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

armodel/models/general_structure.py

@@ -1,6 +1,7 @@
 from abc import ABCMeta
 from typing import List
 
+from .annotation import Annotation
 from .ar_ref import RefType
 from .multilanguage_data import MultiLanguageOverviewParagraph, MultilanguageLongName
 from .ar_object import ARObject
@@ -12,21 +13,55 @@ class Sd(ARObject):
         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.sdg_caption = None
-        self.sdg_contents_type = None
+        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
+    
 class AdminData(ARObject):
     def __init__(self):
         super().__init__()
@@ -48,24 +83,49 @@ class Referrable(ARObject, metaclass=ABCMeta):
             raise NotImplementedError("Referrable is an abstract class.")
         ARObject.__init__(self)
 
-        self.parent = parent
+        self._parent = parent
         self.short_name = short_name
 
+    @property
+    def parent(self):
+        return self._parent
+
+    @parent.setter
+    def parent(self, value):
+        self._parent = value
+
+    @property
+    def shortName(self):
+        return self.short_name
+
+    @shortName.setter
+    def shortName(self, value):
+        self.short_name = value
+
+    def getShortName(self) -> str:
+        return self.short_name
+
     @property
     def full_name(self) -> str:
-        return self.parent.full_name + "/" + self.short_name
+        return self._parent.full_name + "/" + self.short_name
 
-class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
+class MultilanguageReferrable(Referrable, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == MultilanguageReferrable:
             raise NotImplementedError("MultilanguageReferrable is an abstract class.")
         
         super().__init__(parent, short_name)
 
-        self.parent = parent
-        self.long_name = None            # type: MultilanguageLongName
+        #self._parent = parent
+        self.longName = None            # type: MultilanguageLongName
 
-class CollectableElement(ARObject, metaclass=ABCMeta):
+    def getLongName(self) -> MultilanguageLongName:
+        return self.longName
+
+    def setLongName(self, value: MultilanguageLongName):
+        self.longName = value
+        return self
+class CollectableElement(ARObject, metaclass = ABCMeta):
     def __init__(self):
         if type(self) == CollectableElement:
             raise NotImplementedError("CollectableElement is an abstract class.")
@@ -95,10 +155,59 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
-        self.admin_data = None      # type: AdminData
-        self._category = None
+        self.annotations = []       # type: List[Annotation]
+        self.adminData = None       # type: AdminData
+        self.category = None
         self.desc = None            # type: MultiLanguageOverviewParagraph
 
+    def getAdminData(self):
+        return self.adminData
+
+    def setAdminData(self, value):
+        self.adminData = value
+        return self
+    
+    def getDesc(self):
+        return self.desc
+
+    def setDesc(self, value):
+        self.desc = value
+        return self
+
+    def getCategory(self):
+        return self.category
+
+    def setCategory(self, value):
+        self.category = value
+        return self
+    
+    def addAnnotation(self, annotation: Annotation):
+        self.annotations.append(annotation)
+        return self
+    
+    def getAnnotations(self) -> List[Annotation]:
+        return self.annotations
+    
+class Describable(ARObject, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == Describable:
+            raise NotImplementedError("Describable is an abstract class.")
+        
+        super().__init__()
+
+        self._desc = None
+        self._category = None
+        self._adminData = None
+        self._introduction = None
+
+    @property
+    def desc(self):
+        return self._desc
+
+    @desc.setter
+    def desc(self, value):
+        self._desc = value
+
     @property
     def category(self):
         return self._category

armodel/models/implementation.py

@@ -17,13 +17,12 @@ class EngineeringObject(ARObject, metaclass=ABCMeta):
         self.revision_label = None           # type: ARLiteral
         self.short_label = None              # type: ARLiteral
 
-    def setCategory(self, category: ARLiteral):
+    def setCategory(self, category: any):
         if isinstance(category, ARLiteral):
             self.category = category
         else:
             self.category = ARLiteral()
             self.category.setValue(str(category))
-            
         return self
     
     def getCategory(self) -> ARLiteral:
@@ -86,7 +85,7 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
         self.programming_language = None                    # type: ARLiteral
         self.required_artifacts = []           
         self.required_generator_tools = []
-        self._resource_consumption = None                   # type: ResourceConsumption
+        self.resource_consumption = None                    # type: ResourceConsumption
         self.sw_version = ""                                # type: ARLiteral
         self.swc_bsw_mapping_ref = None                     # type: RefType
         self.used_code_generator = None                     # type: ARLiteral
@@ -103,11 +102,11 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
 
     def setResourceConsumption(self, consumption: ResourceConsumption):
         self.elements[consumption.short_name] = consumption
-        self._resource_consumption = consumption
+        self.resource_consumption = consumption
         return self
     
     def getResourceConsumption(self) -> ResourceConsumption:
-        return self._resource_consumption
+        return self.resource_consumption
 
 class BswImplementation(Implementation):
     def __init__(self, parent: ARObject, short_name: str) -> None:

armodel/models/internal_behavior.py

@@ -0,0 +1,63 @@
+from abc import ABCMeta
+from typing import List
+
+from .ar_object import ARLiteral, ARObject
+from .ar_ref import RefType
+from .common_structure import ExclusiveArea
+from .data_prototype import ParameterDataPrototype
+from .general_structure import Identifiable
+
+class IncludedDataTypeSet(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.data_type_refs = []            # type: List[RefType]
+        self.literal_prefix = None          # type: ARLiteral
+
+    def addDataTypeRef(self, ref_type: RefType):
+        self.data_type_refs.append(ref_type)
+
+    def getDataTypeRefs(self) -> List[RefType]:
+        return self.data_type_refs
+    
+    @property
+    def literalPrefix(self) -> ARLiteral:
+        return self.literal_prefix
+    
+    @literalPrefix.setter
+    def literalPrefix(self, value: ARLiteral):
+        self.literal_prefix = value
+
+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

armodel/models/m2/autosar_templates/common_structure/__init__.py

@@ -0,0 +1,188 @@
+from abc import ABCMeta
+from typing import List
+
+from armodel.models.general_structure import ARElement
+from ....ar_object import ARLiteral, ARNumerical, ARObject
+
+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.shortLabel = None
+
+    def getShortLabel(self):
+        return self.shortLabel
+
+    def setShortLabel(self, value):
+        self.shortLabel = value
+        return self
+    
+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 CompositeRuleBasedValueArgument(ARObject, 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 ApplicationValueSpecification(CompositeRuleBasedValueArgument, ValueSpecification):
+    '''
+    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):
+        
+        CompositeRuleBasedValueArgument.__init__(self)
+        ValueSpecification.__init__(self)
+
+        self.category = None
+        self.swAxisCont = []
+        self.swValueCont = None
+
+    def getCategory(self):
+        return self.category
+
+    def setCategory(self, value):
+        self.category = value
+        return self
+
+    def getSwAxisCont(self):
+        return self.swAxisCont
+
+    def setSwAxisCont(self, value):
+        self.swAxisCont = value
+        return self
+
+    def getSwValueCont(self):
+        return self.swValueCont
+
+    def setSwValueCont(self, value):
+        self.swValueCont = value
+        return self
+
+
+class RecordValueSpecification(CompositeValueSpecification):
+    '''
+    Specifies the values for a record.
+    
+    Base : ARObject, CompositeValueSpecification, ValueSpecification
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.fields = []
+
+    def addField(self, field: ValueSpecification):
+        self.fields.append(field)
+
+    def getFields(self) -> List[ValueSpecification]:
+        return self.fields
+    
+class TextValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None               # type: ARLiteral
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+
+class NumericalValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None               # type: ARNumerical  
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+
+class ArrayValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.element = []                                   # type: List[ValueSpecification]
+        self.intendedPartialInitializationCount = None
+
+    def getIntendedPartialInitializationCount(self):
+        return self.intendedPartialInitializationCount
+
+    def setIntendedPartialInitializationCount(self, value):
+        self.intendedPartialInitializationCount = value
+        return self
+
+    def addElement(self, element: ValueSpecification):
+        self.element.append(element)
+
+    def getElements(self) -> List[ValueSpecification]:
+        return self.element
+
+class ConstantSpecification(ARElement):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.valueSpec = None                  # type: ValueSpecification
+
+    def getValueSpec(self):
+        return self.valueSpec
+
+    def setValueSpec(self, value):
+        self.valueSpec = value
+        return self
+
+
+class ConstantReference(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.constantRef = None                 # type: RefType
+
+    def getConstantRef(self):
+        return self.constantRef
+
+    def setConstantRef(self, value):
+        self.constantRef = value
+        return self