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

armodel/models/ar_ref.py

@@ -1,5 +1,3 @@
-from abc import ABCMeta
-from typing import List
 from .ar_object import ARObject
 
 class RefType(ARObject):
@@ -25,203 +23,3 @@ 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.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):
-        super().__init__()
-
-        self.autosar_parameter_iref = None          # type: ParameterInAtomicSWCTypeInstanceRef
-        self.local_parameter_ref = None             # type: RefType
-
-class AtpInstanceRef(ARObject, metaclass=ABCMeta):
-    def __init__(self):
-        if type(self) == AtpInstanceRef:
-            raise NotImplementedError("AtpInstanceRef is an abstract class.")
-        
-        super().__init__()
-class VariableInAtomicSWCTypeInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        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):
-        if type(self) == PortInCompositionTypeInstanceRef:
-            raise NotImplementedError("PortInCompositionTypeInstanceRef is an abstract class.")
-        super().__init__()
-
-        self.abstract_context_component_ref = None  # type: RefType
-        self.base_ref = None                        # type: RefType
-        self.target_port_ref = None                 # type: RefType
-
-class PPortInCompositionInstanceRef(PortInCompositionTypeInstanceRef):
-    def __init__(self):
-        super().__init__()
-        self.context_component_ref = None   # type: RefType
-        self.target_p_port_ref     = None   # type: RefType
-
-class RPortInCompositionInstanceRef(PortInCompositionTypeInstanceRef):
-    def __init__(self):
-        super().__init__()
-        self.context_component_ref = None   # type: RefType
-        self.target_r_port_ref     = None   # type: RefType
-
-class ArVariableInImplementationDataInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-        self.port_prototype_ref = None          # type: RefType
-        self.target_data_prototype_ref = None   # type: RefType
-
-class OperationInAtomicSwcInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
-    def __init__(self):
-        if type(self) == OperationInAtomicSwcInstanceRef:
-            raise NotImplementedError("OperationInAtomicSwcInstanceRef is an abstract class.")
-        super().__init__()
-
-class POperationInAtomicSwcInstanceRef(OperationInAtomicSwcInstanceRef):
-    def __init__(self):
-        super().__init__()
-        self.context_p_port_ref = None              # type: RefType
-        self.target_provided_operation_ref = None   # type: RefType
-
-class ROperationInAtomicSwcInstanceRef(OperationInAtomicSwcInstanceRef):
-    def __init__(self):
-        super().__init__()
-        self.context_r_port_ref = None              # type: RefType
-        self.target_required_operation_ref = None   # type: RefType
-
-class ParameterInAtomicSWCTypeInstanceRef(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_parameter_data_prototype_ref = None               # type: RefType
-        self.target_data_prototype_ref = None                       # type: RefType
-
-class ApplicationCompositeElementInPortInterfaceInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.base_ref = None                                        # type: RefType
-        self.context_data_prototype_ref = None                      # type: RefType
-        self.root_data_prototype_ref = None                         # type: RefType
-        self.target_data_prototype_ref = None                       # type: RefType
-
-class InnerPortGroupInCompositionInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.baseRef = None                                        # type: RefType
-        self.contextRef = None                                     # type: RefType
-        self.targetRef = None                                      # type: RefType
-
-class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.base_ref = None                                        # type: RefType
-        self.context_component_refs = []                            # type: List[RefType]
-        self.context_composition_ref = None                         # type: RefType
-        self.context_port_ref = None                                # type: RefType
-        self.target_data_prototype_ref = None                       # type: RefType 
-

armodel/models/common_structure.py

@@ -10,74 +10,6 @@ from .ar_ref import RefType, TRefType
 
 import re
 
-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 __init__(self, parent, short_name: str):
-        super().__init__(parent, short_name)
-
-        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
-
-    def getArrayImplPolicy(self):
-        return self.arrayImplPolicy
-
-    def setArrayImplPolicy(self, value):
-        self.arrayImplPolicy = value
-        return self
-
-    def getArraySize(self):
-        return self.arraySize
-
-    def setArraySize(self, value):
-        self.arraySize = value
-        return self
-
-    def getArraySizeHandling(self):
-        return self.arraySizeHandling
-
-    def setArraySizeHandling(self, value):
-        self.arraySizeHandling = value
-        return self
-
-    def getArraySizeSemantics(self):
-        return self.arraySizeSemantics
-
-    def setArraySizeSemantics(self, value):
-        self.arraySizeSemantics = value
-        return self
-
-    def getIsOptional(self):
-        return self.isOptional
-
-    def setIsOptional(self, value):
-        self.isOptional = value
-        return self
-
-    def getSwDataDefProps(self):
-        return self.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):
-            event = ImplementationDataTypeElement(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
-    
-    def getImplementationDataTypeElements(self):                    # type：(...) -> List[ImplementationDataTypeElement]
-        return list(filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values()))
 
 class ExclusiveArea(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -249,9 +181,9 @@ class MemorySection(Identifiable):
 
     @alignment.setter
     def alignment(self, value: ARLiteral):
-        if value is not None:
+        if value is not None and value.getValue() != "":
             match = False
-            if value.value in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
+            if value.getValue() in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
                 self._alignment = value
                 match = True
             else:
@@ -261,7 +193,7 @@ class MemorySection(Identifiable):
                     match = True
                     
             if not match:
-                raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.short_name))
+                raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.getShortName()))
             
     def addOption(self, option: ARLiteral):
         self.options.append(option)

armodel/models/communication.py

@@ -1,6 +1,6 @@
 
+from .m2.autosar_templates.sw_component_template.port_interface.instance_refs import ApplicationCompositeElementInPortInterfaceInstanceRef
 from .m2.msr.data_dictionary.data_def_properties import SwDataDefProps
-from .ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef
 from .ar_object import ARObject
 
 class TransmissionAcknowledgementRequest(ARObject):

armodel/models/datatype.py

@@ -1,24 +1,12 @@
 from abc import ABCMeta
 from typing import List
 
+from .m2.msr.data_dictionary.data_def_properties import SwDataDefProps
 from .ar_object import ARLiteral, ARNumerical
 from .ar_ref import RefType
-from .ar_package import Referrable
 from .general_structure import ARElement, ARObject
-from .data_prototype import ApplicationCompositeElementDataPrototype, ApplicationRecordElement
-from .common_structure import ImplementationDataTypeElement, ModeRequestTypeMap
-
-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 = ""
-
-class SymbolProps(ImplementationProps):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
+from .m2.autosar_templates.sw_component_template.data_type.data_prototypes import ApplicationCompositeElementDataPrototype, ApplicationRecordElement
+from .common_structure import ModeRequestTypeMap
 
 class BaseTypeDefinition(ARObject):
     def __init__(self):
@@ -29,9 +17,9 @@ class BaseTypeDirectDefinition(BaseTypeDefinition):
         super().__init__()
 
         self.base_type_encoding = None
-        self.base_type_size = None                # type: ARNumerical
-        self.byteOrder = None                   # type: str
-        self.mem_alignment = None                # type: ARNumerical
+        self.base_type_size = None                  # type: ARNumerical
+        self.byteOrder = None                       # type: str
+        self.mem_alignment = None                   # type: ARNumerical
         self.native_declaration = None      
 
 class BaseType(ARElement, metaclass=ABCMeta):
@@ -146,62 +134,9 @@ class ApplicationRecordDataType(ApplicationCompositeDataType):
     def getApplicationRecordElements(self) -> List[ApplicationRecordElement]:
         return self.record_elements
 
-class AbstractImplementationDataType(AutosarDataType, metaclass=ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == AbstractImplementationDataType:
-            raise NotImplementedError("AbstractImplementationDataType is an abstract class.")
-
-        super().__init__(parent, short_name)
-
-
-class ImplementationDataType(AbstractImplementationDataType):
-    CATEGORY_TYPE_REFERENCE = "TYPE_REFERENCE"
-    CATEGORY_TYPE_VALUE = "VALUE"
-    CATEGORY_TYPE_STRUCTURE = "STRUCTURE"
-    CATEGORY_DATA_REFERENCE = "DATA_REFERENCE"
-    CATEGORY_ARRAY = "ARRAY"
-
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-        
-        self.sub_elements = []      # type: List[str]
-        self.symbol_props = None    # type: ARLiteral
-        self._type_emitter = None    # type: ARLiteral
-
-        self._array_type = None     # ImplementationDataType
-
-    #type:  ImplementationDataTypeElement
-    def createImplementationDataTypeElement(self, short_name: str):
-        self.sub_elements.append(short_name)
-        if (short_name not in self.elements):
-            event = ImplementationDataTypeElement(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
-
-    def getImplementationDataTypeElements(self) -> List[ImplementationDataTypeElement]:
-        elements = []
-        for sub_element in self.sub_elements:
-            elements.append(self.elements[sub_element])
-        return elements
-        # return filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values())
-
-    def getArrayElementType(self) -> str:
-        return self._array_type
-
-    def setArrayElementType(self, type: str):
-        self._array_type = type
-        return self
-
-    def setTypeEmitter(self, emitter: str):
-        self._type_emitter = emitter
-        return self
-    
-    def getTypeEmitter(self) -> str:
-        return self._type_emitter
-
-
 class DataTypeMap(ARObject):
     def __init__(self):
+
         self.application_data_type_ref = None       # type: RefType
         self.implementation_data_type_ref = None    # type: RefType
 

armodel/models/end_to_end_protection.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from .ar_ref import VariableDataPrototypeInSystemInstanceRef
+from .m2.autosar_templates.system_template.instance_refs import VariableDataPrototypeInSystemInstanceRef
 from .ar_object import ARNumerical, ARObject
 from .general_structure import Identifiable
 

armodel/models/general_structure.py

@@ -4,7 +4,7 @@ from typing import List
 from .annotation import Annotation
 from .ar_ref import RefType
 from .multilanguage_data import MultiLanguageOverviewParagraph, MultilanguageLongName
-from .ar_object import ARObject
+from .ar_object import ARObject, ARLiteral
 
 class Sd(ARObject):
     def __init__(self):
@@ -108,7 +108,10 @@ class Referrable(ARObject, metaclass=ABCMeta):
     @property
     def full_name(self) -> str:
         return self._parent.full_name + "/" + self.short_name
-
+    
+    def getFullName(self) -> str:
+        return self.full_name
+    
 class MultilanguageReferrable(Referrable, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == MultilanguageReferrable:
@@ -142,6 +145,9 @@ class CollectableElement(ARObject, metaclass = ABCMeta):
 
     def getElements(self):
         return self.elements.values()
+    
+    def addElement(self, element: Referrable):
+        self.elements[element.getShortName()] = element
 
     def getElement(self, short_name: str) -> Referrable:
         if (short_name not in self.elements):
@@ -157,7 +163,7 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
 
         self.annotations = []       # type: List[Annotation]
         self.adminData = None       # type: AdminData
-        self.category = None
+        self.category = None        # type: ARLiteral
         self.desc = None            # type: MultiLanguageOverviewParagraph
 
     def getAdminData(self):
@@ -213,7 +219,7 @@ class Describable(ARObject, metaclass=ABCMeta):
         return self._category
 
     @category.setter
-    def category(self, value):
+    def category(self, value: ARLiteral):
         self._category = value
 
 class AtpFeature(Identifiable, metaclass=ABCMeta):

armodel/models/internal_behavior.py

@@ -4,7 +4,7 @@ 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 .m2.autosar_templates.sw_component_template.data_type.data_prototypes import ParameterDataPrototype
 from .general_structure import Identifiable
 
 class IncludedDataTypeSet(ARObject):

armodel/models/m2/autosar_templates/autosar_top_level_structure.py

@@ -0,0 +1,120 @@
+from typing import Dict, List
+
+from .generic_structure.ar_package import ARPackage
+from .common_structure.implementation_data_types import ImplementationDataType
+
+from ...general_structure import Referrable, CollectableElement
+
+from ...datatype import ApplicationDataType, DataTypeMap, SwBaseType
+
+class AbstractAUTOSAR(CollectableElement):
+    def __init__(self):
+        super().__init__()
+
+        CollectableElement.__init__(self)
+
+        self.schema_location = ""
+        self._appl_impl_type_maps = {}
+        self._impl_appl_type_maps = {}
+        
+
+        self._ar_packages = {}                  # type: Dict[str, ARPackage]
+        self.short_name_mappings = {}           # type: Dict[str, str]
+
+    def reload(self):
+        pass
+
+    @property
+    def full_name(self):
+        return ""
+
+    def clear(self):
+        self._ar_packages = {}
+        self.elements = {}
+
+    def getElement(self, short_name: str) -> Referrable:
+        if (short_name in self._ar_packages):
+            return self._ar_packages[short_name]
+        return CollectableElement.getElement(self, short_name)
+
+    def getARPackages(self) -> List[ARPackage]:
+        #return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
+        return list(sorted(self._ar_packages.values(), key= lambda a: a.short_name))
+
+    def createARPackage(self, short_name: str) -> ARPackage:
+        if (short_name not in self._ar_packages):
+            ar_package = ARPackage(self, short_name)
+            self._ar_packages[short_name] = ar_package
+        return self._ar_packages[short_name]
+
+    def find(self, referred_name: str) -> Referrable:
+        short_name_list = referred_name.split("/")
+        element = AUTOSAR.getInstance()
+        for short_name in short_name_list:
+            if (short_name == ""):
+                continue
+            element = element.getElement(short_name)
+            if (element == None):
+                return element
+            #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
+        return element
+    
+    def findByShortName(self, short_name: str) -> Referrable:
+        pass
+
+    def getDataType(self, data_type: ImplementationDataType) -> ImplementationDataType:
+        if (isinstance(data_type, ImplementationDataType) or isinstance(data_type, SwBaseType)):
+            if (data_type.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
+                referred_type = self.find(data_type.swDataDefProps.implementationDataTypeRef.value)
+                return self.getDataType(referred_type)
+            if (data_type.category == ImplementationDataType.CATEGORY_DATA_REFERENCE):
+                if (data_type.swDataDefProps.swPointerTargetProps.target_category == "VALUE"):
+                    referred_type = self.find(data_type.swDataDefProps.swPointerTargetProps.sw_data_def_props.baseTypeRef.value)
+                    return self.getDataType(referred_type)
+            return data_type
+        else:
+            raise ValueError("%s is not ImplementationDataType." % data_type)
+            
+    def addDataTypeMap(self, data_type_map: DataTypeMap):
+        if (data_type_map.application_data_type_ref is None) or (data_type_map.implementation_data_type_ref is None):
+            return
+        self._appl_impl_type_maps[data_type_map.application_data_type_ref.value] = data_type_map.implementation_data_type_ref.value
+        self._impl_appl_type_maps[data_type_map.implementation_data_type_ref.value] = data_type_map.application_data_type_ref.value
+
+    def convertToImplementationDataType(self, appl_data_type: str) -> ImplementationDataType:
+        if (appl_data_type not in self._appl_impl_type_maps.keys()):
+            raise IndexError("Invalid application data type <%s>" % appl_data_type)
+
+        return self.find(self._appl_impl_type_maps[appl_data_type])
+
+    def convertToApplicationDataType(self, impl_data_type: str) -> ApplicationDataType:
+        if (impl_data_type not in self._impl_appl_type_maps.keys()):
+            raise IndexError("Invalid Implementation data type <%s>" % impl_data_type)
+        
+        return self.find(self._impl_appl_type_maps[impl_data_type])
+
+    
+class AUTOSAR (AbstractAUTOSAR):        
+    __instance = None
+
+    @staticmethod
+    def getInstance():
+        if (AUTOSAR.__instance == None):
+            AUTOSAR()
+        return AUTOSAR.__instance
+    
+    def new(self):
+        self.clear()
+
+    def __init__(self):
+        if (AUTOSAR.__instance != None):
+            raise Exception("The AUTOSAR is singleton!")
+        
+        AUTOSAR.__instance = self
+
+        super().__init__()
+
+class AUTOSARDoc(AbstractAUTOSAR):
+    def __init__(self):
+        super().__init__()
+        

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

@@ -0,0 +1,21 @@
+from abc import ABCMeta
+
+from ....ar_object import ARLiteral, ARObject
+from ....general_structure import Referrable
+
+
+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