allow writing of Gaudi::Range and Gaudi::NamedRange in Gaudi::Functional

See merge request !1275

GaudiExamples/src/FunctionalAlgorithms/MakeAndConsume.cpp

@@ -476,4 +476,18 @@ namespace Gaudi::Examples {
 
   DECLARE_COMPONENT( IntVectorsMergingConsumer )
 
+  struct MyData {
+    using ConstVector = std::vector<const MyData*>;
+  };
+  using MyDataRange = Gaudi::Range_<MyData::ConstVector>;
+
+  struct RangeProducer : Gaudi::Functional::Producer<MyDataRange()> {
+
+    RangeProducer( const std::string& name, ISvcLocator* pSvcLocator )
+        : Producer( name, pSvcLocator, KeyValue{ "TrackLocation", "" } ){};
+
+    MyDataRange operator()() const override { return {}; }
+  };
+  DECLARE_COMPONENT( RangeProducer )
+
 } // namespace Gaudi::Examples

GaudiKernel/include/GaudiKernel/DataObjectHandle.h

@@ -67,7 +67,7 @@ namespace details {
     return ok;
   }
 
-  template <typename T, typename U>
+  template <Gaudi::DataHandle::Mode, typename T, typename U>
   struct Payload_helper {
     using type =
         std::conditional_t<std::is_base_of_v<DataObject, T> && std::is_same_v<T, U>, T,
@@ -75,16 +75,17 @@ namespace details {
                                               AnyDataWithViewWrapper<std::remove_const_t<T>, std::remove_const_t<U>>>>;
   };
   template <typename T, typename U>
-  struct Payload_helper<Gaudi::Range_<T>, U> {
+  struct Payload_helper<Gaudi::DataHandle::Reader, Gaudi::Range_<T>, U> {
     using type = Gaudi::Range_<T>;
   };
   template <typename T, typename U>
-  struct Payload_helper<Gaudi::NamedRange_<T>, U> {
+  struct Payload_helper<Gaudi::DataHandle::Reader, Gaudi::NamedRange_<T>, U> {
     using type = Gaudi::NamedRange_<T>;
   };
 
-  template <typename T, typename U = T>
-  using Payload_t = typename Payload_helper<T, U>::type;
+  template <Gaudi::DataHandle::Mode mode, typename T, typename U = T>
+  using Payload_t = typename Payload_helper<mode, T, U>::type;
+
 } // namespace details
 
 //---------------------------------------------------------------------------
@@ -393,23 +394,29 @@ private:
 };
 
 //---------------------------- user-facing interface ----------
+namespace details {
+  template <typename T, typename U = T>
+  using WriteHandle = DataObjectHandle<Payload_t<Gaudi::DataHandle::Writer, T, U>>;
+  template <typename T, typename U = T>
+  using ReadHandle = DataObjectHandle<Payload_t<Gaudi::DataHandle::Reader, T, U>>;
+} // namespace details
 
 template <typename T>
-class DataObjectReadHandle : public DataObjectHandle<::details::Payload_t<T>> {
+class DataObjectReadHandle : public ::details::ReadHandle<T> {
   template <typename... Args, std::size_t... Is>
   DataObjectReadHandle( std::tuple<Args...>&& args, std::index_sequence<Is...> )
       : DataObjectReadHandle( std::get<Is>( std::move( args ) )... ) {}
 
 public:
   DataObjectReadHandle( const DataObjID& k, IDataHandleHolder* owner )
-      : DataObjectHandle<::details::Payload_t<T>>{ k, Gaudi::DataHandle::Reader, owner } {}
+      : ::details::ReadHandle<T>{ k, Gaudi::DataHandle::Reader, owner } {}
 
   /// Autodeclaring constructor with property name, mode, key and documentation.
   /// @note the use std::enable_if is required to avoid ambiguities
   template <typename OWNER, typename K, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
-  DataObjectReadHandle( OWNER* owner, std::string propertyName, const K& key = {}, std::string doc = "" )
-      : DataObjectHandle<::details::Payload_t<T>>( owner, Gaudi::DataHandle::Reader, std::move( propertyName ), key,
-                                                   std::move( doc ) ) {}
+  DataObjectReadHandle( OWNER* owner, std::string propertyName, K key = {}, std::string doc = "" )
+      : ::details::ReadHandle<T>( owner, Gaudi::DataHandle::Reader, std::move( propertyName ), std::move( key ),
+                                  std::move( doc ) ) {}
 
   template <typename... Args>
   DataObjectReadHandle( std::tuple<Args...>&& args )
@@ -417,21 +424,21 @@ public:
 };
 
 template <typename T, typename U = T>
-class DataObjectWriteHandle : public DataObjectHandle<::details::Payload_t<T, U>> {
+class DataObjectWriteHandle : public ::details::WriteHandle<T, U> {
   template <typename... Args, std::size_t... Is>
   DataObjectWriteHandle( std::tuple<Args...>&& args, std::index_sequence<Is...> )
       : DataObjectWriteHandle( std::get<Is>( std::move( args ) )... ) {}
 
 public:
   DataObjectWriteHandle( const DataObjID& k, IDataHandleHolder* owner )
-      : DataObjectHandle<::details::Payload_t<T, U>>{ k, Gaudi::DataHandle::Writer, owner } {}
+      : ::details::WriteHandle<T, U>{ k, Gaudi::DataHandle::Writer, owner } {}
 
   /// Autodeclaring constructor with property name, mode, key and documentation.
   /// @note the use std::enable_if is required to avoid ambiguities
   template <typename OWNER, typename K, typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
-  DataObjectWriteHandle( OWNER* owner, std::string propertyName, const K& key = {}, std::string doc = "" )
-      : DataObjectHandle<::details::Payload_t<T, U>>( owner, Gaudi::DataHandle::Writer, std::move( propertyName ), key,
-                                                      std::move( doc ) ) {}
+  DataObjectWriteHandle( OWNER* owner, std::string propertyName, K key = {}, std::string doc = "" )
+      : ::details::WriteHandle<T, U>( owner, Gaudi::DataHandle::Writer, std::move( propertyName ), std::move( key ),
+                                      std::move( doc ) ) {}
 
   template <typename... Args>
   DataObjectWriteHandle( std::tuple<Args...>&& args )