Mergers: add postDeserialization() callback and prioritize MergeInterface (AliceO2Group#6811)

knopers8 · web-flow · commit d2c0d90475f4 · 2021-08-09T11:03:23.000+02:00
This lets the children of MergeInterface to perform any cleanups after
ROOT deserializes the object. The main use-case is setting the valid ownership,
which cannot be propely set while serializing it for any reason.
We also prioritize MergeInterface over TObject when a class inherits both.
diff --git a/Utilities/Mergers/include/Mergers/MergeInterface.h b/Utilities/Mergers/include/Mergers/MergeInterface.h
@@ -36,7 +36,10 @@ class MergeInterface
   /// \brief Custom merge method.
   virtual void merge(MergeInterface* const other) = 0; // const argument
 
-  ClassDef(MergeInterface, 0);
+  /// \brief Lets the child perform any routines after the object was deserialized (e.g. setting the correct ownership)
+  virtual void postDeserialization(){};
+
+  ClassDef(MergeInterface, 1);
 };
 
 } // namespace o2::mergers
diff --git a/Utilities/Mergers/src/IntegratingMerger.cxx b/Utilities/Mergers/src/IntegratingMerger.cxx
@@ -49,19 +49,19 @@ void IntegratingMerger::run(framework::ProcessingContext& ctx)
 
   for (const DataRef& ref : InputRecordWalker(ctx.inputs())) {
     if (ref.header != timerHeader) {
+      auto other = object_store_helpers::extractObjectFrom(ref);
       if (std::holds_alternative<std::monostate>(mMergedObject)) {
-        mMergedObject = object_store_helpers::extractObjectFrom(ref);
-
+        mMergedObject = std::move(object_store_helpers::extractObjectFrom(ref));
       } else if (std::holds_alternative<TObjectPtr>(mMergedObject)) {
         // We expect that if the first object was TObject, then all should.
-        auto other = TObjectPtr(framework::DataRefUtils::as<TObject>(ref).release(), algorithm::deleteTCollections);
-        auto target = std::get<TObjectPtr>(mMergedObject);
-        algorithm::merge(target.get(), other.get());
+        auto targetAsTObject = std::get<TObjectPtr>(mMergedObject);
+        auto otherAsTObject = std::get<TObjectPtr>(other);
+        algorithm::merge(targetAsTObject.get(), otherAsTObject.get());
 
       } else if (std::holds_alternative<MergeInterfacePtr>(mMergedObject)) {
         // We expect that if the first object inherited MergeInterface, then all should.
-        auto other = framework::DataRefUtils::as<MergeInterface>(ref);
-        std::get<MergeInterfacePtr>(mMergedObject)->merge(other.get());
+        auto otherAsMergeInterface = std::get<MergeInterfacePtr>(other);
+        std::get<MergeInterfacePtr>(mMergedObject)->merge(otherAsMergeInterface.get());
       } else {
         throw std::runtime_error("mMergedObject' variant has no value.");
       }
diff --git a/Utilities/Mergers/src/ObjectStore.cxx b/Utilities/Mergers/src/ObjectStore.cxx
@@ -65,10 +65,15 @@ ObjectStore extractObjectFrom(const framework::DataRef& ref)
       errorPrefix + "Failed to read object with name '" + storedClass->GetName() + "' from message using ROOT serialization.");
   }
 
-  if (inheritsFromTObject) {
-    return TObjectPtr(static_cast<TObject*>(object), algorithm::deleteTCollections);
+  if (inheritsFromMergeInterface) {
+    MergeInterface* objectAsMergeInterface = inheritsFromTObject ? dynamic_cast<MergeInterface*>(static_cast<TObject*>(object)) : static_cast<MergeInterface*>(object);
+    if (objectAsMergeInterface == nullptr) {
+      throw std::runtime_error(errorPrefix + "Could not cast '" + storedClass->GetName() + "' to MergeInterface");
+    }
+    objectAsMergeInterface->postDeserialization();
+    return MergeInterfacePtr(objectAsMergeInterface);
   } else {
-    return MergeInterfacePtr(static_cast<MergeInterface*>(object));
+    return TObjectPtr(static_cast<TObject*>(object), algorithm::deleteTCollections);
   }
 }
 
diff --git a/Utilities/Mergers/test/test_ObjectStore.cxx b/Utilities/Mergers/test/test_ObjectStore.cxx
@@ -51,9 +51,9 @@ BOOST_AUTO_TEST_CASE(TestObjectExtraction)
     DataRef ref = makeDataRef(obj);
 
     auto objStore = object_store_helpers::extractObjectFrom(ref);
-    BOOST_REQUIRE(std::holds_alternative<TObjectPtr>(objStore));
+    BOOST_REQUIRE(std::holds_alternative<MergeInterfacePtr>(objStore));
 
-    auto objExtractedCustom = dynamic_cast<CustomMergeableTObject*>(std::get<TObjectPtr>(objStore).get());
+    auto objExtractedCustom = dynamic_cast<CustomMergeableTObject*>(std::get<MergeInterfacePtr>(objStore).get());
     BOOST_REQUIRE(objExtractedCustom != nullptr);
     BOOST_CHECK_EQUAL(objExtractedCustom->getSecret(), 123);
 

Original file line number	Diff line number	Diff line change
`@@ -65,10 +65,15 @@ ObjectStore extractObjectFrom(const framework::DataRef& ref)`
`65`	`65`	`errorPrefix + "Failed to read object with name '" + storedClass->GetName() + "' from message using ROOT serialization.");`
`66`	`66`	`}`
`67`	`67`
`68`		`- if (inheritsFromTObject) {`
`69`		`- return TObjectPtr(static_cast<TObject*>(object), algorithm::deleteTCollections);`
	`68`	`+ if (inheritsFromMergeInterface) {`
	`69`	`+ MergeInterface* objectAsMergeInterface = inheritsFromTObject ? dynamic_cast<MergeInterface>(static_cast<TObject>(object)) : static_cast<MergeInterface*>(object);`
	`70`	`+ if (objectAsMergeInterface == nullptr) {`
	`71`	`+ throw std::runtime_error(errorPrefix + "Could not cast '" + storedClass->GetName() + "' to MergeInterface");`
	`72`	`+ }`
	`73`	`+ objectAsMergeInterface->postDeserialization();`
	`74`	`+ return MergeInterfacePtr(objectAsMergeInterface);`
`70`	`75`	`} else {`
`71`		`- return MergeInterfacePtr(static_cast<MergeInterface*>(object));`
	`76`	`+ return TObjectPtr(static_cast<TObject*>(object), algorithm::deleteTCollections);`
`72`	`77`	`}`
`73`	`78`	`}`
`74`	`79`