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

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

@@ -0,0 +1,77 @@
+from abc import ABCMeta
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical
+
+class BaseTypeDefinition(ARObject):
+    def __init__(self):
+        super().__init__()
+
+
+class BaseTypeDirectDefinition(BaseTypeDefinition):
+    def __init__(self):
+        super().__init__()
+
+        self.baseTypeEncoding = None                # type: BaseTypeEncodingString
+        self.baseTypeSize = None                    # type: ARNumerical
+        self.byteOrder = None                       # type: ByteOrderEnum
+        self.memAlignment = None                    # type: ARNumerical
+        self.nativeDeclaration = None
+
+    def getBaseTypeEncoding(self):
+        return self.baseTypeEncoding
+
+    def setBaseTypeEncoding(self, value):
+        self.baseTypeEncoding = value
+        return self
+
+    def getBaseTypeSize(self):
+        return self.baseTypeSize
+
+    def setBaseTypeSize(self, value):
+        self.baseTypeSize = value
+        return self
+
+    def getByteOrder(self):
+        return self.byteOrder
+
+    def setByteOrder(self, value):
+        self.byteOrder = value
+        return self
+
+    def getMemAlignment(self):
+        return self.memAlignment
+
+    def setMemAlignment(self, value):
+        self.memAlignment = value
+        return self
+
+    def getNativeDeclaration(self):
+        return self.nativeDeclaration
+
+    def setNativeDeclaration(self, value):
+        self.nativeDeclaration = value
+        return self
+
+
+
+class BaseType(ARElement, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == BaseType:
+            raise NotImplementedError("BaseType is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.baseTypeDefinition = BaseTypeDirectDefinition()
+
+    def getBaseTypeDefinition(self):
+        return self.baseTypeDefinition
+
+    def setBaseTypeDefinition(self, value):
+        self.baseTypeDefinition = value
+        return self
+
+
+class SwBaseType(BaseType):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)

armodel/models/{m2_msr.py → M2/MSR/AsamHdo/ComputationMethod.py}

@@ -1,16 +1,31 @@
-from .ar_object import ARLiteral
-from .general_structure import ARObject, ARElement, Limit
-from .ar_ref import RefType
-from abc import ABCMeta
 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.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Limit
 
 class CompuContent(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == CompuContent:
             raise NotImplementedError("CompuContent is an abstract class.")
-        
+
         super().__init__()
 
+
+class CompuConst(ARObject):
+    '''
+    This meta-class represents the fact that the value of a computation method scale is constant.
+    Base            : ARObject
+    Aggregated by   : Compu.compuDefaultValue, CompuScale.compuInverseValue, CompuScaleConstantContents.compuCons
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.compu_const_content_type = None    # type: CompuConstContent
+
+
 class Compu(ARObject):
     def __init__(self):
         super().__init__()
@@ -21,6 +36,7 @@ class Compu(ARObject):
         '''optional'''
         self.compu_default_value = None     # type: CompuConst
 
+
 class CompuConstContent(ARObject, metaclass=ABCMeta):
     '''
     This meta-class represents the fact that the constant value of the computation method can be numerical or textual.
@@ -31,9 +47,10 @@ class CompuConstContent(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == CompuConstContent:
             raise NotImplementedError("CompuConstContent is an abstract class.")
-        
+
         super().__init__()
 
+
 class CompuConstTextContent(CompuConstContent):
     '''
     This meta-class represents the textual content of a scale.
@@ -45,6 +62,7 @@ class CompuConstTextContent(CompuConstContent):
 
         self.vt = None
 
+
 class CompuConstNumericContent(CompuConstContent):
 
     def __init__(self):
@@ -52,30 +70,35 @@ class CompuConstNumericContent(CompuConstContent):
 
         self.v = None
 
-class CompuConst(ARObject):
-    '''
-    This meta-class represents the fact that the value of a computation method scale is constant.
-    Base            : ARObject
-    Aggregated by   : Compu.compuDefaultValue, CompuScale.compuInverseValue, CompuScaleConstantContents.compuCons
-    '''
-    def __init__(self):
-        super().__init__()
-
-        self.compu_const_content_type = None    # type: CompuConstContent
 
 class CompuScaleContents(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == CompuScaleContents:
             raise NotImplementedError("CompuScaleContents is an abstract class.")
-        
+
         super().__init__()
 
+
 class CompuScaleConstantContents(CompuScaleContents):
     def __init__(self):
         super().__init__()
 
         self.compu_const = None     # type: CompuConst
 
+
+class CompuRationalCoeffs(ARObject):
+    '''
+    This meta-class represents the ability to express a rational function by specifying the coefficients of nominator and denominator.
+    Base            : ARObject
+    Aggregated by   : CompuScaleRationalFormula.compuRationalCoeffs
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.compu_denominator = None   # type: CompuNominatorDenominator
+        self.compu_numerator = None     # type: CompuNominatorDenominator
+
+
 class CompuScaleRationalFormula(CompuScaleContents):
     '''
     This meta-class represents the fact that the computation in this scale is represented as rational term.
@@ -85,6 +108,7 @@ class CompuScaleRationalFormula(CompuScaleContents):
 
         self.compu_rational_coeffs = None   # type: CompuRationalCoeffs
 
+
 class CompuNominatorDenominator(ARObject):
     '''
     This class represents the ability to express a polynomial either as Nominator or as Denominator.
@@ -102,17 +126,6 @@ class CompuNominatorDenominator(ARObject):
     def get_vs(self) -> List[float]:
         return self.v
 
-class CompuRationalCoeffs(ARObject):
-    '''
-    This meta-class represents the ability to express a rational function by specifying the coefficients of nominator and denominator.
-    Base            : ARObject
-    Aggregated by   : CompuScaleRationalFormula.compuRationalCoeffs
-    '''
-    def __init__(self):
-        super().__init__()
-
-        self.compu_denominator = None   # type: CompuNominatorDenominator
-        self.compu_numerator = None     # type: CompuNominatorDenominator
 
 class CompuScale(Compu):
     def __init__(self):
@@ -125,6 +138,7 @@ class CompuScale(Compu):
         self.compuScaleContents = None          # type: CompuScaleContents
         self.short_label = None                 # type: ARLiteral
 
+
 class CompuScales(CompuContent):
     def __init__(self):
         super().__init__()
@@ -137,6 +151,7 @@ class CompuScales(CompuContent):
     def getCompuScales(self) -> List[CompuScale]:
         return self.compu_scales
 
+
 class CompuMethod(ARElement):
     CATEGORY_TEXTTABLE = "TEXTTABLE"
 

armodel/models/{global_constraints.py → M2/MSR/AsamHdo/Constraints/GlobalConstraints.py}

@@ -1,8 +1,7 @@
-from .ar_ref import RefType
-from .ar_object import ARNumerical, ARObject
-from .general_structure import Identifiable, Limit
-
 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, Limit, RefType
 
 class InternalConstrs(ARObject):
     def __init__(self):
@@ -11,6 +10,7 @@ class InternalConstrs(ARObject):
         self.lower_limit = None         # type: Limit
         self.upper_limit = None         # type: Limit
 
+
 class PhysConstrs(ARObject):
     def __init__(self):
         super().__init__()
@@ -19,6 +19,7 @@ class PhysConstrs(ARObject):
         self.upper_limit = None         # type: Limit
         self.unit_ref = None            # type: RefType
 
+
 class DataConstrRule(ARObject):
     def __init__(self):
         super().__init__()
@@ -27,6 +28,7 @@ class DataConstrRule(ARObject):
         self.internalConstrs = None     # type: InternalConstrs    
         self.physConstrs = None         # type: PhysConstrs
 
+
 class DataConstr(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)

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

@@ -0,0 +1,60 @@
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from typing import List
+
+class Sd(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.value = ""
+
+    def getGID(self):
+        return self.gid
+
+    def setGID(self, value):
+        self.gid = value
+        return self
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+
+class Sdg(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.sd = []                        # type: List[Sd]
+        self.sdgCaption = None
+        self.sdgContentsTypes = []          # type: List[Sdg]
+
+    def getGID(self):
+        return self.gid
+
+    def setGID(self, value):
+        self.gid = value
+        return self
+
+    def addSd(self, sd: Sd):
+        self.sd.append(sd)
+        return self
+
+    def getSds(self) -> List[Sd]:
+        return self.sd
+
+    def getSdgCaption(self):
+        return self.sdgCaption
+
+    def setSdgCaption(self, value):
+        self.sdgCaption = value
+        return self
+
+    def addSdgContentsType(self, sdg):
+        self.sdgContentsTypes.append(sdg)
+
+    def getSdgContentsTypes(self):
+        return self.sdgContentsTypes

armodel/models/{m2/msr/asam_hdo/units.py → M2/MSR/AsamHdo/Units.py}

@@ -1,7 +1,7 @@
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, ARNumerical, RefType, ARLiteral
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
 
-from ....ar_ref import RefType
-from ....ar_object import ARFloat, ARLiteral, ARNumerical, ARObject
-from ....general_structure import ARElement
 class PhysicalDimension(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)

armodel/models/M2/MSR/CalibrationData/CalibrationValue.py

@@ -0,0 +1,26 @@
+from typing import List
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType
+from ....M2.MSR.DataDictionary.DataDefProperties import ValueList
+
+class SwValues(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._v = []                    # type: List[ARNumerical]
+        self.vt = None                  # type: float
+
+    def addV(self, v: ARNumerical):
+        self._v.append(v)
+
+    def getVs(self) -> List[ARNumerical]:
+        return self._v
+
+
+class SwValueCont(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.sw_arraysize = None         # type: ValueList
+        self.unit_ref = None             # type: RefType
+        self.sw_values_phys = None        # type: SwValues

armodel/models/{m2/msr/data_dictionary/auxillary_objects.py → M2/MSR/DataDictionary/AuxillaryObjects.py}

@@ -1,8 +1,7 @@
-
 from typing import List
-from ....ar_object import ARLiteral, ARObject
-from ....general_structure import Identifiable
-
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 
 class SwAddrMethod(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):

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

@@ -0,0 +1,145 @@
+from typing import List
+from ....M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxisTypeProps
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, ARNumerical, RefType
+
+class SwGenericAxisParam(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.swGenericAxisParamTypeRef = None           # type: RefType
+        self.vfs = []                                   # type: List[ARFloat]
+
+    def getSwGenericAxisParamTypeRef(self):
+        return self.swGenericAxisParamTypeRef
+
+    def setSwGenericAxisParamTypeRef(self, value):
+        self.swGenericAxisParamTypeRef = value
+        return self
+
+    def getVfs(self):
+        return self.vfs
+
+    def addVf(self, value):
+        self.vfs.append(value)
+        return self
+
+class SwAxisGeneric(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.swAxisTypeRef = None                   # type: RefType
+        self.swGenericAxisParams = []               # type: List[SwGenericAxisParam]
+
+    def getSwAxisTypeRef(self):
+        return self.swAxisTypeRef
+
+    def setSwAxisTypeRef(self, value):
+        self.swAxisTypeRef = value
+        return self
+
+    def getSwGenericAxisParams(self):
+        return self.swGenericAxisParams
+
+    def addSwGenericAxisParam(self, value):
+        self.swGenericAxisParams.append(value)
+        return self
+
+class SwAxisIndividual(SwCalprmAxisTypeProps):
+    def __init__(self):
+        super().__init__()
+
+        self.compuMethodRef = None              # type: RefType
+        self.dataConstrRef = None               # type: RefType
+        self.inputVariableTypeRef = None        # type: RefType
+        self.swAxisGeneric = None               # type: SwAxisGeneric
+        self.swMaxAxisPoints = None             # type: ARNumerical
+        self.swMinAxisPoints = None             # type: ARNumerical
+        self.swVariableRefs = []                # type: List
+        self.unitRef = None                     # type: RefType
+
+    def getCompuMethodRef(self):
+        return self.compuMethodRef
+
+    def setCompuMethodRef(self, value):
+        self.compuMethodRef = value
+        return self
+
+    def getDataConstrRef(self):
+        return self.dataConstrRef
+
+    def setDataConstrRef(self, value):
+        self.dataConstrRef = value
+        return self
+
+    def getInputVariableTypeRef(self):
+        return self.inputVariableTypeRef
+
+    def setInputVariableTypeRef(self, value):
+        self.inputVariableTypeRef = value
+        return self
+
+    def getSwAxisGeneric(self):
+        return self.swAxisGeneric
+
+    def setSwAxisGeneric(self, value):
+        self.swAxisGeneric = value
+        return self
+
+    def getSwMaxAxisPoints(self):
+        return self.swMaxAxisPoints
+
+    def setSwMaxAxisPoints(self, value):
+        self.swMaxAxisPoints = value
+        return self
+
+    def getSwMinAxisPoints(self):
+        return self.swMinAxisPoints
+
+    def setSwMinAxisPoints(self, value):
+        self.swMinAxisPoints = value
+        return self
+
+    def getSwVariableRefs(self):
+        return self.swVariableRefs
+
+    def setSwVariableRefs(self, value):
+        self.swVariableRefs = value
+        return self
+
+    def getUnitRef(self):
+        return self.unitRef
+
+    def setUnitRef(self, value):
+        self.unitRef = value
+        return self
+
+
+class SwAxisGrouped(SwCalprmAxisTypeProps):
+    def __init__(self):
+        super().__init__()
+
+        self.sharedAxisTypeRef = None           # type: RefType
+        self.swAxisIndex = None                 # type: ARNumerical
+        self.swCalprmRef = None                 # type: SwCalprmRefProxy
+
+    def getSharedAxisTypeRef(self):
+        return self.sharedAxisTypeRef
+
+    def setSharedAxisTypeRef(self, value):
+        self.sharedAxisTypeRef = value
+        return self
+
+    def getSwAxisIndex(self):
+        return self.swAxisIndex
+
+    def setSwAxisIndex(self, value):
+        self.swAxisIndex = value
+        return self
+
+    def getSwCalprmRef(self):
+        return self.swCalprmRef
+
+    def setSwCalprmRef(self, value):
+        self.swCalprmRef = value
+        return self

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

@@ -0,0 +1,37 @@
+from typing import List
+from abc import ABCMeta
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat
+
+class SwCalprmAxisTypeProps(ARObject, metaclass = ABCMeta):
+    def __init__(self):
+        if type(self) == SwCalprmAxisTypeProps:
+            raise NotImplementedError("SwCalprmAxisTypeProps is an abstract class.")
+
+        super().__init__()
+
+        self.maxGradient = None         # type: ARFloat
+        self.monotony = None            # type: MonotonyEnum
+
+
+class SwCalprmAxis(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.category = None                        # type: CalprmAxisCategoryEnum
+        self.displayFormat = None                   # type: DisplayFormatString
+        self.sw_axis_index = None                   # type: AxisIndexType   
+        self.swCalibrationAccess = None             # type: SwCalibrationAccessEnum
+        self.sw_calprm_axis_type_props = None       # type: SwCalprmAxisTypeProps
+
+class SwCalprmAxisSet(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._swCalprmAxis = []          # type: List[SwCalprmAxis]
+
+    def addSwCalprmAxis(self, axis: SwCalprmAxis):
+        self._swCalprmAxis.append(axis)
+
+    def getSwCalprmAxises(self) -> List[SwCalprmAxis]:
+        return self._swCalprmAxis

armodel/models/{m2/msr/data_dictionary/data_def_properties.py → M2/MSR/DataDictionary/DataDefProperties.py}

@@ -1,11 +1,9 @@
 from typing import List
-
-from ...autosar_templates.common_structure import ValueSpecification
-from ....calibration import SwCalprmAxisSet
-from ....ar_ref import RefType
-from ....annotation import Annotation
-from ....ar_object import ARFloat, ARLiteral, ARObject
-
+from ....M2.MSR.Documentation.Annotation import Annotation
+from ....M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxisSet
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, RefType, ARLiteral
+from ....M2.AUTOSARTemplates.CommonStructure import ValueSpecification
 
 class SwDataDefPropsConditional(ARObject):
     '''
@@ -261,9 +259,6 @@ class SwDataDefProps(ARObject):
         self.valueAxisDataTypeRef = value
         return self
 
-        
-        
-
 class SwPointerTargetProps(ARObject):
     def __init__(self):
         super().__init__()
@@ -293,3 +288,17 @@ class SwPointerTargetProps(ARObject):
         self.targetCategory = value
         return self
 
+
+class ValueList(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.v = None                                       # type: ARFloat
+        self._vf = []                                       # type: List[ARLiteral]
+
+    def addVf(self, vf: ARLiteral):
+        self._vf.append(vf)
+
+    def getVfs(self) -> List[ARLiteral]:
+        return sorted(self._vf)
+