Allow types from different data models in interfaces (#714)

* add detail function for object rank that can be used for comparison

add detecting if `uintptr_t` is defined

* add extension data model with interface

add test for interface with types from data model and its extension

* hide rank value in a proxy

* rename 'Rank' to 'OrderKey'

* add comments, mention in docs

* compare with `std::less`, remove obsolete typedefs, sprinkle `noexcept`

* allow cross-model interfaces in relations

* test relations IO with cross-edm interface

* test links IO with cross-edm interfaces

* fix missing link to extension datamodel in cmake testing function

Author: m-fila

.gitignore

@@ -5,6 +5,7 @@ install
 tests/src
 tests/datamodel
 tests/extension_model
+tests/interface_extension_model
 tests/datamodeljulia
 tests/unittests/Project.toml
 tests/unittests/Manifest.toml

cmake/podioTest.cmake

@@ -27,6 +27,6 @@ function(CREATE_PODIO_TEST sourcefile additional_libs)
   add_executable( ${name} ${sourcefile} )
   add_test(NAME ${name} COMMAND ${name})
 
-  target_link_libraries(${name} PRIVATE TestDataModel ExtensionDataModel ${additional_libs})
+  target_link_libraries(${name} PRIVATE TestDataModel ExtensionDataModel InterfaceExtensionDataModel ${additional_libs})
   PODIO_SET_TEST_ENV(${name})
 endfunction()

doc/datamodel_syntax.md

@@ -268,5 +268,6 @@ The podio `PODIO_GENERATE_DATAMODEL` cmake macro has gained an additional parame
 ### Potential pitfalls
 - The cmake macros do not handle linking against an upstream datamodel automatically. It is the users responsibility to explicitly link against the upstream datamodel.
 - When generating two datamodels side-by-side and into the same output directory and using the `ROOT` backend, the generated `selection.xml` file might be overwritten if both datamodels are generated into the same output directory.
+- The [interfaces](#definition-of-custom-interfaces) defined in a datamodel can list the datatypes defined in an upstream datamodel only if both datamodels have the same [`getSyntax`](#global-options) value.
 
 Limiting this functionality to one upstream datamodel is a conscious choice to limit the potential for abuse of this feature.

include/podio/detail/OrderKey.h

@@ -0,0 +1,28 @@
+#ifndef PODIO_DETAIL_ORDERKEY_H
+#define PODIO_DETAIL_ORDERKEY_H
+#include <functional>
+namespace podio::detail {
+/// Internal class allowing datatype objects to be placed in data structures like maps and sets by providing a way to
+/// compare them. The comparison is based on addresses of their internal data objects.
+///
+/// This class is intended to be used as the return value of internal `podio::detail::getOrderKey` free functions. These
+/// functions are friends of each datatype, allowing them to access the internal data objects and define less-than
+/// comparison operators for both datatypes and interface types.
+///
+/// The friend free function design is used in order to reduce the coupling between interfaces and datatypes. Interfaces
+/// do not need to be friends of datatypes to define the less-than comparison operator, which allows using datatypes
+/// from different datamodels in an interface type.
+class OrderKey {
+public:
+  OrderKey(void* orderKey) noexcept : m_orderKey(orderKey) {
+  }
+  friend bool operator<(const OrderKey& lhs, const OrderKey& rhs) noexcept {
+    return std::less<void*>{}(lhs.m_orderKey, rhs.m_orderKey);
+  }
+
+private:
+  void* m_orderKey;
+};
+} // namespace podio::detail
+
+#endif // PODIO_DETAIL_ORDERKEY_H

python/podio/test_Frame.py

@@ -47,6 +47,13 @@
     "interface_examples",
 }
 
+# The expected collections from the interface extension (only present in the other_events category)
+EXPECTED_INTERFACE_EXTENSION_COLL_NAMES = {
+    "anotherHits",
+    "extension_interface_relation",
+    "extension_interface_links",
+}
+
 # The expected parameter names in each frame
 EXPECTED_PARAM_NAMES = {
     "anInt",
@@ -167,7 +174,9 @@ def test_frame_collections(self):
         self.assertEqual(set(self.event.getAvailableCollections()), EXPECTED_COLL_NAMES)
         self.assertEqual(
             set(self.other_event.getAvailableCollections()),
-            EXPECTED_COLL_NAMES.union(EXPECTED_EXTENSION_COLL_NAMES),
+            EXPECTED_COLL_NAMES.union(EXPECTED_EXTENSION_COLL_NAMES).union(
+                EXPECTED_INTERFACE_EXTENSION_COLL_NAMES
+            ),
         )
 
         # Not going over all collections here, as that should all be covered by the

python/podio/test_Reader.py

@@ -75,9 +75,9 @@ def test_frame_iterator_invalid_category(self):
     def test_available_datamodels(self):
         """Make sure that the datamodel information can be retrieved"""
         datamodels = self.reader.datamodel_definitions
-        self.assertEqual(len(datamodels), 2)
+        self.assertEqual(len(datamodels), 3)
         for model in datamodels:
-            self.assertTrue(model in ("datamodel", "extension_model"))
+            self.assertTrue(model in ("datamodel", "extension_model", "interface_extension_model"))
 
         self.assertEqual(self.reader.current_file_version("datamodel"), build_version)
 

python/podio_gen/cpp_generator.py

@@ -340,9 +340,10 @@ def _preprocess_for_collection(self, datatype):
                         self._build_include_for_class(relation.bare_type, include_from)
                     )
                     for int_type in relation.interface_types:
+                        int_type_include_from = self._needs_include(int_type.full_type)
                         includes_cc.add(
                             self._build_include_for_class(
-                                int_type.bare_type + "Collection", include_from
+                                int_type.bare_type + "Collection", int_type_include_from
                             )
                         )
                 else:

python/templates/Interface.h.jinja2

@@ -12,6 +12,7 @@
 
 #include "podio/ObjectID.h"
 #include "podio/utilities/TypeHelpers.h"
+#include "podio/detail/OrderKey.h"
 
 #include <memory>
 #include <ostream>
@@ -59,7 +60,7 @@ private:
 {{ macros.member_getters_concept(Members, use_get_syntax) }}
     virtual const std::type_info& typeInfo() const = 0;
     virtual bool equal(const Concept* rhs) const = 0;
-    virtual const void* objAddress() const = 0;
+    virtual podio::detail::OrderKey objOrderKey() const = 0;
   };
 
   template<typename ValueT>
@@ -88,8 +89,8 @@ private:
       return false;
     }
 
-    const void* objAddress() const final {
-      return m_value.m_obj.get();
+    podio::detail::OrderKey objOrderKey() const final {
+      return podio::detail::getOrderKey(m_value);
     }
 
 {{ macros.member_getters_model(Members, use_get_syntax) }}
@@ -169,7 +170,7 @@ public:
   }
 
   friend bool operator<(const {{ class.bare_type }}& lhs, const {{ class.bare_type }}& rhs) {
-    return lhs.m_self->objAddress() < rhs.m_self->objAddress();
+    return lhs.m_self->objOrderKey() < rhs.m_self->objOrderKey();
   }
 
 {{ macros.member_getters(Members, use_get_syntax) }}

python/templates/Object.cc.jinja2

@@ -43,3 +43,7 @@
                       VectorMembers, use_get_syntax)}}
 
 {{ utils.namespace_close(class.namespace) }}
+
+podio::detail::OrderKey podio::detail::getOrderKey(const {{ class.namespace }}::{{ class.bare_type }}& obj) {
+  return podio::detail::OrderKey{obj.m_obj.get()};
+}

python/templates/Object.h.jinja2

@@ -12,6 +12,7 @@
 {% endfor %}
 
 #include "podio/utilities/MaybeSharedPtr.h"
+#include "podio/detail/OrderKey.h"
 
 #include <ostream>
 #include <cstdint>
@@ -22,6 +23,11 @@
 
 {{ utils.forward_decls(forward_declarations) }}
 
+namespace podio::detail {
+// Internal function used in less comparison operators of the datatypes and interface types
+OrderKey getOrderKey(const {{ class.namespace }}::{{ class.bare_type }}& obj);
+};
+
 {{ utils.namespace_open(class.namespace) }}
 class Mutable{{ class.bare_type }};
 class {{ class.bare_type }}Collection;
@@ -34,9 +40,7 @@ class {{ class.bare_type }} {
   friend class {{ class.bare_type }}Collection;
   friend class {{ class.full_type }}CollectionData;
   friend class {{ class.bare_type }}CollectionIterator;
-{% for interface in using_interface_types %}
-  friend class {{ interface }};
-{% endfor %}
+  friend podio::detail::OrderKey podio::detail::getOrderKey(const {{ class.bare_type }} & obj);
 
 public:
   using mutable_type = Mutable{{ class.bare_type }};