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

armodel/cli/arxml_dump_cli.py

@@ -2,7 +2,10 @@ import getopt
 import sys
 import logging
 
-from ..models import AUTOSAR, ARPackage, VariableAccess, SwComponentType, DataTypeMappingSet
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.data_elements import VariableAccess
+from ..models.m2.autosar_templates.generic_structure.ar_package import ARPackage
+
+from ..models import AUTOSAR, SwComponentType, DataTypeMappingSet
 from ..models import SwcInternalBehavior, ImplementationDataType
 from ..models import BswModuleDescription, BswInternalBehavior, BswModuleEntity, BswModuleEntry
 from ..models import PortPrototype, RPortPrototype, PPortPrototype
@@ -10,38 +13,38 @@ from ..models import SenderReceiverInterface, ClientServerInterface
 from ..parser import ARXMLParser
 
 def show_variable_access(indent:int, variable_access: VariableAccess):
-    if (variable_access.accessed_variable_ref != None):
-        accessed_variable_ref = variable_access.accessed_variable_ref
-        if (accessed_variable_ref.autosar_variable_in_impl_datatype != None):
-            autosar_variable_in_impl_datatype = accessed_variable_ref.autosar_variable_in_impl_datatype
-            print("%s: %s" % (" " * indent, autosar_variable_in_impl_datatype.port_prototype.value))
-            print("%s: %s" % (" " * indent, autosar_variable_in_impl_datatype.target_data_prototype.value))
+    if (variable_access.getAccessedVariableRef() != None):
+        accessed_variable_ref = variable_access.getAccessedVariableRef()
+        if (accessed_variable_ref.getAutosarVariableInImplDatatype() != None):
+            autosar_variable_in_impl_datatype = accessed_variable_ref.getAutosarVariableInImplDatatype()
+            print("%s: %s" % (" " * indent, autosar_variable_in_impl_datatype.getPortPrototypeRef().getValue()))
+            print("%s: %s" % (" " * indent, autosar_variable_in_impl_datatype.getTargetDataPrototypeRef().getValue()))
 
 def show_port(indent:int, port_prototype: PortPrototype):
     if (isinstance(port_prototype, RPortPrototype)):
-        print("%s-RPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.required_interface_tref.value))
+        print("%s-RPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.getRequiredInterfaceTRef().getValue()))
         for client_com_spec in port_prototype.getClientComSpecs():
-            print("%s    : %s (ClientComSpec)" % (" " * (indent + 2), client_com_spec.operationRef.value))
+            print("%s    : %s (ClientComSpec)" % (" " * (indent + 2), client_com_spec.getOperationRef().getValue()))
         for com_spec in port_prototype.getNonqueuedReceiverComSpecs():
-            print("%s    : %s (NonqueuedReceiverComSpec)" % (" " * (indent + 2), com_spec.dataElementRef.value))
+            print("%s    : %s (NonqueuedReceiverComSpec)" % (" " * (indent + 2), com_spec.getDataElementRef().getValue()))
     elif (isinstance(port_prototype, PPortPrototype)):
-        print("%s-PPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.provided_interface_tref.value))
+        print("%s-PPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.getProvidedInterfaceTRef().getValue()))
         for com_spec in port_prototype.getNonqueuedSenderComSpecs():
-            print("%s    : %s (NonqueuedSenderComSpec)" % (" " * (indent + 2), com_spec.dataElementRef.value))
+            print("%s    : %s (NonqueuedSenderComSpec)" % (" " * (indent + 2), com_spec.getDataElementRef().getValue()))
     else:
         raise ValueError("Unsupported Port prototype")
 
 def show_type(indent: int, data_type: ImplementationDataType):
     print("%s-Implementation Type: %s (%s)" % (" " * indent, data_type.short_name, data_type._parent.full_name))
-    print("%s                    : %s" % (" " * indent, data_type.category))
-    if (data_type.swDataDefProps != None):
-        if (data_type.swDataDefProps.baseTypeRef != None):
-            base_type_ref = data_type.swDataDefProps.baseTypeRef
-            print("%s                    : %s (%s)" % (" " * indent, base_type_ref.value, base_type_ref.dest))
+    print("%s                    : %s" % (" " * indent, data_type.getCategory()))
+    if (data_type.getSwDataDefProps() != None):
+        if (data_type.getSwDataDefProps().getBaseTypeRef() != None):
+            base_type_ref = data_type.getSwDataDefProps().getBaseTypeRef()
+            print("%s                    : %s (%s)" % (" " * indent, base_type_ref.getValue(), base_type_ref.getDest()))
             
-        if (data_type.swDataDefProps.implementationDataTypeRef != None):
-            implementation_data_type_ref = data_type.swDataDefProps.implementationDataTypeRef
-            print("%s                    : %s (%s)" % (" " * indent, implementation_data_type_ref.value, implementation_data_type_ref.dest))
+        if (data_type.getSwDataDefProps().getImplementationDataTypeRef() != None):
+            implementation_data_type_ref = data_type.getSwDataDefProps().getImplementationDataTypeRef()
+            print("%s                    : %s (%s)" % (" " * indent, implementation_data_type_ref.getValue(), implementation_data_type_ref.getDest()))
 
 def show_data_type_mapping(indent: int, mapping_set: DataTypeMappingSet):
     print("%s- Data Mapping Set <%s>:" % (" " * indent, mapping_set.short_name))
@@ -63,8 +66,8 @@ def show_behavior(indent:int, behavior: SwcInternalBehavior):
         for server_call_point in runnable.getServerCallPoints():
             print("%s-scp : %s" % (" " * (indent + 4), variable_access.short_name))
             if (server_call_point.operation_iref != None):
-                print("%s: %s" % (" " * (indent + 9), server_call_point.operation_iref.conext_r_port.value))
-                print("%s: %s" % (" " * (indent + 9), server_call_point.operation_iref.target_required_operation.value))
+                print("%s: %s" % (" " * (indent + 9), server_call_point.getOperationIRef().getContextRPortRef().getValue()))
+                print("%s: %s" % (" " * (indent + 9), server_call_point.getOperationIRef().getTargetRequiredOperationRef().getValue()))
     for event in behavior.getOperationInvokedEvents():
         print("   - OperationInvokedEvent : %s" % event.short_name)
         print("                           : %s" % (event.start_on_event_ref.value))

armodel/cli/arxml_format_cli.py

@@ -5,11 +5,8 @@ import sys
 import os.path
 
 
-from ..models.ar_package import AUTOSAR
+from ..models.m2.autosar_templates.autosar_top_level_structure import AUTOSAR
 from ..parser.arxml_parser import ARXMLParser
-from ..parser.connector_xlsx_parser import ConnectorXlsReader
-
-from ..lib import InputFileParser
 from ..writer import ARXMLWriter
 
 def main():

armodel/cli/connector_update_cli.py

@@ -5,7 +5,7 @@ import sys
 import os.path
 
 
-from ..models.ar_package import AUTOSAR
+from ..models.m2.autosar_templates.autosar_top_level_structure import AUTOSAR
 from ..parser.arxml_parser import ARXMLParser
 from ..parser.connector_xlsx_parser import ConnectorXlsReader
 

armodel/cli/swc_list_cli.py

@@ -4,7 +4,7 @@ import logging
 import sys
 import os.path
 
-from armodel import AUTOSAR, ARPackage
+from armodel import AUTOSAR
 from armodel.parser import ARXMLParser
 
 from ..lib import InputFileParser, SwComponentAnalyzer

armodel/lib/sw_component.py

@@ -1,7 +1,9 @@
 import logging
 
 from typing import List
-from ..models import AUTOSAR, ARPackage, AtomicSwComponentType, CompositionSwComponentType
+
+from ..models.m2.autosar_templates.generic_structure.ar_package import ARPackage
+from ..models import AUTOSAR, AtomicSwComponentType, CompositionSwComponentType
 
 class SwComponentAnalyzer:
     def __init__(self) -> None:

armodel/lib/system_signal.py

@@ -1,7 +1,9 @@
 import logging
 from typing import List
 
-from ..models.ar_package import AUTOSAR, ARPackage
+from ..models.m2.autosar_templates.generic_structure.ar_package import ARPackage
+
+from ..models.m2.autosar_templates.autosar_top_level_structure import AUTOSAR
 from ..models.fibex.fibex_core.core_communication import SystemSignal
 
 class SystemSignalAnalyzer:

armodel/models/__init__.py

@@ -3,7 +3,7 @@ from .ar_object import *
 from .general_structure import *
 from .common_structure import *
 from .sw_component import *
-from .ar_package import *
+from .m2.autosar_templates.autosar_top_level_structure import *
 from .ar_ref import *
 from .datatype import *
 from .port_prototype import * 

armodel/models/datatype.py

@@ -1,6 +1,7 @@
 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 .general_structure import ARElement, ARObject
@@ -133,11 +134,9 @@ class ApplicationRecordDataType(ApplicationCompositeDataType):
     def getApplicationRecordElements(self) -> List[ApplicationRecordElement]:
         return self.record_elements
 
-
-
-
 class DataTypeMap(ARObject):
     def __init__(self):
+
         self.application_data_type_ref = None       # type: RefType
         self.implementation_data_type_ref = None    # type: RefType
 

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_data_types.py

@@ -85,6 +85,7 @@ class AbstractImplementationDataType(AutosarDataType, metaclass = ABCMeta):
         super().__init__(parent, short_name)
 
 class ImplementationDataType(AbstractImplementationDataType):
+
     CATEGORY_TYPE_REFERENCE = "TYPE_REFERENCE"
     CATEGORY_TYPE_VALUE = "VALUE"
     CATEGORY_TYPE_STRUCTURE = "STRUCTURE"
@@ -93,17 +94,22 @@ class ImplementationDataType(AbstractImplementationDataType):
 
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
+
+        self.arrayImplPolicy = None
+        self.arraySize = None
+        self.arraySizeHandling = None                   # type: ARLiteral
+        self.arraySizeSemantics = None                  # type: ARLiteral
         
-        self.sub_elements = []          # type: List[str]
-        self.symbolProps = None         # type: SymbolProps
-        self._type_emitter = None       # type: ARLiteral
+        self.subElements = []                           # type: List[str]
+        self.symbolProps = None                         # type: SymbolProps
+        self._type_emitter = None                       # type: ARLiteral
 
         self._array_type = None         # ImplementationDataType
         self._struct_type = None        # ImplementationDataType
 
     
     def createImplementationDataTypeElement(self, short_name: str) -> ImplementationDataTypeElement:     
-        self.sub_elements.append(short_name)
+        self.subElements.append(short_name)
         if (short_name not in self.elements):
             event = ImplementationDataTypeElement(self, short_name)
             self.elements[short_name] = event
@@ -111,7 +117,7 @@ class ImplementationDataType(AbstractImplementationDataType):
 
     def getImplementationDataTypeElements(self) -> List[ImplementationDataTypeElement]:
         elements = []
-        for sub_element in self.sub_elements:
+        for sub_element in self.subElements:
             elements.append(self.elements[sub_element])
         return elements
         # return filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values())