template <typename T>

static auto as(DataRef const& ref)

{

auto payloadSize = DataRefUtils::getPayloadSize(ref);

// SFINAE makes this available only for the case we are using

// trivially copyable type, this is to distinguish it from the

// alternative below, which works for TObject (which are serialised).

if constexpr (is_messageable<T>::value == true) {

using DataHeader = o2::header::DataHeader;

auto header = o2::header::get<const DataHeader*>(ref.header);

if (header->payloadSerializationMethod != o2::header::gSerializationMethodNone) {

throw runtime_error("Attempt to extract a POD from a wrong message kind");

}

if ((payloadSize % sizeof(T)) != 0) {

throw runtime_error("Cannot extract POD from message as size do not match");

}

// FIXME: provide a const collection

return gsl::span<T>(reinterpret_cast<T*>(const_cast<char*>(ref.payload)), payloadSize / sizeof(T));

} else if constexpr (has_root_dictionary<T>::value == true &&

is_messageable<T>::value == false) {

std::unique_ptr<T> result;

static_assert(is_type_complete_v<struct RootSerializationSupport>, "Framework/RootSerializationSupport.h not included");

call_if_defined<struct RootSerializationSupport>([&](auto* p) {

// Classes using the ROOT ClassDef/ClassImp macros can be detected automatically

// and the serialization method can be deduced. If the class is also

// messageable, gSerializationMethodNone is used by default. This substitution

// does not apply for such types, the serialization method needs to be specified

// explicitely using type wrapper @a ROOTSerialized.

using RSS = std::decay_t<decltype(*p)>;

using DataHeader = o2::header::DataHeader;

auto header = o2::header::get<const DataHeader*>(ref.header);

if (header->payloadSerializationMethod != o2::header::gSerializationMethodROOT) {

throw runtime_error("Attempt to extract a TMessage from non-ROOT serialised message");

}

typename RSS::FairInputTBuffer ftm(const_cast<char*>(ref.payload), payloadSize);

auto* requestedClass = RSS::TClass::GetClass(typeid(T));

ftm.InitMap();

auto* storedClass = ftm.ReadClass();

// should always have the class description if has_root_dictionary is true

assert(requestedClass != nullptr);

ftm.SetBufferOffset(0);

ftm.ResetMap();

auto* object = ftm.ReadObjectAny(storedClass);

if (object == nullptr) {

throw runtime_error_f("Failed to read object with name %s from message using ROOT serialization.",

(storedClass != nullptr ? storedClass->GetName() : "<unknown>"));

}

if constexpr (std::is_base_of<typename RSS::TObject, T>::value) { // compile time switch

// if the type to be extracted inherits from TObject, the class descriptions

// do not need to match exactly, only the dynamic_cast has to work

// FIXME: could probably try to extend this to arbitrary types T being a base

// to the stored type, but this would require to cast the extracted object to

// the actual type. This requires this information to be available as a type

// in the ROOT dictionary, check if this is the case or if TClass::DynamicCast

// can be used for the test. Right now, this case was and is not covered and

// not yet checked in the unit test either.

auto* r = dynamic_cast<T*>(static_cast<typename RSS::TObject*>(object));

if (r) {

result.reset(r);

}

// This check includes the case: storedClass == requestedClass

} else if (storedClass->InheritsFrom(requestedClass)) {

result.reset(static_cast<T*>(object));

}

if (result == nullptr) {

// did not manage to cast the pointer to result

// delete object via the class info if available, not the case for all types,

// e.g. for standard containers of ROOT objects apparently this is not always

// the case

auto* delfunc = storedClass->GetDelete();

if (delfunc) {

(*delfunc)(object);

}

throw runtime_error_f("Attempting to extract a %s but a %s is actually stored which cannot be casted to the requested one.",

(requestedClass != nullptr ? requestedClass->GetName() : "<unknown>"),

(storedClass != nullptr ? storedClass->GetName() : "<unknown>"));

}

// collections in ROOT can be non-owning or owning and the proper cleanup depends on

// this flag. Be it a bug or a feature in ROOT, but the owning flag of the extracted

// object only depends on the state at serialization of the original object. However,

// all objects created during deserialization are new and must be owned by the collection

// to avoid memory leak. So we call SetOwner if it is available for the type.

if constexpr (requires(T t) { t.SetOwner(true); }) {

result->SetOwner(true);

}

});

return std::move(result);

} else if constexpr (is_specialization_v<T, ROOTSerialized> == true) {

// See above. SFINAE allows us to use this to extract a ROOT-serialized object

// with a somewhat uniform API. ROOT serialization method is enforced by using

// type wrapper @a ROOTSerialized

static_assert(is_type_complete_v<struct RootSerializationSupport>, "Framework/RootSerializationSupport.h not included");

using wrapped = typename T::wrapped_type;

using DataHeader = o2::header::DataHeader;

std::unique_ptr<wrapped> result;

call_if_defined<struct RootSerializationSupport>([&](auto* p) {

using RSS = std::decay_t<decltype(*p)>;

auto header = o2::header::get<const DataHeader*>(ref.header);

if (header->payloadSerializationMethod != o2::header::gSerializationMethodROOT) {

throw runtime_error("Attempt to extract a TMessage from non-ROOT serialised message");

}

auto* cl = RSS::TClass::GetClass(typeid(wrapped));

if (has_root_dictionary<wrapped>::value == false && cl == nullptr) {

throw runtime_error("ROOT serialization not supported, dictionary not found for data type");

}

typename RSS::FairInputTBuffer ftm(const_cast<char*>(ref.payload), payloadSize);

ftm.InitMap();

auto* classInfo = ftm.ReadClass();

ftm.SetBufferOffset(0);

ftm.ResetMap();

result.reset(static_cast<wrapped*>(ftm.ReadObjectAny(cl)));

if (result.get() == nullptr) {

throw runtime_error_f("Unable to extract class %s", cl == nullptr ? "<name not available>" : cl->GetName());

}

// workaround for ROOT feature, see above

if constexpr (requires(T t) { t.SetOwner(true); }) {

result->SetOwner(true);

}

});

return std::move(result);

} else if constexpr (is_specialization_v<T, CCDBSerialized> == true) {

using wrapped = typename T::wrapped_type;

using DataHeader = o2::header::DataHeader;

auto* ptr = DataRefUtils::decodeCCDB(ref, typeid(wrapped));

if constexpr (std::is_base_of<o2::conf::ConfigurableParam, wrapped>::value) {

auto& param = const_cast<typename std::remove_const<wrapped&>::type>(wrapped::Instance());

param.syncCCDBandRegistry(ptr);

ptr = &param;

}

std::unique_ptr<wrapped> result(static_cast<wrapped*>(ptr));

return std::move(result);

}

}

// Decode a CCDB object using the CcdbApi.

static void* decodeCCDB(DataRef const& ref, std::type_info const& info);

static std::map<std::string, std::string> extractCCDBHeaders(DataRef const& ref);

static o2::header::DataHeader::PayloadSizeType getPayloadSize(const DataRef& ref)

{

using DataHeader = o2::header::DataHeader;

auto* header = o2::header::get<const DataHeader*>(ref.header);

if (!header) {

return 0;

}

// in case of an O2 message with multiple payloads, the size of the message stored

// in DataRef is returned,

// as a prototype solution we are using splitPayloadIndex == splitPayloadParts to

// indicate that there are splitPayloadParts payloads following the header

if (header->splitPayloadParts > 1 && header->splitPayloadIndex == header->splitPayloadParts) {

return ref.payloadSize;

}

return header->payloadSize < ref.payloadSize || ref.payloadSize == 0 ? header->payloadSize : ref.payloadSize;

}

template <typename T>

static auto getHeader(const DataRef& ref)

{

using HeaderT = typename std::remove_pointer<T>::type;

static_assert(std::is_pointer<T>::value && std::is_base_of<o2::header::BaseHeader, HeaderT>::value,

"pointer to BaseHeader-derived type required");

return o2::header::get<T>(ref.header);

}

static bool isValid(DataRef const& ref)

{

return ref.header != nullptr;

}

/// check if the DataRef object matches a partcular binding

/// Can be used to check if DataRef from the InputRecord iterator comes from

/// a particular input.

static bool match(DataRef const& ref, const char* binding)

{

return ref.spec != nullptr && ref.spec->binding == binding;

}

template <DataHeaderLike H>

static bool matchHeader(DataRef const& ref, InputSpec const& spec)

{

auto const* dh = o2::header::get<H*>(ref.header);

if (dh == nullptr) {

return false;

}

return DataSpecUtils::match(spec, dh->dataOrigin, dh->dataDescription, dh->subSpecification);

}

/// check if the O2 message referred by DataRef matches a particular

/// input spec. The DataHeader is retrieved from the header message and matched

/// against @ref spec parameter.

template <DataHeaderLike... H>

static bool match(DataRef const& ref, InputSpec const& spec)

{

return (DataRefUtils::matchHeader<H>(ref, spec) || ... || matchHeader<o2::header::DataHeader>(ref, spec));

}