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

armodel/cli/arxml_dump_cli.py

@@ -2,46 +2,52 @@ import getopt
 import sys
 import logging
 
-from ..models import AUTOSAR, ARPackage, VariableAccess, SwComponentType, DataTypeMappingSet
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
+
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import PPortPrototype, PortPrototype, RPortPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import DataTypeMappingSet
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior, BswModuleEntity
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import VariableAccess
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage
+from ..models import AUTOSAR, SwComponentType
 from ..models import SwcInternalBehavior, ImplementationDataType
-from ..models import BswModuleDescription, BswInternalBehavior, BswModuleEntity, BswModuleEntry
-from ..models import PortPrototype, RPortPrototype, PPortPrototype
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
 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 +69,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))
@@ -84,7 +90,7 @@ def show_sw_component(indent: int, sw_component: SwComponentType):
 def show_sender_receiver_interface(indent: int, sr_interface: SenderReceiverInterface):
     print("%s%s" % (" " * indent, sr_interface.short_name))
     for data_element in sr_interface.getDataElements():
-        print("%sData Element:%s (%s) " % (" " * (indent + 2), data_element.short_name, data_element.type_ref.value))
+        print("%sData Element:%s (%s) " % (" " * (indent + 2), data_element.short_name, data_element.getTypeTRef().getValue()))
 
 def show_client_server_interface(indent: int, cs_interface: ClientServerInterface):
     print("%s%s" % (" " * indent, cs_interface.short_name))

armodel/cli/arxml_format_cli.py

@@ -5,11 +5,8 @@ import sys
 import os.path
 
 
-from ..models.ar_package import AUTOSAR
+from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure 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.AUTOSARTemplates.AutosarTopLevelStructure 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.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage 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.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage
+
+from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
 from ..models.fibex.fibex_core.core_communication import SystemSignal
 
 class SystemSignalAnalyzer:

armodel/models/M2/AUTOSARTemplates/AutosarTopLevelStructure.py

@@ -0,0 +1,123 @@
+from typing import Dict, List
+
+from .SWComponentTemplate.Datatype.Datatypes import ApplicationDataType
+
+from ..MSR.AsamHdo.BaseTypes import SwBaseType
+
+from .GenericStructure.GeneralTemplateClasses.Identifiable import CollectableElement
+from .GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage
+from .CommonStructure.ImplementationDataTypes import ImplementationDataType
+from .GenericStructure.GeneralTemplateClasses.Identifiable import Referrable
+from .SWComponentTemplate.Datatype.Datatypes import DataTypeMap
+
+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__()
+