Add example how to create component from template class

examples/template/config.toml

@@ -7,6 +7,7 @@
     ComponentType = "/ComponentTypes"
     ModeDeclaration = "/ModeDclrGroups"
     PortInterface = "/PortInterfaces"
+    Constant = "/Constants"
     base_ref = "/"
 
 [namespace.AUTOSAR_Platform]
@@ -24,4 +25,11 @@
 [document.DataTypes]
     packages = "/DataTypes"
 
+[document.Constants]
+    packages = "/Constants"
+
+[document_mapping.ComponentType]
+    package_ref = "/ComponentTypes"
+    element_types = "SwComponentType"
+    suffix_filters = ["_Implementation"]
 

examples/template/demo_system/component.py

@@ -0,0 +1,56 @@
+"""
+Component type templates
+"""
+# flake8: noqa
+# pylint: disable=C0103, C0301
+
+
+import autosar.xml.element as ar_element
+import autosar.xml.workspace as ar_workspace
+from . import factory, portinterface, constants
+
+NAMESPACE = "Default"
+
+
+def create_ReceiverComponent(_0: str,
+                             workspace: ar_workspace.Workspace,
+                             deps: dict[str, ar_element.ARElement] | None,
+                             **_1) -> ar_element.ApplicationSoftwareComponentType:
+    """
+    Create Receiver component type
+    """
+
+    timer_interface = deps[portinterface.FreeRunningTimer_I.ref(workspace)]
+    vehicle_speed_interface = deps[portinterface.EngineSpeed_I.ref(workspace)]
+    engine_speed_interface = deps[portinterface.VehicleSpeed_I.ref(workspace)]
+    engine_speed_init = deps[constants.EngineSpeed_IV.ref(workspace)]
+    vehicle_speed_init = deps[constants.VehicleSpeed_IV.ref(workspace)]
+    swc = ar_element.ApplicationSoftwareComponentType("ReceiverComponent")
+    swc.create_require_port("EngineSpeed", engine_speed_interface, com_spec={"init_value": engine_speed_init.ref(),
+                                                                             "alive_timeout": 0,
+                                                                             "enable_update": False,
+                                                                             "uses_end_to_end_protection": False,
+                                                                             "handle_never_received": False
+                                                                             })
+    swc.create_require_port("VehicleSpeed", vehicle_speed_interface, com_spec={"init_value": vehicle_speed_init.ref(),
+                                                                               "alive_timeout": 0,
+                                                                               "enable_update": False,
+                                                                               "uses_end_to_end_protection": False,
+                                                                               "handle_never_received": False
+                                                                               })
+    swc.create_require_port("FreeRunningTimer", timer_interface)
+    swc.create_internal_behavior()
+    return swc
+
+
+ReceiverComponent = factory.GenericComponentTypeTemplate("ReceiverComponent",
+                                                        NAMESPACE,
+                                                        create_ReceiverComponent,
+                                                        depends=[portinterface.EngineSpeed_I,
+                                                                 portinterface.VehicleSpeed_I,
+                                                                 portinterface.FreeRunningTimer_I,
+                                                                 constants.EngineSpeed_IV,
+                                                                 constants.VehicleSpeed_IV,])
+ReceiverComponent_Implementation = factory.SwcImplementationTemplate("ReceiverComponent_Implementation",
+                                                                     NAMESPACE,
+                                                                     component_type=ReceiverComponent)

examples/template/demo_system/constants.py

@@ -0,0 +1,12 @@
+"""
+Constants templates
+"""
+# flake8: noqa
+# pylint: disable=C0103, C0301
+
+from . import factory
+
+NAMESPACE = "Default"
+
+EngineSpeed_IV = factory.ConstantTemplate("EngineSpeed_IV", NAMESPACE, 65535)
+VehicleSpeed_IV = factory.ConstantTemplate("VehicleSpeed_IV", NAMESPACE, 65535)

examples/template/demo_system/factory.py

@@ -1,7 +1,7 @@
 """
 Example template classes
 """
-from typing import Callable
+from typing import Any, Callable
 import autosar.xml.template as ar_template
 import autosar.xml.element as ar_element
 import autosar.xml.enumeration as ar_enum
@@ -294,7 +294,7 @@ def create(self,
 
 class GenericPortInterfaceTemplate(ar_template.ElementTemplate):
     """
-    Generic element template
+    Generic port interface element template
     """
 
     def __init__(self,
@@ -315,3 +315,113 @@ def create(self,
         """
         elem = self.create_func(element_ref, workspace, dependencies, **kwargs)
         return elem
+
+
+class SenderReceiverInterfaceTemplate(ar_template.ElementTemplate):
+    """
+    Sender receiver port interface template restricted to a single data element
+    It is assumed that the element name ends with "_I"
+    """
+
+    def __init__(self,
+                 element_name: str,
+                 namespace_name: str,
+                 data_element_template: ar_template.ElementTemplate,
+                 data_element_name: str | None = None) -> None:
+        super().__init__(element_name, namespace_name, ar_enum.PackageRole.PORT_INTERFACE, [data_element_template])
+        self.data_element_template = data_element_template
+        self.data_element_name = data_element_name
+
+    def create(self,
+               element_ref: str,
+               workspace: ar_workspace.Workspace,
+               dependencies: dict[str, ar_element.ARElement] | None,
+               **kwargs) -> ar_element.SenderReceiverInterface:
+        """
+        Create method
+        """
+        elem_type = dependencies[self.data_element_template.ref(workspace)]
+        port_interface = ar_element.SenderReceiverInterface(self.element_name)
+        elem_name = self.data_element_name
+        if elem_name is None:
+            if self.element_name.endswith("_I"):
+                elem_name = self.element_name[:-2]
+            else:
+                elem_name = self.element_name
+        port_interface.create_data_element(elem_name, type_ref=elem_type.ref())
+        return port_interface
+
+
+class GenericComponentTypeTemplate(ar_template.ElementTemplate):
+    """
+    Generic component type element template
+    """
+
+    def __init__(self,
+                 element_name: str,
+                 namespace_name: str,
+                 create_func: CreateFuncType,
+                 depends: list[TemplateBase] | None = None) -> None:
+        super().__init__(element_name, namespace_name, ar_enum.PackageRole.COMPONENT_TYPE, depends)
+        self.create_func = create_func
+
+    def create(self,
+               element_ref: str,
+               workspace: ar_workspace.Workspace,
+               dependencies: dict[str, ar_element.ARElement] | None,
+               **kwargs) -> ar_element.PortInterface:
+        """
+        Create method
+        """
+        elem = self.create_func(element_ref, workspace, dependencies, **kwargs)
+        return elem
+
+
+class SwcImplementationTemplate(ar_template.ElementTemplate):
+    """
+    SwcImplementation template
+    """
+
+    def __init__(self,
+                 element_name: str,
+                 namespace_name: str,
+                 component_type: ar_template.ElementTemplate) -> None:
+        super().__init__(element_name, namespace_name, ar_enum.PackageRole.COMPONENT_TYPE, [component_type])
+        self.component_type = component_type
+
+    def create(self,
+               _0: str,
+               workspace: ar_workspace.Workspace,
+               dependencies: dict[str, ar_element.ARElement] | None,
+               **kwargs) -> ar_element.SwBaseType:
+        """
+        Factory method for creating a new SwcImplementation
+        """
+        swc_type = dependencies[self.component_type.ref(workspace)]
+        elem = ar_element.SwcImplementation(self.element_name,
+                                            behavior_ref=swc_type.internal_behavior.ref())
+
+        return elem
+
+
+class ConstantTemplate(ar_template.ElementTemplate):
+    """
+    Constant template
+    """
+
+    def __init__(self,
+                 element_name: str,
+                 namespace_name: str,
+                 value: Any) -> None:
+        super().__init__(element_name, namespace_name, ar_enum.PackageRole.CONSTANT)
+        self.value = value
+
+    def create(self,
+               _0: str,
+               _1: ar_workspace.Workspace,
+               _2: dict[str, ar_element.ARElement] | None,
+               **_3) -> ar_element.SwBaseType:
+        """
+        Factory method for creating a new SwcImplementation
+        """
+        return ar_element.ConstantSpecification.make_constant(self.element_name, self.value)

examples/template/demo_system/portinterface.py

@@ -7,12 +7,10 @@
 
 import autosar.xml.element as ar_element
 import autosar.xml.workspace as ar_workspace
-from . import factory, mode
+from . import factory, mode, platform
 
 NAMESPACE = "Default"
 
-EcuM_CurrentMode = factory.ModeSwitchInterfaceTemplate("EcuM_CurrentMode", NAMESPACE, mode.EcuM_Mode, "currentMode", is_service=True)
-
 
 def create_NvMService_interface(element_ref: str,
                                 _1: ar_workspace.Workspace,
@@ -22,10 +20,36 @@ def create_NvMService_interface(element_ref: str,
     Create NvmService interface
     """
 
-    interface = ar_element.ClientServerInterface("NvMService_I", is_service=True)
-    e_not_ok = interface.create_possible_error("E_NOT_OK", 1)
-    interface.create_operation("EraseBlock", possible_error_refs=element_ref + "/" + e_not_ok.name)
-    return interface
+    port_interface = ar_element.ClientServerInterface("NvMService_I", is_service=True)
+    e_not_ok = port_interface.create_possible_error("E_NOT_OK", 1)
+    port_interface.create_operation("EraseBlock", possible_error_refs=element_ref + "/" + e_not_ok.name)
+    return port_interface
+
 
+def create_free_running_timer_interface(_0: str,
+                                        workspace: ar_workspace.Workspace,
+                                        deps: dict[str, ar_element.ARElement] | None,
+                                        **_1) -> ar_element.ClientServerInterface:
+    """
+    Creates client server interface FreeRunningTimer_I
+    """
+    uint32_impl_type = deps[platform.ImplementationTypes.uint32.ref(workspace)]
+    boolean_impl_type = deps[platform.ImplementationTypes.boolean.ref(workspace)]
+    port_interface = ar_element.ClientServerInterface("FreeRunningTimer_I")
+    operation = port_interface.create_operation("GetTime")
+    operation.create_out_argument("value", type_ref=uint32_impl_type.ref())
+    operation = port_interface.create_operation("IsTimerElapsed")
+    operation.create_in_argument("startTime", type_ref=uint32_impl_type.ref())
+    operation.create_in_argument("duration", type_ref=uint32_impl_type.ref())
+    operation.create_out_argument("result", type_ref=boolean_impl_type.ref())
+    return port_interface
 
+EcuM_CurrentMode = factory.ModeSwitchInterfaceTemplate("EcuM_CurrentMode", NAMESPACE, mode.EcuM_Mode, "currentMode", is_service=True)
 NvMService_I = factory.GenericPortInterfaceTemplate("NvMService_I", NAMESPACE, create_NvMService_interface)
+FreeRunningTimer_I = factory.GenericPortInterfaceTemplate("FreeRunningTimer_I",
+                                                          NAMESPACE,
+                                                          create_free_running_timer_interface,
+                                                          depends=[platform.ImplementationTypes.uint32,
+                                                                   platform.ImplementationTypes.boolean])
+VehicleSpeed_I = factory.SenderReceiverInterfaceTemplate("VehicleSpeed_I", NAMESPACE, platform.ImplementationTypes.uint16)
+EngineSpeed_I = factory.SenderReceiverInterfaceTemplate("EngineSpeed_I", NAMESPACE, platform.ImplementationTypes.uint16)

examples/template/generate_xml_using_config.py

@@ -3,7 +3,7 @@
 """
 
 import os
-from demo_system import platform, datatype, portinterface
+from demo_system import platform, component
 import autosar.xml.workspace as ar_workspace
 
 
@@ -18,19 +18,11 @@ def apply_platform_types(workspace: ar_workspace.Workspace):
     workspace.apply(platform.ImplementationTypes.uint64)
 
 
-def apply_data_types(workspace: ar_workspace.Workspace):
+def apply_component_types(workspace: ar_workspace.Workspace):
     """
-    Applies data type templates
+    Applies component type templates
     """
-    workspace.apply(datatype.InactiveActive_T)
-
-
-def apply_portinterfaces(workspace: ar_workspace.Workspace):
-    """
-    Applies mode templates
-    """
-    workspace.apply(portinterface.EcuM_CurrentMode)
-    workspace.apply(portinterface.NvMService_I)
+    workspace.apply(component.ReceiverComponent_Implementation)
 
 
 def main():
@@ -39,8 +31,7 @@ def main():
     document_root = os.path.join(os.path.dirname(__file__), "generated")
     workspace = ar_workspace.Workspace(config_file_path, document_root=document_root)
     apply_platform_types(workspace)
-    apply_data_types(workspace)
-    apply_portinterfaces(workspace)
+    apply_component_types(workspace)
     workspace.write_documents()
     print("Done")
 

examples/template/generate_xml_without_config.py

@@ -4,7 +4,8 @@
 """
 
 import os
-from demo_system import platform, datatype, portinterface
+from demo_system import platform, component
+import autosar.xml.element as ar_element
 import autosar.xml.workspace as ar_workspace
 
 
@@ -25,7 +26,9 @@ def create_namespaces(workspace: ar_workspace.Workspace):
         "CompuMethod": "/DataTypes/CompuMethods",
         "DataConstraint": "/DataTypes/DataConstrs",
         "ModeDeclaration": "/ModeDclrGroups",
-        "PortInterface": "/PortInterfaces"},
+        "PortInterface": "/PortInterfaces",
+        "Constant": "/Constants",
+        "ComponentType": "/ComponentTypes"},
         base_ref="/")
 
 
@@ -40,13 +43,13 @@ def create_documents(workspace: ar_workspace.Workspace) -> None:
     """
     Creates documents
     """
-    sub_directory = "generated"
-    platform_document_path = create_abs_path(sub_directory, "AUTOSAR_Platform.arxml")
-    datatype_document_path = create_abs_path(sub_directory, "DataTypes.arxml")
-    portinterface_document_path = create_abs_path(sub_directory, "PortInterfaces.arxml")
-    workspace.create_document(platform_document_path, packages="/AUTOSAR_Platform")
-    workspace.create_document(datatype_document_path, packages="/DataTypes")
-    workspace.create_document(portinterface_document_path, packages=["/ModeDclrGroups", "/PortInterfaces"])
+    workspace.create_document("AUTOSAR_Platform.arxml", packages="/AUTOSAR_Platform")
+    workspace.create_document("DataTypes.arxml", packages="/DataTypes")
+    workspace.create_document("Constants.arxml", packages="/Constants")
+    workspace.create_document("PortInterfaces.arxml", packages=["/ModeDclrGroups", "/PortInterfaces"])
+    workspace.create_document_mapping(package_ref="/ComponentTypes",
+                                      element_types=ar_element.SwComponentType,
+                                      suffix_filters=["_Implementation"])
 
 
 def apply_platform_types(workspace: ar_workspace.Workspace):
@@ -60,29 +63,20 @@ def apply_platform_types(workspace: ar_workspace.Workspace):
     workspace.apply(platform.ImplementationTypes.uint64)
 
 
-def apply_data_types(workspace: ar_workspace.Workspace):
+def apply_component_types(workspace: ar_workspace.Workspace):
     """
-    Applies data type templates
+    Applies component type templates
     """
-    workspace.apply(datatype.InactiveActive_T)
-
-
-def apply_portinterfaces(workspace: ar_workspace.Workspace):
-    """
-    Applies mode templates
-    """
-    workspace.apply(portinterface.EcuM_CurrentMode)
-    workspace.apply(portinterface.NvMService_I)
+    workspace.apply(component.ReceiverComponent_Implementation)
 
 
 def main():
     """Main"""
-    workspace = ar_workspace.Workspace()
+    workspace = ar_workspace.Workspace(document_root="generated")
     create_namespaces(workspace)
-    apply_platform_types(workspace)
-    apply_data_types(workspace)
-    apply_portinterfaces(workspace)
     create_documents(workspace)
+    apply_platform_types(workspace)
+    apply_component_types(workspace)
     workspace.write_documents()
     print("Done")