Added abstract types in default parameters and '-l' language argument

AIDASoft · Sep 27, 2023 · 506060f · 506060f
1 parent 589f952
commit 506060f
Show file tree

Hide file tree

Showing 11 changed files with 123 additions and 110 deletions.
diff --git a/.gitignore b/.gitignore
@@ -5,6 +5,7 @@ install
 tests/src
 tests/datamodel
 tests/extension_model
+tests/datamodeljulia
 
 # Python
 *pyc

diff --git a/cmake/podioMacros.cmake b/cmake/podioMacros.cmake
@@ -128,13 +128,15 @@ set_property(CACHE PODIO_USE_CLANG_FORMAT PROPERTY STRINGS AUTO ON OFF)
 #                           passed directly to podio_class_generator.py and validated there
 #                           Default is ROOT
 #      SCHEMA_EVOLUTION     OPTIONAL: The path to the yaml file declaring the necessary schema evolution
-#  )
+#      LANG                 OPTIONAL: The programming language choice
+#                           Default is cpp
+# )
 #
 # Note that the create_${datamodel} target will always be called, but if the YAML_FILE has not changed
 # this is essentially a no-op, and should not cause re-compilation.
 #---------------------------------------------------------------------------------------------------
 function(PODIO_GENERATE_DATAMODEL datamodel YAML_FILE RETURN_HEADERS RETURN_SOURCES)
-  CMAKE_PARSE_ARGUMENTS(ARG "" "OLD_DESCRIPTION;OUTPUT_FOLDER;UPSTREAM_EDM;SCHEMA_EVOLUTION" "IO_BACKEND_HANDLERS" ${ARGN})
+  CMAKE_PARSE_ARGUMENTS(ARG "" "OLD_DESCRIPTION;OUTPUT_FOLDER;UPSTREAM_EDM;SCHEMA_EVOLUTION" "IO_BACKEND_HANDLERS;LANG" ${ARGN})
   IF(NOT ARG_OUTPUT_FOLDER)
     SET(ARG_OUTPUT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR})
   ENDIF()
@@ -153,6 +155,13 @@ function(PODIO_GENERATE_DATAMODEL datamodel YAML_FILE RETURN_HEADERS RETURN_SOUR
     SET(ARG_IO_BACKEND_HANDLERS "ROOT")
   ENDIF()
 
+  # Check if the LANG argument is specified and set the language accordingly.
+  IF(ARG_LANG)
+    SET(LANGUAGE_ARG "-l=${ARG_LANG}")
+  ELSE()
+    SET(LANGUAGE_ARG "-l=cpp")  # Default to C++
+  ENDIF()
+
   SET(SCHEMA_EVOLUTION_ARG "")
   IF (ARG_SCHEMA_EVOLUTION)
     SET(SCHEMA_EVOLUTION_ARG "--evolution_file=${ARG_SCHEMA_EVOLUTION}")
@@ -201,7 +210,7 @@ function(PODIO_GENERATE_DATAMODEL datamodel YAML_FILE RETURN_HEADERS RETURN_SOUR
   message(STATUS "Creating '${datamodel}' datamodel")
   # we need to boostrap the data model, so this has to be executed in the cmake run
   execute_process(
-    COMMAND ${Python_EXECUTABLE} ${podio_PYTHON_DIR}/podio_class_generator.py ${CLANG_FORMAT_ARG} ${OLD_DESCRIPTION_ARG} ${SCHEMA_EVOLUTION_ARG} ${UPSTREAM_EDM_ARG} ${YAML_FILE} ${ARG_OUTPUT_FOLDER} ${datamodel} ${ARG_IO_BACKEND_HANDLERS}
+    COMMAND ${Python_EXECUTABLE} ${podio_PYTHON_DIR}/podio_class_generator.py ${CLANG_FORMAT_ARG} ${OLD_DESCRIPTION_ARG} ${SCHEMA_EVOLUTION_ARG} ${UPSTREAM_EDM_ARG} ${YAML_FILE} ${ARG_OUTPUT_FOLDER} ${datamodel} ${ARG_IO_BACKEND_HANDLERS} ${LANGUAGE_ARG}
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     RESULT_VARIABLE podio_generate_command_retval
     )

diff --git a/python/podio/test_MemberParser.py b/python/podio/test_MemberParser.py
@@ -232,6 +232,7 @@ def test_parse_invalid(self):
       try:
         self.assertRaises(DefinitionError, parser.parse, inp)
       except AssertionError:
+        # pylint: disable-next=raise-missing-from
         raise AssertionError(f"'{inp}' should raise a DefinitionError from the MemberParser")
 
   def test_parse_valid_no_description(self):

diff --git a/python/podio_class_generator.py b/python/podio_class_generator.py
@@ -80,11 +80,12 @@ class IncludeFrom(IntEnum):
 class ClassGenerator:
   """The entry point for reading a datamodel definition and generating the
   necessary source code from it."""
-  def __init__(self, yamlfile, install_dir, package_name, io_handlers, verbose, dryrun,
+  def __init__(self, yamlfile, install_dir, package_name, io_handlers, proglang, verbose, dryrun,
                upstream_edm, old_description, evolution_file):
     self.install_dir = install_dir
     self.package_name = package_name
     self.io_handlers = io_handlers
+    self.proglang = proglang
     self.verbose = verbose
     self.dryrun = dryrun
     self.yamlfile = yamlfile
@@ -141,15 +142,18 @@ def process(self):
     for name, datatype in self.datamodel.datatypes.items():
       datamodel['datatypes'].append(self._process_datatype(name, datatype))
 
-    self._write_edm_def_file()
-    self._process_parent_module(datamodel)
+    if self.proglang == "julia":
+      self._process_parent_module(datamodel)
 
-    if 'ROOT' in self.io_handlers:
-      self.prepare_iorules()
-      self._create_selection_xml()
+    if self.proglang == "cpp":
+      self._write_edm_def_file()
 
-    self._write_cmake_lists_file()
+      if 'ROOT' in self.io_handlers:
+        self._create_selection_xml()
+
+      self._write_cmake_lists_file()
 
+    self.process_schema_evolution()
     self.print_report()
 
   def process_schema_evolution(self):
@@ -288,8 +292,12 @@ def _process_component(self, name, component):
     component['includes'] = self._sort_includes(includes)
     component['includes_jl'] = {'struct': sorted(includes_jl)}
     component['class'] = DataType(name)
-    self._fill_templates('Component', component)
-    self._fill_templates('MutableStruct', component)
+
+    if self.proglang == "cpp":
+      self._fill_templates('Component', component)
+    if self.proglang == "julia":
+      self._fill_templates('MutableStruct', component)
+
     return component
 
     # Add potentially older schema for schema evolution
@@ -324,47 +332,50 @@ def _process_datatype(self, name, definition):
     """Process one datatype"""
     datatype = self._preprocess_datatype(name, definition)
 
-    # ROOT schema evolution preparation
-    # Compute and prepare the potential schema evolution parts
-    schema_evolution_datatype = copy.deepcopy(datatype)
-    needs_schema_evolution = False
-    for member in schema_evolution_datatype['Members']:
-      if member.is_array:
-        if member.array_type in self.root_schema_dict:
-          needs_schema_evolution = True
-          self._replace_component_in_paths(member.array_type, member.array_type + self.old_schema_version,
-                                           schema_evolution_datatype['includes_data'])
-          member.full_type = member.full_type.replace(member.array_type, member.array_type + self.old_schema_version)
-          member.array_type = member.array_type + self.old_schema_version
+    if self.proglang == "julia":
+      self._fill_templates('MutableStruct', datatype)
+
+    if self.proglang == "cpp":
+      # ROOT schema evolution preparation
+      # Compute and prepare the potential schema evolution parts
+      schema_evolution_datatype = copy.deepcopy(datatype)
+      needs_schema_evolution = False
+      for member in schema_evolution_datatype['Members']:
+        if member.is_array:
+          if member.array_type in self.root_schema_dict:
+            needs_schema_evolution = True
+            self._replace_component_in_paths(member.array_type, member.array_type + self.old_schema_version,
+                                            schema_evolution_datatype['includes_data'])
+            member.full_type = member.full_type.replace(member.array_type, member.array_type + self.old_schema_version)
+            member.array_type = member.array_type + self.old_schema_version
 
+        else:
+          if member.full_type in self.root_schema_dict:
+            needs_schema_evolution = True
+            # prepare the ROOT I/O rule
+            self._replace_component_in_paths(member.full_type, member.full_type + self.old_schema_version,
+                                            schema_evolution_datatype['includes_data'])
+            member.full_type = member.full_type + self.old_schema_version
+            member.bare_type = member.bare_type + self.old_schema_version
+
+      if needs_schema_evolution:
+        print(f"  Preparing explicit schema evolution for {name}")
+        schema_evolution_datatype['class'].bare_type = schema_evolution_datatype['class'].bare_type + self.old_schema_version  # noqa
+        self._fill_templates('Data', schema_evolution_datatype)
+        self.root_schema_datatype_names.add(name + self.old_schema_version)
+        self._fill_templates('Collection', datatype, schema_evolution_datatype)
       else:
-        if member.full_type in self.root_schema_dict:
-          needs_schema_evolution = True
-          # prepare the ROOT I/O rule
-          self._replace_component_in_paths(member.full_type, member.full_type + self.old_schema_version,
-                                           schema_evolution_datatype['includes_data'])
-          member.full_type = member.full_type + self.old_schema_version
-          member.bare_type = member.bare_type + self.old_schema_version
-
-    if needs_schema_evolution:
-      print(f"  Preparing explicit schema evolution for {name}")
-      schema_evolution_datatype['class'].bare_type = schema_evolution_datatype['class'].bare_type + self.old_schema_version  # noqa
-      self._fill_templates('Data', schema_evolution_datatype)
-      self.root_schema_datatype_names.add(name + self.old_schema_version)
-      self._fill_templates('Collection', datatype, schema_evolution_datatype)
-    else:
-      self._fill_templates('Collection', datatype)
+        self._fill_templates('Collection', datatype)
 
-    self._fill_templates('Data', datatype)
-    self._fill_templates('Object', datatype)
-    self._fill_templates('MutableObject', datatype)
-    self._fill_templates('Obj', datatype)
-    self._fill_templates('Collection', datatype)
-    self._fill_templates('CollectionData', datatype)
-    self._fill_templates('MutableStruct', datatype)
+      self._fill_templates('Data', datatype)
+      self._fill_templates('Object', datatype)
+      self._fill_templates('MutableObject', datatype)
+      self._fill_templates('Obj', datatype)
+      self._fill_templates('Collection', datatype)
+      self._fill_templates('CollectionData', datatype)
 
-    if 'SIO' in self.io_handlers:
-      self._fill_templates('SIOBlock', datatype)
+      if 'SIO' in self.io_handlers:
+        self._fill_templates('SIOBlock', datatype)
 
     return datatype
 
@@ -717,15 +728,18 @@ def read_upstream_edm(name_path):
   import argparse
   # pylint: disable=invalid-name # before 2.5.0 pylint is too strict with the naming here
   parser = argparse.ArgumentParser(description='Given a description yaml file this script generates '
-                                   'the necessary c++ files in the target directory')
+                                   'the necessary c++ or julia files in the target directory')
 
   parser.add_argument('description', help='yaml file describing the datamodel')
   parser.add_argument('targetdir', help='Target directory where the generated data classes will be put. '
                       'Header files will be put under <targetdir>/<packagename>/*.h. '
-                      'Source files will be put under <targetdir>/src/*.cc')
+                      'Source files will be put under <targetdir>/src/*.cc. '
+                      'Julia files will be put under <targetdir>/<packagename>/*.jl.')
   parser.add_argument('packagename', help='Name of the package.')
   parser.add_argument('iohandlers', choices=['ROOT', 'SIO'], nargs='+',
                       help='The IO backend specific code that should be generated')
+  parser.add_argument('-l', '--lang', choices=['cpp', 'julia'], default='cpp',
+                      help='Specify the programming language (default: cpp)')
   parser.add_argument('-q', '--quiet', dest='verbose', action='store_false', default=True,
                       help='Don\'t write a report to screen')
   parser.add_argument('-d', '--dryrun', action='store_true', default=False,
@@ -753,7 +767,7 @@ def read_upstream_edm(name_path):
     if not os.path.exists(directory):
       os.makedirs(directory)
 
-  gen = ClassGenerator(args.description, args.targetdir, args.packagename, args.iohandlers,
+  gen = ClassGenerator(args.description, args.targetdir, args.packagename, args.iohandlers, proglang=args.lang,
                        verbose=args.verbose, dryrun=args.dryrun, upstream_edm=args.upstream_edm,
                        old_description=args.old_description, evolution_file=args.evolution_file)
   if args.clangformat:

diff --git a/python/templates/CMakeLists.txt b/python/templates/CMakeLists.txt
@@ -25,4 +25,6 @@ set(PODIO_TEMPLATES
 
   ${CMAKE_CURRENT_LIST_DIR}/MutableStruct.jl.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/ParentModule.jl.jinja2
+  ${CMAKE_CURRENT_LIST_DIR}/macros/abstracttypes.jinja2
+  ${CMAKE_CURRENT_LIST_DIR}/macros/params.jinja2
 )
diff --git a/python/templates/Constructor.jl.jinja2 b/python/templates/Constructor.jl.jinja2
diff --git a/python/templates/JuliaCollection.jl.jinja2 b/python/templates/JuliaCollection.jl.jinja2
diff --git a/python/templates/ParentModule.jl.jinja2 b/python/templates/ParentModule.jl.jinja2
@@ -1,4 +1,5 @@
 {% import "macros/params.jinja2" as params %}
+{% import "macros/abstracttypes.jinja2" as abstdatatype %}
 module {{ class.bare_type }}
 {% for component in components %}
 export {{ component['class'].bare_type }}
@@ -21,7 +22,7 @@ function {{ component['class'].bare_type }}(
 	{% if member.is_array %}
 	{{ member.name }}::{{ member.julia_type }} = {{ member.julia_type }}(undef),
 	{% elif member.is_builtin %}
-	{{ member.name }}::{{ member.julia_type }} = {{ member.julia_type }}(0),
+	{{ member.name }}::{{ abstdatatype.classify_data_type(member.julia_type) }} = {{ member.julia_type }}(0),
 	{% else %}
 	{{ member.name }}::{{ member.julia_type }}Struct = {{ member.julia_type }}(),
 	{% endif %}
@@ -42,7 +43,11 @@ function {{ component['class'].bare_type }}(
 )
 	return {{ component['class'].bare_type }}Struct{{ params.julia_parameters(component['params_jl'], "", "Struct") }}(
 	{% for member in component['Members'] %}
+	{% if member.is_builtin %}
+	{{ member.julia_type }}({{ member.name }}),
+	{% else %}
 	{{ member.name }},
+	{% endif %}
 	{% endfor %}
 	{% for relation in component['OneToManyRelations'] %}
 	{{ relation.name }},
@@ -64,7 +69,7 @@ function {{ datatype['class'].bare_type }}(
 	{% if member.is_array %}
 	{{ member.name }}::{{ member.julia_type }} = {{ member.julia_type }}(undef),
 	{% elif member.is_builtin %}
-	{{ member.name }}::{{ member.julia_type }} = {{ member.julia_type }}(0),
+	{{ member.name }}::{{ abstdatatype.classify_data_type(member.julia_type) }} = {{ member.julia_type }}(0),
 	{% else %}
 	{{ member.name }}::{{ member.julia_type }}Struct = {{ member.julia_type }}(),
 	{% endif %}
@@ -85,7 +90,11 @@ function {{ datatype['class'].bare_type }}(
 )
 	return {{ datatype['class'].bare_type }}Struct{{ params.julia_parameters(datatype['params_jl'], "", "Struct") }}(
 	{% for member in datatype['Members'] %}
+	{% if member.is_builtin %}
+	{{ member.julia_type }}({{ member.name }}),
+	{% else %}
 	{{ member.name }},
+	{% endif %}
 	{% endfor %}
 	{% for relation in datatype['OneToManyRelations'] %}
 	{{ relation.name }},

diff --git a/python/templates/macros/abstracttypes.jinja2 b/python/templates/macros/abstracttypes.jinja2
@@ -0,0 +1,17 @@
+{% macro classify_data_type(data_type) %}
+    {%- set type_map = {
+        'Int8': 'Integer',
+        'UInt8': 'Integer',
+        'Int16': 'Integer',
+        'UInt16': 'Integer',
+        'Int32': 'Integer',
+        'UInt32': 'Integer',
+        'Int64': 'Integer',
+        'UInt64': 'Integer',
+        'Float16': 'Real',
+        'Float32': 'Real',
+        'Float64': 'Real'
+    } -%}
+
+    {{ type_map.get(data_type, data_type) }}
+{%- endmacro -%}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -64,6 +64,20 @@ add_subdirectory(schema_evolution)
 CREATE_PODIO_TEST(ostream_operator.cpp "")
 CREATE_PODIO_TEST(write_ascii.cpp "")
 
+PODIO_GENERATE_DATAMODEL(datamodeljulia datalayout.yaml headers sources
+  IO_BACKEND_HANDLERS ${PODIO_IO_HANDLERS}
+  OLD_DESCRIPTION datalayout_old.yaml
+  SCHEMA_EVOLUTION schema_evolution.yaml
+  LANG julia
+  )
+
+PODIO_GENERATE_DATAMODEL(extensionmodeljulia datalayout_extension.yaml ext_headers ext_sources
+  UPSTREAM_EDM datamodel:datalayout.yaml
+  IO_BACKEND_HANDLERS ${PODIO_IO_HANDLERS}
+  OUTPUT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/extension_model
+  LANG julia
+  )
+
 # Customize CTest to potentially disable some of the tests with known problems
 configure_file(CTestCustom.cmake ${PROJECT_BINARY_DIR}/CTestCustom.cmake @ONLY)
 find_program(Julia_EXECUTABLE julia)

diff --git a/tests/unittest.jl b/tests/unittest.jl
@@ -1,5 +1,5 @@
-include("datamodel/Datamodel.jl")
-using .Datamodel
+include("datamodeljulia/Datamodeljulia.jl")
+using .Datamodeljulia
 using Test
 @testset "Julia Bindings" begin
 	@testset "Relations" begin