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

armodel/models/ar_ref.py

@@ -7,17 +7,81 @@ class RefType(ARObject):
         self.dest = ""
         self.value = ""
 
+    def getDest(self):
+        return self.dest
+
+    def setDest(self, value):
+        self.dest = value
+        return self
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
 class TRefType(RefType):
     def __init__(self):
         super().__init__()
-        
+
+class AnyInstanceRef(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                             # type: RefType
+        self.contextElementRef = None                   # type: RefType
+        self.targetRef = None                           # type: RefType
+
+    def getBaseRef(self) -> RefType:
+        return self.baseRef
+
+    def setBaseRef(self, value: RefType):
+        self.baseRef = value
+        return self
+
+    def getContextElementRef(self) -> RefType:
+        return self.contextElementRef
+
+    def setContextElementRef(self, value: RefType):
+        self.contextElementRef = value
+        return self
+
+    def getTargetRef(self) -> RefType:
+        return self.targetRef
+
+    def setTargetRef(self, value:RefType):
+        self.targetRef = value
+        return self
 
 class AutosarVariableRef(ARObject):
     def __init__(self):
         super().__init__()
-        self.autosar_variable_iref = None               # type: VariableInAtomicSWCTypeInstanceRef 
-        self.autosar_variable_in_impl_datatype = None   # type: ArVariableInImplementationDataInstanceRef
-        self.local_variable_ref = None
+
+        self.autosarVariableIRef = None             # type: VariableInAtomicSWCTypeInstanceRef 
+        self.autosarVariableInImplDatatype = None   # type: ArVariableInImplementationDataInstanceRef
+        self.localVariableRef = None
+
+    def getAutosarVariableIRef(self):
+        return self.autosarVariableIRef
+
+    def setAutosarVariableIRef(self, value):
+        self.autosarVariableIRef = value
+        return self
+
+    def getAutosarVariableInImplDatatype(self):
+        return self.autosarVariableInImplDatatype
+
+    def setAutosarVariableInImplDatatype(self, value):
+        self.autosarVariableInImplDatatype = value
+        return self
+
+    def getLocalVariableRef(self):
+        return self.localVariableRef
+
+    def setLocalVariableRef(self, value):
+        self.localVariableRef = value
+        return self
 
 class AutosarParameterRef(ARObject):
     def __init__(self):
@@ -32,16 +96,51 @@ class AtpInstanceRef(ARObject, metaclass=ABCMeta):
             raise NotImplementedError("AtpInstanceRef is an abstract class.")
         
         super().__init__()
-
 class VariableInAtomicSWCTypeInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
 
-        self.base_ref = None                            # type: RefType
-        self.context_data_prototype_ref = None          # type: RefType
-        self.port_prototype_ref = None                  # type: RefType
-        self.root_variable_data_prototype_ref = None    # type: RefType
-        self.target_data_prototype_ref = None           # type: RefType
+        self.baseRef = None                             # type: RefType
+        self.contextDataPrototypeRefs = []              # type: List[RefType]
+        self.portPrototypeRef = None                    # type: RefType
+        self.rootVariableDataPrototypeRef = None        # type: RefType
+        self.targetDataPrototypeRef = None              # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextDataPrototypeRefs(self):
+        return self.contextDataPrototypeRefs
+
+    def addContextDataPrototypeRef(self, value):
+        self.contextDataPrototypeRefs.append(value)
+        return self
+
+    def getPortPrototypeRef(self):
+        return self.portPrototypeRef
+
+    def setPortPrototypeRef(self, value):
+        self.portPrototypeRef = value
+        return self
+
+    def getRootVariableDataPrototypeRef(self):
+        return self.rootVariableDataPrototypeRef
+
+    def setRootVariableDataPrototypeRef(self, value):
+        self.rootVariableDataPrototypeRef = value
+        return self
+
+    def getTargetDataPrototypeRef(self):
+        return self.targetDataPrototypeRef
+
+    def setTargetDataPrototypeRef(self, value):
+        self.targetDataPrototypeRef = value
+        return self
+
 
 class PortInCompositionTypeInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
     def __init__(self):
@@ -89,36 +188,6 @@ class ROperationInAtomicSwcInstanceRef(OperationInAtomicSwcInstanceRef):
         self.context_r_port_ref = None              # type: RefType
         self.target_required_operation_ref = None   # type: RefType
 
-class VariableInAtomicSwcInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
-    def __init__(self):
-        if type(self) == OperationInAtomicSwcInstanceRef:
-            raise NotImplementedError("OperationInAtomicSwcInstanceRef is an abstract class.")
-
-        super().__init__()
-
-class RVariableInAtomicSwcInstanceRef(VariableInAtomicSwcInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.context_r_port_ref = None              # type: RefType
-        self.target_data_element_ref = None         # type: RefType
-
-class RVariableInAtomicSwcInstanceRef(VariableInAtomicSwcInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.context_r_port_ref = None              # type: RefType
-        self.target_data_element_ref = None         # type: RefType
-
-class RModeInAtomicSwcInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.base_ref = None                                        # type: RefType
-        self.context_mode_declaration_group_prototype_ref = None    # type: RefType
-        self.context_port_ref = None                                # type: RefType
-        self.target_mode_declaration_ref = None                     # type: RefType
-
 class ParameterInAtomicSWCTypeInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
@@ -156,25 +225,3 @@ class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
         self.context_port_ref = None                                # type: RefType
         self.target_data_prototype_ref = None                       # type: RefType 
 
-class RModeGroupInAtomicSWCInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.context_r_port = None                                  # type: RefType
-        self.target_mode_group = None                               # type: RefType
-
-    @property
-    def contextRPort(self) -> RefType:
-        return self.context_r_port
-    
-    @contextRPort.setter
-    def contextRPort(self, value: RefType):
-        self.context_r_port = value
-
-    @property
-    def targetModeGroup(self) -> RefType:
-        return self.target_mode_group
-    
-    @targetModeGroup.setter
-    def targetModeGroup(self, value: RefType):
-        self.target_mode_group = value

armodel/models/bsw_module_template.py

@@ -15,14 +15,35 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
 
         self.accessedModeGroupRefs = []                 # type: List[RefType]
         self.activationPointRefs = []                   # type: List[RefType]
-        self.implemented_entry_ref = None                 # type: RefType
-        self._managedModeGroupRefs = []                 # type: List[RefType]
+        self.implementedEntryRef = None                 # type: RefType
+        self.managedModeGroupRefs = []                  # type: List[RefType]
+
+    def getAccessedModeGroupRefs(self):
+        return self.accessedModeGroupRefs
+
+    def addAccessedModeGroupRefs(self, value):
+        self.accessedModeGroupRefs.append(value)
+        return self
+
+    def getActivationPointRefs(self):
+        return self.activationPointRefs
+
+    def addActivationPointRefs(self, value):
+        self.activationPointRefs.append(value)
+        return self
+
+    def getImplementedEntryRef(self):
+        return self.implementedEntryRef
+
+    def setImplementedEntryRef(self, value):
+        self.implementedEntryRef = value
+        return self
 
     def addManagedModeGroupRef(self, ref: RefType):
-        self._managedModeGroupRefs.append(ref)
+        self.managedModeGroupRefs.append(ref)
 
     def getManagedModeGroupRefs(self) -> List[RefType]:
-        return self._managedModeGroupRefs
+        return self.managedModeGroupRefs
 
 class BswCalledEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
@@ -235,7 +256,7 @@ class BswInternalBehavior(InternalBehavior):
     def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
         return self.included_data_type_sets
 
-class BswModuleDescription(AtpStructureElement):
+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
@@ -262,15 +283,17 @@ class BswModuleDescription(AtpStructureElement):
     def getImplementedEntries(self) -> List[RefType]:
         return self._implementedEntryRefs
 
-    @property
-    def category(self) -> str:
-        return self._category
-
-    @category.setter
-    def category(self, value:str):
-        if value not in ("BSW_MODULE", "BSW_CLUSTER", "LIBRARY"):
-            raise ValueError("Invalid category <%s> of BswModuleDescription <%s>" % (value, self.short_name))
-        self._category = value
+    #@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):

armodel/models/common_structure.py

@@ -3,141 +3,72 @@
 from abc import ABCMeta
 from typing import List
 
-from .ar_object import ARFloat, ARLiteral, ARNumerical
-from .general_structure import ARObject, ARElement, Identifiable
-from .data_dictionary import SwDataDefProps
+from .ar_object import ARBoolean, ARFloat, ARLiteral, ARNumerical
+from .general_structure import ARObject, Identifiable
+from .m2.msr.data_dictionary.data_def_properties import SwDataDefProps
 from .ar_ref import RefType, TRefType
 
 import re
 
-class ValueSpecification(ARObject, metaclass=ABCMeta):
-    '''
-    Base class for expressions leading to a value which can be used to initialize a data object.
-    
-    Base        : ARObject
-    Subclasses  : AbstractRuleBasedValueSpecification, ApplicationValueSpecification, CompositeValueSpecification,
-                  ConstantReference, NotAvailableValueSpecification, NumericalValueSpecification, ReferenceValueSpecification, 
-                  TextValueSpecification
-    '''
-    def __init__(self):
-        if type(self) == ValueSpecification:
-            raise NotImplementedError("ValueSpecification is an abstract class.")
-        
-        super().__init__()
-
-        self.short_label = None
-
-class CompositeRuleBasedValueArgument(ValueSpecification, metaclass=ABCMeta):
-    '''
-    This meta-class has the ability to serve as the abstract base class for ValueSpecifications that can be
-    used for compound primitive data types.
-
-    Base        : ARObject
-    Subclasses  : ApplicationRuleBasedValueSpecification, ApplicationValueSpecification
-    '''
-    def __init__(self):
-        if type(self) == CompositeRuleBasedValueArgument:
-            raise NotImplementedError("CompositeRuleBasedValueArgument is an abstract class.")
-        
-        super().__init__()
-
-class CompositeValueSpecification(ValueSpecification, metaclass=ABCMeta):
-    '''
-    This abstract meta-class acts a base class for ValueSpecifications that have a composite form.
-
-    Base        : ARObject, ValueSpecification
-    Subclasses  : ArrayValueSpecification, RecordValueSpecification
-    '''            
-    def __init__(self):
-        if type(self) == CompositeValueSpecification:
-            raise NotImplementedError("CompositeValueSpecification is an abstract class.")
-        
-        super().__init__()
-
-class ApplicationValueSpecification(CompositeRuleBasedValueArgument):
-    '''
-    This meta-class represents values for DataPrototypes typed by ApplicationDataTypes (this includes in
-    particular compound primitives).
-    For further details refer to ASAM CDF 2.0. This meta-class corresponds to some extent with
-    SW-INSTANCE in ASAM CDF 2.0.
-
-    Base ARObject, CompositeRuleBasedValueArgument, ValueSpecification    
-    '''
-    def __init__(self):
-        super().__init__()
-
-        self.category = None
-        self.sw_Axis_cont = []
-        self.sw_value_cont = None
-
-class RecordValueSpecification(CompositeValueSpecification):
-    '''
-    Specifies the values for a record.
-    
-    Base : ARObject, CompositeValueSpecification, ValueSpecification
-    '''
-    def __init__(self):
-        super().__init__()        
-
-        self._fields = []
-
-    def add_field(self, field: ValueSpecification):
-        self._fields.append(field)
-
-    def get_fields(self) -> List[ValueSpecification]:
-        return self._fields
+class AbstractImplementationDataTypeElement(Identifiable):
+    def __init__(self, parent, short_name: str):
+        super().__init__(parent, short_name)
 
-class TextValueSpecification(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
+    ARRAY_SIZE_SEMANTICS_FIXED_SIZE = "FIXED-SIZE"
+    ARRAY_SIZE_SEMANTICS_VARIABLE_SIZE = "VARIABLE_SIZE"
 
-        self.value = None        # type: str
+    def __init__(self, parent, short_name: str):
+        super().__init__(parent, short_name)
 
-class NumericalValueSpecification(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+        self.arrayImplPolicy = None             # type: ARLiteral
+        self.arraySize = None                   # type: ARNumerical
+        self.arraySizeHandling = None           # type: ARLiteral
+        self.arraySizeSemantics = None          # type: ARLiteral
+        self.isOptional = None                  # type: ARBoolean
+        self.swDataDefProps = None              # type: SwDataDefProps
 
-        self.value = None        # type: ARFloat  
+    def getArrayImplPolicy(self):
+        return self.arrayImplPolicy
 
-class ArrayValueSpecification(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+    def setArrayImplPolicy(self, value):
+        self.arrayImplPolicy = value
+        return self
 
-        self._element = []       # type: List[ValueSpecification]
+    def getArraySize(self):
+        return self.arraySize
 
-    def add_element(self, element: ValueSpecification):
-        self._element.append(element)
+    def setArraySize(self, value):
+        self.arraySize = value
+        return self
 
-    def get_elements(self) -> List[ValueSpecification]:
-        return self._element
+    def getArraySizeHandling(self):
+        return self.arraySizeHandling
 
-class ConstantSpecification(ARElement):
-    def __init__(self, parent, short_name):
-        super().__init__(parent, short_name)
+    def setArraySizeHandling(self, value):
+        self.arraySizeHandling = value
+        return self
 
-        self.value_spec = None  # type: ValueSpecification
+    def getArraySizeSemantics(self):
+        return self.arraySizeSemantics
 
-class ConstantReference(ValueSpecification):
-    def __init__(self):
-        super().__init__()
+    def setArraySizeSemantics(self, value):
+        self.arraySizeSemantics = value
+        return self
 
-        self.constant_ref = None
+    def getIsOptional(self):
+        return self.isOptional
 
-class AbstractImplementationDataTypeElement(Identifiable):
-    def __init__(self, parent, short_name: str):
-        super().__init__(parent, short_name)
-
-class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
-    ARRAY_SIZE_SEMANTICS_FIXED_SIZE = "FIXED-SIZE"
-    ARRAY_SIZE_SEMANTICS_VARIABLE_SIZE = "VARIABLE_SIZE"
+    def setIsOptional(self, value):
+        self.isOptional = value
+        return self
 
-    def __init__(self, parent, short_name: str):
-        super().__init__(parent, short_name)
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
 
-        self.arraySize = None               # type: int
-        self.array_size_semantics = None      # type: str
-        self.isOptional = None              # type: bool
-        self.sw_data_def_props = None          # type: SwDataDefProps
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
     
     def createImplementationDataTypeElement(self, short_name: str): # type: (...) -> ImplementationDataTypeElement
         if (short_name not in self.elements):
@@ -190,41 +121,54 @@ 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.activation_reason = None               # *
-        self.minimum_start_interval = None          # type: ARFloat
-        self.reentrancy_level = None                # 
-        self.can_enter_exclusive_area_refs = []     # type: List[RefType]  
-        self.sw_addr_method_ref = None              # type: RefType
+        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.minimum_start_interval is not None:
-            return int(self.minimum_start_interval.getValue() * 1000)
+        if self.minimumStartInterval is not None:
+            return int(self.minimumStartInterval.getValue() * 1000)
         return None
 
-    @property
-    def minimumStartInterval(self) -> ARFloat:
-        return self.minimum_start_interval
-    
-    @minimumStartInterval.setter
-    def minimumStartInterval(self, value: ARFloat):
-        self.minimum_start_interval = value
-    
-    @property
-    def swAddrMethodRef(self) -> RefType:
-        return self.sw_addr_method_ref
-    
-    @swAddrMethodRef.setter
-    def swAddrMethodRef(self, ref: RefType):
-        self.sw_addr_method_ref = ref
-
     def addCanEnterExclusiveAreaRef(self, ref: RefType):
-        self.can_enter_exclusive_area_refs.append(ref)
+        self.canEnterExclusiveAreaRefs.append(ref)
 
     def getCanEnterExclusiveAreaRefs(self):
-        return self.can_enter_exclusive_area_refs
+        return self.canEnterExclusiveAreaRefs
     
 class ModeDeclarationGroupPrototype(Identifiable):
     """
@@ -247,21 +191,57 @@ class ModeDeclarationGroupPrototype(Identifiable):
             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
+
 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.options = []                   # type: List[ARLiteral]
         self.swAddrMethodRef = None         # type: RefType
         self.symbol = None                  # type: ARLiteral
 
-    def addOption(self, option: ARLiteral):
-        self._options.append(option)
+    def getAlignment(self):
+        return self.alignment
 
-    def getOptions(self) -> List[ARLiteral]:
-        return self._options
+    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:
@@ -282,7 +262,12 @@ class MemorySection(Identifiable):
                     
             if not match:
                 raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.short_name))
-        
+            
+    def addOption(self, option: ARLiteral):
+        self.options.append(option)
+
+    def getOptions(self) -> List[ARLiteral]:
+        return self.options
 
 class ResourceConsumption(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/communication.py

@@ -1,5 +1,5 @@
 
-from .data_dictionary import SwDataDefProps
+from .m2.msr.data_dictionary.data_def_properties import SwDataDefProps
 from .ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef
 from .ar_object import ARObject