From 2e1397918b2dcf97f6e0810c40469c2fa7e6dc01 Mon Sep 17 00:00:00 2001
From: Thomas Madlener <thomas.madlener@desy.de>
Date: Mon, 22 Jan 2024 13:15:07 +0100
Subject: [PATCH] Add support for interface types (#516)

* Make code generation process interfaces

* Implement interface types using type-erasure

* Add unittests for interface types

* Make sure to always store the immutable handle inside

* Put all type helpers into the podio namespace

Avoid collisions downstream

* make equality operators symmetric

* Return trivial types by value for consistency

* Improve method name to be more interface like

* Make interfaces only accept interfaced types

* Fix easy to fix python issues

* Add documentation for interface types

* Make checking for explicit types and if-else chain
---
 cmake/podioMacros.cmake                       |   7 +-
 doc/datamodel_syntax.md                       |  53 +++++-
 include/podio/utilities/TypeHelpers.h         |  93 +++++++++++
 python/podio_gen/cpp_generator.py             |  32 +++-
 python/podio_gen/generator_base.py            |  65 ++++++--
 python/podio_gen/generator_utils.py           |   8 +-
 python/podio_gen/julia_generator.py           |  12 ++
 python/podio_gen/podio_config_reader.py       |  72 +++++++-
 .../test_ClassDefinitionValidator.py          | 109 ++++++++++--
 python/templates/CMakeLists.txt               |   2 +
 python/templates/Interface.h.jinja2           | 157 ++++++++++++++++++
 python/templates/macros/collections.jinja2    |  20 +++
 python/templates/macros/interface.jinja2      |  48 ++++++
 tests/datalayout.yaml                         |  40 +++++
 tests/unittests/CMakeLists.txt                |   2 +-
 tests/unittests/interface_types.cpp           |  93 +++++++++++
 16 files changed, 770 insertions(+), 43 deletions(-)
 create mode 100644 python/templates/Interface.h.jinja2
 create mode 100644 python/templates/macros/interface.jinja2
 create mode 100644 tests/unittests/interface_types.cpp

diff --git a/cmake/podioMacros.cmake b/cmake/podioMacros.cmake
index 9ac7bd3af..0fd0bee39 100644
--- a/cmake/podioMacros.cmake
+++ b/cmake/podioMacros.cmake
@@ -203,8 +203,11 @@ function(PODIO_GENERATE_DATAMODEL datamodel YAML_FILE RETURN_HEADERS RETURN_SOUR
     ${YAML_FILE}
     ${PODIO_TEMPLATES}
     ${podio_PYTHON_DIR}/podio_class_generator.py
-    ${podio_PYTHON_DIR}/podio/generator_utils.py
-    ${podio_PYTHON_DIR}/podio/podio_config_reader.py
+    ${podio_PYTHON_DIR}/podio_gen/generator_utils.py
+    ${podio_PYTHON_DIR}/podio_gen/podio_config_reader.py
+    ${podio_PYTHON_DIR}/podio_gen/generator_base.py
+    ${podio_PYTHON_DIR}/podio_gen/cpp_generator.py
+    ${podio_PYTHON_DIR}/podio_gen/julia_generator.py
   )
 
   message(STATUS "Creating '${datamodel}' datamodel")
diff --git a/doc/datamodel_syntax.md b/doc/datamodel_syntax.md
index 5644d10a6..04e6753bd 100644
--- a/doc/datamodel_syntax.md
+++ b/doc/datamodel_syntax.md
@@ -9,6 +9,7 @@ PODIO encourages the usage of composition, rather than inheritance.
 One of the reasons for doing so is the focus on efficiency friendly `plain-old-data`.
 For this reason, PODIO does not support inheritance within the defined data model.
 Instead, users can combine multiple `components` to build a to be used `datatype`.
+Additionally, if several datatypes should be callable through the same interface, the `interface` category can be used.
 
 To allow the datatypes to be real PODs, the data stored within the data model are constrained to be
 POD-compatible data. Those are
@@ -92,7 +93,6 @@ For describing physics quantities it is important to know their units. Thus it i
       <type> <name>{<default-value>} [<unit>] // <comment>
 ```
 
-
 ### Definition of references between objects:
 There can be one-to-one-relations and one-to-many relations being stored in a particular class. This happens either in the `OneToOneRelations` or `OneToManyRelations` section of the data definition. The definition has again the form:
 
@@ -126,6 +126,57 @@ The `includes` will be add to the header files of the generated classes.
 
 The code being provided has to use the macro `{name}` in place of the concrete name of the class.
 
+## Definition of custom interfaces
+An interface type can be defined as follows (again using an example from the example datamodel)
+
+```yaml
+    interfaces:
+      TypeWithEnergy:
+        Description: "A generic interface for types with an energy member"
+        Author: "Someone"
+        Types:
+          - ExampleHit
+          - ExampleMC
+          - ExampleCluster
+        Members:
+          - double energy // the energy
+```
+
+This definition will yield a class called `TypeWithEnergy` that has one public
+method to get the `energy`. Here the syntax for defining more accessors is
+exactly the same as it is for the `datatypes`. Additionally, it is necessary to
+define which `Types` can be used with this interface class, in this case the
+`ExampleHit`, `ExampleMC` or an `ExampleCluster`. **NOTE: `interface` types do
+not allow for mutable access to their data.** They can be used in relations
+between objects, just like normal `datatypes`.
+
+### Assigning to interface types
+
+Interface types support the same functionality as normal (immutable) datatypes.
+The main additional functionality they offer is the possibility to directly
+assign to them (if they type is supported) and to query them for the type that
+is currently being held internally.
+
+```cpp
+auto energyType = TypeWithEnergy{}; // An empty interface is possible but useless
+bool valid = energyType.isValid();  // <-- false
+
+auto hit = ExampleHit{};
+energyType = hit;     // assigning a hit to the interface type
+energyType.energy();  // <-- get's the energy from the underlying hit
+
+auto cluster = ExampleCluster{};
+energyType = cluster; // ra-assigning another object is possible
+bool same = (energyType == cluster); // <-- true (comparisons work as expected)
+
+bool isCluster = energyType.isA<ExampleCluster>(); // <-- true
+bool isHit     = energyType.isA<ExampleHit>();     // <-- false
+
+auto newCluster = energyType.getValue<ExampleCluster>(); // <-- "cast back" to original type
+
+// "Casting" only works if the types match. Otherwise there will be an exception
+auto newHit = energyType.getValue<ExampleHit>(); // <-- exception
+```
 
 ## Global options
 Some customization of the generated code is possible through flags. These flags are listed in the section `options`:
diff --git a/include/podio/utilities/TypeHelpers.h b/include/podio/utilities/TypeHelpers.h
index 74d1a4d28..7c794230c 100644
--- a/include/podio/utilities/TypeHelpers.h
+++ b/include/podio/utilities/TypeHelpers.h
@@ -9,6 +9,45 @@
 #include <vector>
 
 namespace podio {
+#if __has_include("experimental/type_traits.h")
+  #include <experimental/type_traits>
+namespace det {
+  using namespace std::experimental;
+} // namespace det
+#else
+// Implement the minimal feature set we need
+namespace det {
+  namespace detail {
+    template <typename DefT, typename AlwaysVoidT, template <typename...> typename Op, typename... Args>
+    struct detector {
+      using value_t = std::false_type;
+      using type = DefT;
+    };
+
+    template <typename DefT, template <typename...> typename Op, typename... Args>
+    struct detector<DefT, std::void_t<Op<Args...>>, Op, Args...> {
+      using value_t = std::true_type;
+      using type = Op<Args...>;
+    };
+  } // namespace detail
+
+  struct nonesuch {
+    ~nonesuch() = delete;
+    nonesuch(const nonesuch&) = delete;
+    void operator=(const nonesuch&) = delete;
+  };
+
+  template <template <typename...> typename Op, typename... Args>
+  using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;
+
+  template <template <typename...> typename Op, typename... Args>
+  static constexpr bool is_detected_v = is_detected<Op, Args...>::value;
+
+  template <typename DefT, template <typename...> typename Op, typename... Args>
+  using detected_or = detail::detector<DefT, void, Op, Args...>;
+} // namespace det
+#endif
+
 namespace detail {
 
   /**
@@ -158,6 +197,60 @@ namespace detail {
   template <typename T>
   using GetMappedType = typename MapLikeTypeHelper<T>::mapped_type;
 
+  /**
+   * Detector for checking the existence of a mutable_type type member. Used to
+   * determine whether T is (or could be) a podio generated default (immutable)
+   * handle.
+   */
+  template <typename T>
+  using hasMutable_t = typename T::mutable_type;
+
+  /**
+   * Detector for checking the existance of an object_type type member. Used ot
+   * determine whether T is (or could be) a podio generated mutable handle.
+   */
+  template <typename T>
+  using hasObject_t = typename T::object_type;
+
+  /**
+   * Variable template for determining whether type T is a podio generated
+   * handle class.
+   *
+   * NOTE: this basically just checks the existance of the mutable_type and
+   * object_type type members, so it is rather easy to fool this check if one
+   * wanted to. However, for our purposes we mainly need it for a static_assert
+   * to have more understandable compilation error message.
+   */
+  template <typename T>
+  constexpr static bool isPodioType = det::is_detected_v<hasObject_t, T> || det::is_detected_v<hasMutable_t, T>;
+
+  /**
+   * Variable template for obtaining the default handle type from any podio
+   * generated handle type.
+   *
+   * If T is already a default handle, this will return T, if T is a mutable
+   * handle it will return T::object_type.
+   */
+  template <typename T>
+  using GetDefaultHandleType = typename det::detected_or<T, hasObject_t, T>::type;
+
+  /**
+   * Variable template for obtaining the mutable handle type from any podio
+   * generated handle type.
+   *
+   * If T is alrady a mutable handle, this will return T, if T is a default
+   * handle it will return T::mutable_type.
+   */
+  template <typename T>
+  using GetMutableHandleType = typename det::detected_or<T, hasMutable_t, T>::type;
+
+  /**
+   * Helper type alias to transform a tuple of handle types to a tuple of
+   * mutable handle types.
+   */
+  template <typename Tuple>
+  using TupleOfMutableTypes = typename ToTupleOfTemplateHelper<GetMutableHandleType, Tuple>::type;
+
 } // namespace detail
 
 // forward declaration to be able to use it below
diff --git a/python/podio_gen/cpp_generator.py b/python/podio_gen/cpp_generator.py
index a22fce38b..82542b151 100644
--- a/python/podio_gen/cpp_generator.py
+++ b/python/podio_gen/cpp_generator.py
@@ -103,6 +103,8 @@ def do_process_component(self, name, component):
       self._fill_templates('Component', component)
       self.root_schema_component_names.add(name + self.old_schema_version)
 
+    return component
+
   def do_process_datatype(self, name, datatype):
     """Do the cpp specific processing of a datatype"""
     datatype["includes_data"] = self._get_member_includes(datatype["Members"])
@@ -152,6 +154,17 @@ def do_process_datatype(self, name, datatype):
     if 'SIO' in self.io_handlers:
       self._fill_templates('SIOBlock', datatype)
 
+    return datatype
+
+  def do_process_interface(self, _, interface):
+    """Process an interface definition and generate the necesary code"""
+    interface["include_types"] = [
+        self._build_include(t) for t in interface["Types"]
+        ]
+
+    self._fill_templates("Interface", interface)
+    return interface
+
   def print_report(self):
     """Print a summary report about the generated code"""
     if not self.verbose:
@@ -176,6 +189,8 @@ def _preprocess_for_class(self, datatype):
         member.sub_members = self.datamodel.components[member.full_type]['Members']
 
     for relation in datatype['OneToOneRelations']:
+      if self._is_interface(relation.full_type):
+        relation.interface_types = self.datamodel.interfaces[relation.full_type]["Types"]
       if self._needs_include(relation.full_type):
         if relation.namespace not in fwd_declarations:
           fwd_declarations[relation.namespace] = []
@@ -188,6 +203,8 @@ def _preprocess_for_class(self, datatype):
       includes.add('#include "podio/RelationRange.h"')
 
     for relation in datatype['OneToManyRelations']:
+      if self._is_interface(relation.full_type):
+        relation.interface_types = self.datamodel.interfaces[relation.full_type]["Types"]
       if self._needs_include(relation.full_type):
         includes.add(self._build_include(relation))
 
@@ -243,7 +260,12 @@ def _preprocess_for_collection(self, datatype):
     for relation in datatype['OneToManyRelations'] + datatype['OneToOneRelations']:
       if datatype['class'].bare_type != relation.bare_type:
         include_from = self._needs_include(relation.full_type)
-        includes_cc.add(self._build_include_for_class(relation.bare_type + 'Collection', include_from))
+        if self._is_interface(relation.full_type):
+          includes_cc.add(self._build_include_for_class(relation.bare_type, include_from))
+          for int_type in relation.interface_types:
+            includes_cc.add(self._build_include_for_class(int_type.bare_type + 'Collection', include_from))
+        else:
+          includes_cc.add(self._build_include_for_class(relation.bare_type + 'Collection', include_from))
         includes.add(self._build_include_for_class(relation.bare_type, include_from))
 
     if datatype['VectorMembers']:
@@ -425,11 +447,15 @@ def _get_member_includes(self, members):
 
   def _needs_include(self, classname) -> IncludeFrom:
     """Check whether the member needs an include from within the datamodel"""
-    if classname in self.datamodel.components or classname in self.datamodel.datatypes:
+    if classname in self.datamodel.components or \
+       classname in self.datamodel.datatypes or \
+       classname in self.datamodel.interfaces:
       return IncludeFrom.INTERNAL
 
     if self.upstream_edm:
-      if classname in self.upstream_edm.components or classname in self.upstream_edm.datatypes:
+      if classname in self.upstream_edm.components or \
+         classname in self.upstream_edm.datatypes or \
+         classname in self.upstream_edm.interfaces:
         return IncludeFrom.EXTERNAL
 
     return IncludeFrom.NOWHERE
diff --git a/python/podio_gen/generator_base.py b/python/podio_gen/generator_base.py
index 698bd94dd..4b798fd1a 100644
--- a/python/podio_gen/generator_base.py
+++ b/python/podio_gen/generator_base.py
@@ -73,26 +73,38 @@ class ClassGeneratorBaseMixin:
                          processed. Needs to return a (potentially) empty
                          dictionary
 
-  do_process_component(name: str, component: dict): do some language specific
-                       processing for a component populating the component
-                       dictionary further. When called only the "class" key will
-                       be populated. This function also has to to take care of
-                       filling the necessary templates!
+  do_process_component(name: str, component: dict) -> dict: do some language
+                       specific processing for a component populating the
+                       component dictionary further. When called only the
+                       "class" key will be populated. Return a dictionary or
+                       None. If None, this will not be put into the "components"
+                       list. This function also has to to take care of filling
+                       the necessary templates!
 
   do_process_datatype(name: str, datatype: dict): do some language specific
                       processing for a datatype populating the datatype
                       dictionary further. When called only the "class" key will
-                      be populated. This function also has to take care of
-                      filling the necessary templates!
+                      be populated. Return a dictionary or None. If None, this
+                      will not be put into the "datatypes" list. This function
+                      also has to take care of filling the necessary templates!
+
+  do_process_interface(name: str, interface: dict): do some language specific
+                       processing for an interface type, populating the
+                       interface dictionary further. When called only the
+                       "class" key will be populated. Return a dictionary or
+                       None. If None, this will not be put into the "interfaces"
+                       list. This function also has to take care of filling the
+                       necessary templates!
 
   post_process(datamodel: dict): do some global post processing for which all
                components and datatypes need to have been processed already.
                Gets called with the dictionary that has been created in
                pre_proces and filled during the processing. The process
-               components and datatypes are accessible via the "components" and
-               "datatypes" keys respectively.
+               components and datatypes are accessible via the "components",
+               "datatypes" and "interfaces" keys respectively.
 
   print_report(): prints a report summarizing what has been generated
+
   """
   def __init__(self, yamlfile, install_dir, package_name, verbose, dryrun, upstream_edm):
     self.yamlfile = yamlfile
@@ -128,12 +140,22 @@ def process(self):
 
     datamodel['components'] = []
     datamodel['datatypes'] = []
+    datamodel['interfaces'] = []
 
     for name, component in self.datamodel.components.items():
-      datamodel["components"].append(self._process_component(name, component))
+      comp = self._process_component(name, component)
+      if comp is not None:
+        datamodel["components"].append(comp)
 
     for name, datatype in self.datamodel.datatypes.items():
-      datamodel["datatypes"].append(self._process_datatype(name, datatype))
+      datat = self._process_datatype(name, datatype)
+      if datat is not None:
+        datamodel["datatypes"].append(datat)
+
+    for name, interface in self.datamodel.interfaces.items():
+      interf = self._process_interface(name, interface)
+      if interf is not None:
+        datamodel["interfaces"].append(interf)
 
     self.post_process(datamodel)
     if self.verbose:
@@ -147,8 +169,7 @@ def _process_component(self, name, component):
     component = deepcopy(component)
     component['class'] = DataType(name)
 
-    self.do_process_component(name, component)
-    return component
+    return self.do_process_component(name, component)
 
   def _process_datatype(self, name, datatype):
     """Process a single datatype into a dictionary that can be used in jinja2
@@ -156,9 +177,15 @@ def _process_datatype(self, name, datatype):
     datatype = deepcopy(datatype)
     datatype["class"] = DataType(name)
 
-    self.do_process_datatype(name, datatype)
+    return self.do_process_datatype(name, datatype)
 
-    return datatype
+  def _process_interface(self, name, interface):
+    """Process a single interface definition into a dictionary that can be used
+    in jinja2 templates and return that"""
+    interface = deepcopy(interface)
+    interface["class"] = DataType(name)
+
+    return self.do_process_interface(name, interface)
 
   @staticmethod
   def _get_filenames_templates(template_base, name):
@@ -182,6 +209,7 @@ def get_fn_format(tmpl):
     endings = {
         'Data': ('h',),
         'PrintInfo': ('h',),
+        'Interface': ('h',),
         'MutableStruct': ('jl',),
         'ParentModule': ('jl',),
         }.get(template_base, ('h', 'cc'))
@@ -228,3 +256,10 @@ def _fill_templates(self, template_base, data, old_schema_data=None):
     data['incfolder'] = self.incfolder
     for filename, template in self._get_filenames_templates(template_base, data['class'].bare_type):
       self._write_file(filename, self._eval_template(template, data, old_schema_data))
+
+  def _is_interface(self, classname):
+    """Check whether this is an interface type or a regular datatype"""
+    all_interfaces = self.datamodel.interfaces
+    if self.upstream_edm:
+      all_interfaces = list(self.datamodel.interfaces) + list(self.upstream_edm.interfaces)
+    return classname in all_interfaces
diff --git a/python/podio_gen/generator_utils.py b/python/podio_gen/generator_utils.py
index dfc47ec5c..a2d8b680c 100644
--- a/python/podio_gen/generator_utils.py
+++ b/python/podio_gen/generator_utils.py
@@ -116,6 +116,10 @@ def __str__(self):
 
     return scoped_type
 
+  def _to_json(self):
+    """Return a string representation that can be parsed again"""
+    return self.full_type
+
 
 class MemberVariable:
   """Simple class to hold information about a member variable"""
@@ -138,6 +142,7 @@ def __init__(self, name, **kwargs):
 
     self.includes = set()
     self.jl_imports = set()
+    self.interface_types = []  # populated in the generator script if necessary
 
     if kwargs:
       raise ValueError(f"Unused kwargs in MemberVariable: {list(kwargs.keys())}")
@@ -258,7 +263,7 @@ def _to_json(self):
 
 class DataModel:  # pylint: disable=too-few-public-methods
   """A class for holding a complete datamodel read from a configuration file"""
-  def __init__(self, datatypes=None, components=None, options=None, schema_version=None):
+  def __init__(self, datatypes=None, components=None, interfaces=None, options=None, schema_version=None):
     self.options = options or {
         # should getters / setters be prefixed with get / set?
         "getSyntax": False,
@@ -270,6 +275,7 @@ def __init__(self, datatypes=None, components=None, options=None, schema_version
     self.schema_version = schema_version
     self.components = components or {}
     self.datatypes = datatypes or {}
+    self.interfaces = interfaces or {}
 
   def _to_json(self):
     """Return the dictionary, so that we can easily hook this into the pythons
diff --git a/python/podio_gen/julia_generator.py b/python/podio_gen/julia_generator.py
index 17173a772..82fe18ffd 100644
--- a/python/podio_gen/julia_generator.py
+++ b/python/podio_gen/julia_generator.py
@@ -46,13 +46,25 @@ def do_process_component(self, _, component):
     component['upstream_edm'] = self.upstream_edm
     component['upstream_edm_name'] = self.get_upstream_name()
     self._fill_templates("MutableStruct", component)
+    return component
 
   def do_process_datatype(self, _, datatype):
     """Do the julia specific processing for a datatype"""
+    if any(self._is_interface(r.full_type) for r in datatype["OneToOneRelations"] + datatype["OneToManyRelations"]):
+      # Julia doesn't support any interfaces yet, so we have to also sort out
+      # all the datatypes that use them
+      return None
+
     datatype["params_jl"] = sorted(self._get_julia_params(datatype), key=lambda x: x[0])
     datatype["upstream_edm"] = self.upstream_edm
     datatype["upstream_edm_name"] = self.get_upstream_name()
+
     self._fill_templates("MutableStruct", datatype)
+    return datatype
+
+  def do_process_interface(self, _, __):
+    """Julia does not support interface types yet, so this does nothing"""
+    return None
 
   def get_upstream_name(self):
     """Get the name of the upstream datamodel if any"""
diff --git a/python/podio_gen/podio_config_reader.py b/python/podio_gen/podio_config_reader.py
index 1dea8b0bb..39275b503 100644
--- a/python/podio_gen/podio_config_reader.py
+++ b/python/podio_gen/podio_config_reader.py
@@ -6,7 +6,7 @@
 import warnings
 import yaml
 
-from podio_gen.generator_utils import MemberVariable, DefinitionError, BUILTIN_TYPES, DataModel
+from podio_gen.generator_utils import MemberVariable, DefinitionError, BUILTIN_TYPES, DataModel, DataType
 
 
 class MemberParser:
@@ -141,6 +141,13 @@ class ClassDefinitionValidator:
       "Typedefs",
       )
 
+  # The interface definitions need the normal datatype keys plus Types to which
+  # it applies and also which accessor functions to generate
+  required_interface_keys = required_datatype_keys + (
+      "Members",
+      "Types"
+      )
+
   valid_extra_code_keys = ("declaration", "implementation", "includes")
   # documented but not yet implemented
   not_yet_implemented_extra_code = ('declarationFile', 'implementationFile')
@@ -151,6 +158,7 @@ def validate(cls, datamodel, upstream_edm=None):
     cls._check_components(datamodel, upstream_edm)
     expose_pod_members = datamodel.options['exposePODMembers']
     cls._check_datatypes(datamodel, expose_pod_members, upstream_edm)
+    cls._check_interfaces(datamodel, upstream_edm)
 
   @classmethod
   def _check_comp(cls, member, components, upstream_edm):
@@ -195,6 +203,19 @@ def _check_datatypes(cls, datamodel, expose_pod_members, upstream_edm):
       cls._fill_defaults(definition)
       cls._check_datatype(name, definition, expose_pod_members, datamodel, upstream_edm)
 
+  @classmethod
+  def _check_interfaces(cls, datamodel, upstream_edm):
+    """Check the interface definitions"""
+    all_types = list(datamodel.datatypes.keys())
+    ext_types = upstream_edm.datatypes.keys() if upstream_edm else []
+    all_types.extend(ext_types)
+
+    for name, definition in datamodel.interfaces.items():
+      if name in all_types:
+        raise DefinitionError(f"'{name}' defines an interface type with the same name as an existing datatype")
+      cls._check_interface_fields(name, definition)
+      cls._check_interface_types(name, definition, all_types)
+
   @classmethod
   def _check_datatype(cls, classname, definition, expose_pod_members, datamodel, upstream_edm):
     """Check that a datatype only defines valid types and relations."""
@@ -234,9 +255,9 @@ def _check_members(cls, classname, members, expose_pod_members, datamodel, upstr
   def _check_relations(cls, classname, definition, datamodel, upstream_edm):
     """Check the relations of a class."""
     def _valid_datatype(rel_type):
-      if rel_type in datamodel.datatypes:
+      if rel_type in datamodel.datatypes or rel_type in datamodel.interfaces:
         return True
-      if upstream_edm and rel_type in upstream_edm.datatypes:
+      if upstream_edm and (rel_type in upstream_edm.datatypes or rel_type in upstream_edm.interfaces):
         return True
       return False
 
@@ -286,6 +307,24 @@ def _check_keys(cls, classname, definition):
 
         raise DefinitionError("{classname} defines invalid 'ExtraCode' categories: {invalid_keys}{not_yet_impl}")
 
+  @classmethod
+  def _check_interface_fields(cls, name, definition):
+    """Check whether the fields of an interface definition follow the required schema"""
+    for key in cls.required_interface_keys:
+      if key not in definition:
+        raise DefinitionError(f"interface '{name}' does not define '{key}' field which is required")
+
+    invalid_keys = [k for k in definition.keys() if k not in cls.required_interface_keys]
+    if invalid_keys:
+      raise DefinitionError(f"interface '{name}' defines invalid fields: {invalid_keys}")
+
+  @classmethod
+  def _check_interface_types(cls, name, definition, known_datatypes):
+    """Check whether an interface really only uses known datatypes"""
+    for wrapped_type in definition["Types"]:
+      if wrapped_type.full_type not in known_datatypes:
+        raise DefinitionError(f"interface '{name}' tries to use Type '{wrapped_type}' which is not defined anywhere")
+
   @classmethod
   def _fill_defaults(cls, definition):
     """Fill some of the fields with empty defaults in order to make it easier to
@@ -359,6 +398,26 @@ def _read_datatype(cls, value):
 
     return datatype
 
+  @classmethod
+  def _read_interface(cls, value):
+    """Read an interface definition and put it into a more easily digestible format"""
+    interface = {}
+    for category, definition in value.items():
+      if category == "Members":
+        members = []
+        for member in definition:
+          members.append(cls.member_parser.parse(member))
+        interface["Members"] = members
+      elif category == "Types":
+        types = []
+        for typ in definition:
+          types.append(DataType(typ))
+        interface["Types"] = types
+      else:
+        interface[category] = copy.deepcopy(definition)
+
+    return interface
+
   @classmethod
   def parse_model(cls, model_dict, package_name, upstream_edm=None):
     """Parse a model from the dictionary, e.g. read from a yaml file."""
@@ -382,6 +441,11 @@ def parse_model(cls, model_dict, package_name, upstream_edm=None):
       for klassname, value in model_dict["datatypes"].items():
         datatypes[klassname] = cls._read_datatype(value)
 
+    interfaces = {}
+    if "interfaces" in model_dict:
+      for klassname, value in model_dict["interfaces"].items():
+        interfaces[klassname] = cls._read_interface(value)
+
     options = copy.deepcopy(cls.options)
     if "options" in model_dict:
       for option, value in model_dict["options"].items():
@@ -395,7 +459,7 @@ def parse_model(cls, model_dict, package_name, upstream_edm=None):
 
     # If this doesn't raise an exception everything should in principle work out
     validator = ClassDefinitionValidator()
-    datamodel = DataModel(datatypes, components, options, schema_version)
+    datamodel = DataModel(datatypes, components, interfaces, options, schema_version)
     validator.validate(datamodel, upstream_edm)
     return datamodel
 
diff --git a/python/podio_gen/test_ClassDefinitionValidator.py b/python/podio_gen/test_ClassDefinitionValidator.py
index 1f712926b..8cd80b8b9 100644
--- a/python/podio_gen/test_ClassDefinitionValidator.py
+++ b/python/podio_gen/test_ClassDefinitionValidator.py
@@ -9,16 +9,16 @@
 from copy import deepcopy
 
 from podio_gen.podio_config_reader import ClassDefinitionValidator, MemberVariable, DefinitionError
-from podio_gen.generator_utils import DataModel
+from podio_gen.generator_utils import DataModel, DataType
 
 
-def make_dm(components, datatypes, options=None):
+def make_dm(components, datatypes, interfaces=None, options=None):
   """Small helper function to turn things into a datamodel dict as expected by
   the validator"""
-  return DataModel(datatypes, components, options)
+  return DataModel(datatypes, components, interfaces, options)
 
 
-class ClassDefinitionValidatorTest(unittest.TestCase):
+class ClassDefinitionValidatorTest(unittest.TestCase):  # pylint: disable=too-many-public-methods
   """Unit tests for the ClassDefinitionValidator"""
   def setUp(self):
     valid_component_members = [
@@ -60,6 +60,15 @@ def setUp(self):
             }
         }
 
+    self.valid_interface = {
+        "InterfaceType": {
+            "Author": "Karma Chameleon",
+            "Description": "I can be many things but only one at a time",
+            "Members": valid_datatype_members,
+            "Types": [DataType("DataType")]
+            }
+        }
+
     # The default options that should be used for validation
     self.def_opts = {'exposePODMembers': False}
 
@@ -111,13 +120,13 @@ def test_component_valid_members(self):
 
   def test_datatype_valid_members(self):
     self._assert_no_exception(DefinitionError, '{} should not raise for a valid datatype',
-                              self.validate, make_dm({}, self.valid_datatype, self.def_opts))
+                              self.validate, make_dm({}, self.valid_datatype, options=self.def_opts))
 
     # things should still work if we add a component member
     self.valid_datatype['DataType']['Members'].append(MemberVariable(type='Component', name='comp'))
     self._assert_no_exception(DefinitionError, '{} should allow for members that are components',
                               self.validate,
-                              make_dm(self.valid_component, self.valid_datatype, self.def_opts))
+                              make_dm(self.valid_component, self.valid_datatype, options=self.def_opts))
 
     # also when we add an array of components
     self.valid_datatype['DataType']['Members'].append(MemberVariable(array_type='Component',
@@ -125,14 +134,14 @@ def test_datatype_valid_members(self):
                                                                      name='arrComp'))
     self._assert_no_exception(DefinitionError, '{} should allow for arrays of components as members',
                               self.validate,
-                              make_dm(self.valid_component, self.valid_datatype, self.def_opts))
+                              make_dm(self.valid_component, self.valid_datatype, options=self.def_opts))
 
     # pod members can be redefined if they are note exposed
     self.valid_datatype['DataType']['Members'].append(MemberVariable(type='double', name='aFloat'))
     self._assert_no_exception(DefinitionError,
                               '{} should allow for re-use of component names if the components are not exposed',
                               self.validate,
-                              make_dm(self.valid_component, self.valid_datatype, self.def_opts))
+                              make_dm(self.valid_component, self.valid_datatype, options=self.def_opts))
 
     datatype = {
         'DataTypeWithoutMembers': {
@@ -140,7 +149,7 @@ def test_datatype_valid_members(self):
             }
         }
     self._assert_no_exception(DefinitionError, '{} should allow for almost empty datatypes',
-                              self.validate, make_dm({}, datatype, self.def_opts))
+                              self.validate, make_dm({}, datatype, options=self.def_opts))
 
   def test_datatype_invalid_definitions(self):
     for required in ('Author', 'Description'):
@@ -288,7 +297,7 @@ def test_component_valid_upstream(self):
     upstream_dm = make_dm(self.valid_component, {})
 
     self._assert_no_exception(DefinitionError, '{} should allow to use upstream components in components',
-                              self.validate, make_dm(component, {}, self.def_opts), upstream_dm)
+                              self.validate, make_dm(component, {}, options=self.def_opts), upstream_dm)
 
   def test_component_invalid_upstream(self):
     """Test that a component does not pass if it is not available upstream or in the
@@ -344,7 +353,7 @@ def test_datatype_valid_upstream(self):
 
     upstream_dm = make_dm(self.valid_component, self.valid_datatype, self.def_opts)
     self._assert_no_exception(DefinitionError, '{} should allow to use to use upstream datatypes and components',
-                              self.validate, make_dm({}, datatype, self.def_opts), upstream_dm)
+                              self.validate, make_dm({}, datatype, {}, self.def_opts), upstream_dm)
 
   def test_datatype_invalid_upstream(self):
     """Test that datatypes that are not from upstream cannot be used"""
@@ -355,30 +364,98 @@ def test_datatype_invalid_upstream(self):
             }
         }
 
-    upstream_dm = make_dm(self.valid_component, self.valid_datatype, self.def_opts)
+    upstream_dm = make_dm(self.valid_component, self.valid_datatype, {}, self.def_opts)
 
     # Check for invalid members
     dtype = deepcopy(basetype)
     dtype['DsType']['Members'] = [MemberVariable(type='InvalidType', name='foo', description='non existant upstream')]
     with self.assertRaises(DefinitionError):
-      self.validate(make_dm({}, dtype, self.def_opts), upstream_dm)
+      self.validate(make_dm({}, dtype, options=self.def_opts), upstream_dm)
 
     # Check relations
     dtype = deepcopy(basetype)
     dtype['DsType']['OneToOneRelations'] = [MemberVariable(type='InvalidType', name='foo', description='invalid')]
     with self.assertRaises(DefinitionError):
-      self.validate(make_dm({}, dtype, self.def_opts), upstream_dm)
+      self.validate(make_dm({}, dtype, options=self.def_opts), upstream_dm)
 
     dtype = deepcopy(basetype)
     dtype['DsType']['OneToManyRelations'] = [MemberVariable(type='InvalidType', name='foo', description='invalid')]
     with self.assertRaises(DefinitionError):
-      self.validate(make_dm({}, dtype, self.def_opts), upstream_dm)
+      self.validate(make_dm({}, dtype, options=self.def_opts), upstream_dm)
 
     # vector members
     dtype = deepcopy(basetype)
     dtype['DsType']['VectorMembers'] = [MemberVariable(type='InvalidType', name='foo', description='invalid')]
     with self.assertRaises(DefinitionError):
-      self.validate(make_dm({}, dtype, self.def_opts), upstream_dm)
+      self.validate(make_dm({}, dtype, options=self.def_opts), upstream_dm)
+
+  def test_interface_valid_def(self):
+    """Make sure that a valid interface definition inside a valid datamodel passes without exceptions"""
+    self._assert_no_exception(DefinitionError, '{} should not raise for a valid interface type',
+                              self.validate, make_dm({}, self.valid_datatype, self.valid_interface), False)
+
+  def test_interface_invalid_fields(self):
+    """Make sure that interface definitions do not contain any superfluous fields"""
+    for inv_field in ['OneToManyRelations', 'VectorMembers', 'OneToOneRelations']:
+      interface = deepcopy(self.valid_interface)
+      interface['InterfaceType'][inv_field] = ['An invalid field']
+      with self.assertRaises(DefinitionError):
+        self.validate(make_dm({}, self.valid_datatype, interface), False)
+
+  def test_interface_missing_fields(self):
+    """Make sure that interfaces have all the required types when they pass validation"""
+    for req in ('Author', 'Description', 'Members', 'Types'):
+      int_type = deepcopy(self.valid_interface)
+      del int_type['InterfaceType'][req]
+      with self.assertRaises(DefinitionError):
+        self.validate(make_dm({}, self.valid_datatype, int_type), False)
+
+  def test_interface_only_defined_datatypes(self):
+    """Make sure that the interface only uses defined datatypes"""
+    int_type = deepcopy(self.valid_interface)
+    int_type['InterfaceType']['Types'].append(DataType('UndefinedType'))
+    with self.assertRaises(DefinitionError):
+      self.validate(make_dm({}, self.valid_datatype, int_type), False)
+
+    int_type = deepcopy(self.valid_interface)
+    int_type['InterfaceType']['Types'].append(DataType('Component'))
+
+    int_type = deepcopy(self.valid_interface)
+    int_type['InterfaceType']['Types'].append(DataType('float'))
+    with self.assertRaises(DefinitionError):
+      self.validate(make_dm({}, self.valid_datatype, int_type), False)
+
+  def test_interface_no_redefining_datatype(self):
+    """Make sure that there is no datatype already with the same name"""
+    int_type = {
+        'DataType': {
+            'Author': 'Copycat',
+            'Description': 'I shall not redefine datatypes as interfaces',
+            'Members': [],
+            'Types': []
+            }
+        }
+    with self.assertRaises(DefinitionError):
+      self.validate(make_dm({}, self.valid_datatype, int_type), False)
+
+  def test_datatype_uses_interface_type(self):
+    """Make sure that a data type can use a valid interface definition"""
+    datatype = deepcopy(self.valid_datatype)
+    datatype['DataType']['OneToManyRelations'] = [MemberVariable(type='InterfaceType', name='interfaceRelation')]
+    self._assert_no_exception(DefinitionError, '{} should allow to use relations to interface types',
+                              self.validate, make_dm({}, datatype, self.valid_interface), False)
+
+  def test_interface_valid_upstream(self):
+    """Make sure that we can use interface definitions from upstream models"""
+    # Create an upstream datamodel that contains the interface type
+    upstream_dm = make_dm({}, self.valid_datatype, self.valid_interface)
+
+    # Make a downstream model datatype that uses the interface from the upstream
+    # but doesn't bring along its own interface definitions
+    datatype = {'DownstreamType': deepcopy(self.valid_datatype['DataType'])}
+    datatype['DownstreamType']['OneToOneRelations'] = [MemberVariable(type='InterfaceType', name='interfaceRelation')]
+    self._assert_no_exception(DefinitionError, '{} should allow to use interface types from an upstream datamodel',
+                              self.validate, make_dm({}, datatype), upstream_dm)
 
 
 if __name__ == '__main__':
diff --git a/python/templates/CMakeLists.txt b/python/templates/CMakeLists.txt
index 83a52996a..503097189 100644
--- a/python/templates/CMakeLists.txt
+++ b/python/templates/CMakeLists.txt
@@ -10,6 +10,7 @@ set(PODIO_TEMPLATES
   ${CMAKE_CURRENT_LIST_DIR}/Obj.cc.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/Object.cc.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/Object.h.jinja2
+  ${CMAKE_CURRENT_LIST_DIR}/Interface.h.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/MutableObject.cc.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/MutableObject.h.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/selection.xml.jinja2
@@ -22,6 +23,7 @@ set(PODIO_TEMPLATES
   ${CMAKE_CURRENT_LIST_DIR}/macros/iterator.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/macros/sioblocks.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/macros/utils.jinja2
+  ${CMAKE_CURRENT_LIST_DIR}/macros/interface.jinja2
 
   ${CMAKE_CURRENT_LIST_DIR}/MutableStruct.jl.jinja2
   ${CMAKE_CURRENT_LIST_DIR}/ParentModule.jl.jinja2
diff --git a/python/templates/Interface.h.jinja2 b/python/templates/Interface.h.jinja2
new file mode 100644
index 000000000..cdb87f350
--- /dev/null
+++ b/python/templates/Interface.h.jinja2
@@ -0,0 +1,157 @@
+{% import "macros/declarations.jinja2" as common_macros %}
+{% import "macros/utils.jinja2" as utils %}
+{% import "macros/interface.jinja2" as macros %}
+// AUTOMATICALLY GENERATED FILE - DO NOT EDIT
+
+#ifndef {{ package_name.upper() }}_{{ class.bare_type }}_H
+#define {{ package_name.upper() }}_{{ class.bare_type }}_H
+
+{% for include in include_types %}
+{{ include }}
+{% endfor %}
+
+#include "podio/ObjectID.h"
+#include "podio/utilities/TypeHelpers.h"
+
+#include <memory>
+#include <ostream>
+#include <stdexcept>
+
+{{ utils.namespace_open(class.namespace) }}
+
+{{ common_macros.class_description(class.bare_type, Description, Author) }}
+class {{ class.bare_type }} {
+
+  /// type alias containing all the types this interface should work for.
+  using InterfacedTypes = std::tuple<{{ Types | join(", ")}}>;
+  /// type alias containing all the mutable types that can be used to initalize
+  /// this interface
+  using InterfacedMutableTypes = podio::detail::TupleOfMutableTypes<InterfacedTypes>;
+
+  /// template variable for determining whether type T is a valid interface type
+  template<typename T>
+  constexpr static bool isInterfacedType = podio::detail::isInTuple<T, InterfacedTypes>;
+
+  /// template variable for determining whether type T can be used to initialize
+  /// this interface
+  template<typename T>
+  constexpr static bool isInitializableFrom = isInterfacedType<T> || podio::detail::isInTuple<T, InterfacedMutableTypes>;
+
+  struct Concept {
+    virtual ~Concept() = default;
+    virtual std::unique_ptr<Concept> clone() const = 0;
+    virtual void print(std::ostream&) const = 0;
+
+    virtual podio::ObjectID getObjectID() const = 0;
+    virtual bool isAvailable() const = 0;
+    virtual void unlink() = 0;
+{{ macros.member_getters_concept(Members, use_get_syntax) }}
+    virtual const std::type_info& typeInfo() const = 0;
+    virtual bool equal(const Concept* rhs) const = 0;
+  };
+
+  template<typename ValueT>
+  struct Model final : Concept {
+    ~Model() = default;
+    Model(ValueT value) : m_value(value) {}
+
+    std::unique_ptr<Concept> clone() const final {
+      return std::make_unique<Model<ValueT>>(m_value);
+    }
+
+    void print(std::ostream& os) const final {
+      os << m_value;
+    }
+
+    void unlink() final { m_value.unlink(); }
+    bool isAvailable() const final { return m_value.isAvailable(); }
+    podio::ObjectID getObjectID() const { return m_value.getObjectID(); }
+
+    const std::type_info& typeInfo() const final { return typeid(ValueT); }
+
+    bool equal(const Concept* rhs) const final {
+      if (typeInfo() == rhs->typeInfo()) {
+        return m_value == static_cast<const Model<ValueT>*>(rhs)->m_value;
+      }
+      return false;
+    }
+
+{{ macros.member_getters_model(Members, use_get_syntax) }}
+
+    ValueT m_value{};
+  };
+
+ std::unique_ptr<Concept> m_self{nullptr};
+
+public:
+  template<typename ValueT>
+  {{ class.bare_type }}(ValueT value) :
+    m_self(std::make_unique<Model<podio::detail::GetDefaultHandleType<ValueT>>>(value)) {
+    static_assert(isInitializableFrom<ValueT>, "{{ class.bare_type }} can only be initialized with one of the following types (and their Mutable counter parts): {{ Types | join(", ") }}");
+  }
+
+  {{ class.bare_type }}(const {{ class.bare_type }}& other) :
+    m_self(other.m_self->clone()) {}
+  {{ class.bare_type }}& operator=(const {{ class.bare_type }}& other) {
+    {{ class.bare_type }} tmp{other};
+    std::swap(tmp.m_self, this->m_self);
+    return *this;
+  }
+
+  ~{{ class.bare_type }}() = default;
+  {{ class.bare_type }}({{ class.bare_type }}&&) = default;
+  {{ class.bare_type }}& operator=({{ class.bare_type }}&&) = default;
+
+  /// Create an empty handle
+  static {{ class.bare_type }} makeEmpty() {
+    // We simply chose the first type of the interfaced types here to initialize
+    // an empty handle
+    return {{ Types[0] }}::makeEmpty();
+  }
+
+  /// check whether the object is actually available
+  bool isAvailable() const { return m_self->isAvailable(); }
+  /// disconnect from the underlying value
+  void unlink() { m_self->unlink(); }
+
+  podio::ObjectID id() const { return getObjectID(); }
+  podio::ObjectID getObjectID() const { return m_self->getObjectID(); }
+
+  /// Check if the object currently holds a value of the requested type
+  template<typename T>
+  bool isA() const {
+    static_assert(isInterfacedType<T>, "{{ class.bare_type }} can only ever be one of the following types: {{ Types | join (", ") }}");
+    return typeid(T) == m_self->typeInfo();
+  }
+
+  /// Get the contained value as the concrete type it was put in. This will
+  /// throw a std::runtime_error if T is not the type of the currently held
+  /// value. Use holds to check beforehand if necessary  template<typename T>
+  template<typename T>
+  T getValue() const {
+    if (!isA<T>()) {
+      throw std::runtime_error("Cannot get value as object currently holds anotyer type");
+    }
+    // We can safely cast here since we check types before
+    return static_cast<Model<T>*>(m_self.get())->m_value;
+  }
+
+  friend bool operator==(const {{ class.bare_type }}& lhs, const {{ class.bare_type }}& rhs) {
+    return lhs.m_self->equal(rhs.m_self.get());
+  }
+
+  friend bool operator!=(const {{ class.bare_type }}& lhs, const {{ class.bare_type }}& rhs) {
+    return !(lhs == rhs);
+  }
+
+{{ macros.member_getters(Members, use_get_syntax) }}
+
+  friend std::ostream& operator<<(std::ostream& os, const {{ class.bare_type }}& value) {
+    value.m_self->print(os);
+    return os;
+  }
+};
+
+{{ utils.namespace_close(class.namespace) }}
+
+#endif
diff --git a/python/templates/macros/collections.jinja2 b/python/templates/macros/collections.jinja2
index 743efa7ec..3edd804a3 100644
--- a/python/templates/macros/collections.jinja2
+++ b/python/templates/macros/collections.jinja2
@@ -71,9 +71,20 @@ std::vector<{{ member.full_type }}> {{ class.bare_type }}Collection::{{ member.n
         m_rel_{{ relation.name }}->emplace_back({{ relation.full_type }}::makeEmpty());
         continue;
       }
+{% if relation.interface_types %}
+      // We need the concrete collection type to assign it to an InferenceWrapper
+{% set else = joiner("else") %}
+{% for int_type in relation.interface_types %}
+      {{ else() }} if (auto {{ int_type.bare_type }}Coll = dynamic_cast<{{ int_type.full_type }}Collection*>(coll)) {
+        const auto tmp = (*{{ int_type.bare_type }}Coll)[id.index];
+        m_rel_{{ relation.name }}->emplace_back(tmp);
+      }
+{% endfor %}
+{% else %}
       {{ relation.full_type }}Collection* tmp_coll = static_cast<{{ relation.full_type }}Collection*>(coll);
       const auto tmp = (*tmp_coll)[id.index];
       m_rel_{{ relation.name }}->emplace_back(tmp);
+{% endif %}
     } else {
       m_rel_{{ relation.name }}->emplace_back({{ relation.full_type }}::makeEmpty());
     }
@@ -91,8 +102,17 @@ std::vector<{{ member.full_type }}> {{ class.bare_type }}Collection::{{ member.n
         entries[i]->m_{{ relation.name }} = nullptr;
         continue;
       }
+{% if relation.interface_types %}
+{% set else = joiner("else") %}
+{% for int_type in relation.interface_types %}
+      {{ else() }} if (auto {{ int_type.bare_type }}Coll = dynamic_cast<{{ int_type.full_type }}Collection*>(coll)) {
+        entries[i]->m_{{ relation.name }} = new {{ relation.full_type }}((*{{ int_type.bare_type }}Coll)[id.index]);
+      }
+{% endfor %}
+{% else %}
       {{ relation.full_type }}Collection* tmp_coll = static_cast<{{ relation.full_type }}Collection*>(coll);
       entries[i]->m_{{ relation.name }} = new {{ relation.full_type }}((*tmp_coll)[id.index]);
+{% endif %}
     } else {
       entries[i]->m_{{ relation.name }} = nullptr;
     }
diff --git a/python/templates/macros/interface.jinja2 b/python/templates/macros/interface.jinja2
new file mode 100644
index 000000000..44e9ad000
--- /dev/null
+++ b/python/templates/macros/interface.jinja2
@@ -0,0 +1,48 @@
+{% macro member_getters_concept(members, get_syntax) %}
+{%for member in members %}
+    virtual {{ member.getter_return_type() }} {{ member.getter_name(get_syntax) }}() const = 0;
+{% if member.is_array %}
+    virtual {{ member.getter_return_type(True) }} {{ member.getter_name(get_syntax) }}(size_t i) const = 0;
+{%- endif %}
+{% if member.sub_members %}
+{% for sub_member in member.sub_members %}
+    virtual {{ sub_member.getter_return_type() }} {{ sub_member.getter_name(get_sytnax) }}() const = 0;
+{% endfor %}
+{% endif %}
+
+{% endfor %}
+{% endmacro %}
+
+
+{% macro member_getters_model(members, get_syntax) %}
+{%for member in members %}
+    {{ member.getter_return_type() }} {{ member.getter_name(get_syntax) }}() const final { return m_value.{{ member.getter_name(get_syntax) }}(); }
+{% if member.is_array %}
+    {{ member.getter_return_type(True) }} {{ member.getter_name(get_syntax) }}(size_t i) const final { return m_value.{{ member.getter_name(get_syntax) }}(i); }
+{%- endif %}
+{% if member.sub_members %}
+{% for sub_member in member.sub_members %}
+    {{ sub_member.getter_return_type() }} {{ sub_member.getter_name(get_sytnax) }}() const final { return m_value.{{ sub_member.getter_name(get_syntax) }}(); }
+{% endfor %}
+{% endif %}
+
+{% endfor %}
+{% endmacro %}
+
+{% macro member_getters(members, get_syntax) %}
+{%for member in members %}
+  /// Access the {{ member.docstring }}
+  {{ member.getter_return_type() }} {{ member.getter_name(get_syntax) }}() const { return m_self->{{ member.getter_name(get_syntax) }}(); }
+{% if member.is_array %}
+  /// Access item i of the {{ member.docstring }}
+  {{ member.getter_return_type(True) }} {{ member.getter_name(get_syntax) }}(size_t i) const { return m_self->{{ member.getter_name(get_syntax) }}(i); }
+{%- endif %}
+{% if member.sub_members %}
+{% for sub_member in member.sub_members %}
+  /// Access the member of {{ member.docstring }}
+  {{ sub_member.getter_return_type() }} {{ sub_member.getter_name(get_sytnax) }}() const { return m_self->{{ sub_member.getter_name(get_syntax) }}(); }
+{% endfor %}
+{% endif %}
+
+{% endfor %}
+{% endmacro %}
diff --git a/tests/datalayout.yaml b/tests/datalayout.yaml
index de3ae703c..4c5dd515c 100755
--- a/tests/datalayout.yaml
+++ b/tests/datalayout.yaml
@@ -198,3 +198,43 @@ datatypes :
       - ex2::NamespaceStruct s{10, 11} // one that we happen to know works
       - double d{9.876e5} // double val
       - CompWithInit comp // To make sure that the default initializer of the component does what it should
+
+  ExampleWithInterfaceRelation:
+    Description: "Datatype that uses an interface type as one of its relations"
+    Author: "Thomas Madlener"
+    OneToOneRelations:
+      - TypeWithEnergy aSingleEnergyType // single relation
+      - ex42::AnotherTypeWithEnergy energyRelation // another single relation
+    OneToManyRelations:
+      - TypeWithEnergy manyEnergies // multiple relations
+      - ex42::AnotherTypeWithEnergy moreEnergies // multiple namespace relations
+
+  nsp::EnergyInNamespace:
+    Description: "A type with energy in a namespace"
+    Author: "Thomas Madlener"
+    Members:
+      - double energy // energy
+    ExtraCode:
+      declaration:
+        "int PDG() const { return 42; }"
+
+interfaces:
+  TypeWithEnergy:
+    Description: "Generic interface for all types with an energy member"
+    Author: "Thomas Madlener"
+    Types:
+      - ExampleHit
+      - ExampleMC
+      - ExampleCluster
+    Members:
+      - double energy // the energy
+
+  ex42::AnotherTypeWithEnergy:
+    Description: "Another interface type for making sure they also work in namespaces"
+    Author: "Thomas Madlener"
+    Types:
+      - ExampleMC
+      - nsp::EnergyInNamespace
+    Members:
+      - double energy // the energy
+      - int PDG // a pdg
diff --git a/tests/unittests/CMakeLists.txt b/tests/unittests/CMakeLists.txt
index c49157b3f..9ac2efa54 100644
--- a/tests/unittests/CMakeLists.txt
+++ b/tests/unittests/CMakeLists.txt
@@ -40,7 +40,7 @@ if(NOT Catch2_FOUND)
 endif()
 
 find_package(Threads REQUIRED)
-add_executable(unittest_podio unittest.cpp frame.cpp buffer_factory.cpp)
+add_executable(unittest_podio unittest.cpp frame.cpp buffer_factory.cpp interface_types.cpp)
 target_link_libraries(unittest_podio PUBLIC TestDataModel PRIVATE Catch2::Catch2WithMain Threads::Threads podio::podioRootIO)
 if (ENABLE_SIO)
   target_link_libraries(unittest_podio PRIVATE podio::podioSioIO)
diff --git a/tests/unittests/interface_types.cpp b/tests/unittests/interface_types.cpp
new file mode 100644
index 000000000..98dd50210
--- /dev/null
+++ b/tests/unittests/interface_types.cpp
@@ -0,0 +1,93 @@
+#include "catch2/catch_test_macros.hpp"
+
+#include "podio/ObjectID.h"
+
+#include "datamodel/AnotherTypeWithEnergy.h"
+#include "datamodel/EnergyInNamespaceCollection.h"
+#include "datamodel/ExampleClusterCollection.h"
+#include "datamodel/ExampleHitCollection.h"
+#include "datamodel/TypeWithEnergy.h"
+#include <stdexcept>
+
+TEST_CASE("InterfaceTypes basic functionality", "[interface-types][basics]") {
+  using WrapperT = TypeWithEnergy;
+
+  auto emptyWrapper = WrapperT::makeEmpty();
+  REQUIRE_FALSE(emptyWrapper.isAvailable());
+  REQUIRE(emptyWrapper.isA<ExampleHit>());
+
+  ExampleHit hit{};
+  WrapperT wrapper1 = hit;
+  WrapperT wrapper2 = hit;
+
+  // The operator== compares the underlying pointers
+  REQUIRE(wrapper1 == wrapper2);
+  // The comparison operator is symmetric
+  REQUIRE(hit == wrapper1);
+  // Reassgning to a different entity should make comparisons fail
+  wrapper2 = ExampleHit{};
+  REQUIRE(wrapper1 != wrapper2);
+
+  // Comparisons also work with Mutable types
+  MutableExampleHit mutHit{};
+  wrapper2 = mutHit;
+  REQUIRE(mutHit != wrapper1);
+  REQUIRE(wrapper2 == mutHit);
+
+  // Make sure that the object id functionality work as expected. The wrapped
+  // object is in no collection, so it should be the default id.
+  REQUIRE(wrapper1.id() == podio::ObjectID{});
+
+  // Create an element in a collection to get one with a non-default object id
+  ExampleHitCollection hitColl{};
+  hitColl.setID(42);
+  wrapper1 = hitColl.create();
+  REQUIRE(wrapper1.id() == podio::ObjectID{0, 42});
+}
+
+TEST_CASE("InterfaceType from immutable", "[interface-types][basics]") {
+  using WrapperT = TypeWithEnergy;
+
+  ExampleHit hit{};
+  WrapperT wrapper{hit};
+  REQUIRE(wrapper.isA<ExampleHit>());
+  REQUIRE_FALSE(wrapper.isA<ExampleCluster>());
+  REQUIRE(wrapper.getValue<ExampleHit>() == hit);
+  REQUIRE(wrapper == hit);
+
+  ExampleCluster cluster{};
+  wrapper = cluster;
+  REQUIRE(wrapper.isA<ExampleCluster>());
+  REQUIRE(wrapper.getValue<ExampleCluster>() == cluster);
+  REQUIRE_THROWS_AS(wrapper.getValue<ExampleHit>(), std::runtime_error);
+  REQUIRE(wrapper != hit);
+}
+
+TEST_CASE("InterfaceType from mutable", "[interface-types][basics]") {
+  using WrapperT = TypeWithEnergy;
+
+  ExampleHit hit{};
+  WrapperT wrapper{hit};
+  REQUIRE(wrapper.isA<ExampleHit>());
+  REQUIRE_FALSE(wrapper.isA<ExampleCluster>());
+  REQUIRE(wrapper.getValue<ExampleHit>() == hit);
+  REQUIRE(wrapper == hit);
+  // Comparison also work against the immutable classes
+  ExampleHit immutableHit = hit;
+  REQUIRE(wrapper == immutableHit);
+
+  MutableExampleCluster cluster{};
+  wrapper = cluster;
+  REQUIRE(wrapper.isA<ExampleCluster>());
+  REQUIRE(wrapper.getValue<ExampleCluster>() == cluster);
+  REQUIRE_THROWS_AS(wrapper.getValue<ExampleHit>(), std::runtime_error);
+  REQUIRE(wrapper != hit);
+}
+
+TEST_CASE("InterfaceType getters", "[basics][interface-types][code-gen]") {
+  MutableExampleCluster cluster{};
+  cluster.energy(3.14f);
+
+  TypeWithEnergy interfaceType = cluster;
+  REQUIRE(interfaceType.energy() == 3.14f);
+}