Commit d14b9e0

template <typename T, typename... Args>

decltype(auto) make(const Output& spec, Args... args)

{

// plain buffer as polymorphic spectator std::vector, which does not run constructors / destructors

using ValueType = typename T::value_type;

auto& timingInfo = mRegistry->get<TimingInfo>();

return context.add<MessageContext::VectorObject<ValueType, MessageContext::ContainerRefObject<std::vector<ValueType, o2::pmr::NoConstructAllocator<ValueType>>>>>(

std::move(headerMessage), channel, 0, std::forward<Args>(args)...)

.get();

// this catches all std::vector objects with messageable value type before checking if is also

// has a root dictionary, so non-serialized transmission is preferred

using ValueType = typename T::value_type;

constexpr bool isBoostSerializable = framework::is_boost_serializable<T>::value;

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

return *reinterpret_cast<T*>(newChunk(spec, sizeof(T)).data());

return make_boost<typename T::wrapped_type>(std::move(spec));

return make_boost<T>(std::move(spec));

} else {

static_assert(always_static_assert_v<T>, ERROR_STRING);

create(spec, &writer, schema);

return writer;

}

return make_boost<FirstArg>(std::move(spec));

} else {

static_assert(always_static_assert_v<T>, ERROR_STRING);

/// Adopt a raw buffer in the framework and serialize / send

/// it to the consumers of @a spec once done.

template <typename T>

adopt(const Output& spec, T* ptr)

{

adopt_boost(std::move(spec), std::move(ptr()));

memcpy(payloadMessage->GetData(), &object, sizeof(T));

serializationType = o2::header::gSerializationMethodNone;

(gsl::details::is_span<T>::value && has_messageable_value_type<T>::value)) {

using ElementType = typename std::remove_pointer<typename T::value_type>::type;

if constexpr (is_messageable<ElementType>::value) {

"\n - pointers to those"

"\n - types with ROOT dictionary and implementing ROOT ClassDef interface");

}

// Serialize a snapshot of an object with root dictionary

payloadMessage = proxy.createMessage();

// Explicitely ROOT serialize a snapshot of object.

// An object wrapped into type `ROOTSerialized` is explicitely marked to be ROOT serialized

// and is expected to have a ROOT dictionary. Availability can not be checked at compile time

});

return std::move(result);

// 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

}

});

return std::move(result);

using wrapped = typename T::wrapped_type;

using DataHeader = o2::header::DataHeader;

std::unique_ptr<wrapped> result(static_cast<wrapped*>(DataRefUtils::decodeCCDB(ref, typeid(wrapped))));

constexpr auto index = framework::has_type_at_v<std::decay_t<T>>(associated_pack_t{});

if constexpr (relatedByIndex<std::decay_t<G>, std::decay_t<T>>()) {

auto name = getLabelFromType<std::decay_t<T>>();

if (table.size() == 0) {

return;

}

} else {

pos = position;

}

if (originalTable.size() == 0) {

return originalTable;

}

return std::make_unique<TableConsumer>(data, DataRefUtils::getPayloadSize(ref));

// implementation (e)

// substitution for boost-serialized entities

// We have to deserialize the ostringstream.

// FIXME: check that the string is null terminated.

// @return deserialized copy of payload

auto str = std::string(ref.payload, DataRefUtils::getPayloadSize(ref));

assert(DataRefUtils::getPayloadSize(ref) == sizeof(T));

return o2::utils::BoostDeserialize<typename T::wrapped_type>(str);

} else {

return o2::utils::BoostDeserialize<T>(str);

// implementation (g)

} else if constexpr (is_container<T>::value) {

// currently implemented only for vectors

auto header = DataRefUtils::getHeader<header::DataHeader*>(ref);

auto payloadSize = DataRefUtils::getPayloadSize(ref);

auto method = header->payloadSerializationMethod;

/// container, C++11 and beyond will implicitly apply return value optimization.

/// @return std container object

using NonConstT = typename std::remove_const<T>::type;

// we expect the unique_ptr to hold an object, exception should have been thrown

// otherwise

auto object = DataRefUtils::as<NonConstT>(ref);

// return type with non-owning Deleter instance

std::unique_ptr<ValueT const, Deleter<ValueT const>> result(ptr, Deleter<ValueT const>(false));

return result;

// TODO: construct a vector spectator

// this is a quick solution now which makes a copy of the plain vector data

auto* start = reinterpret_cast<typename ValueT::value_type const*>(ref.payload);

std::list<int> c;

int d;

BOOST_REQUIRE_EQUAL(test1, true);

BOOST_REQUIRE_EQUAL(test2, true);

BOOST_REQUIRE_EQUAL(test3, false);

BOOST_REQUIRE_EQUAL(test6, false);

ROOTSerialized<decltype(d)> e(d);

BOOST_REQUIRE_EQUAL(test7, true);

}

struct is_specialization<Ref<Args...>, Ref> : std::true_type {

};

template <typename A, typename B>

struct is_overriding : public std::bool_constant<std::is_same_v<A, B> == false && std::is_member_function_pointer_v<A> && std::is_member_function_pointer_v<B>> {

};

mPublishingMode = def;

} else if constexpr (std::is_same<U, SpecialPublishHook*>::value) {

mPublishHook = def;

cargs.emplace_back(key_type(def.key), def.name);

using type = BranchConfigurationElement<typename U::type, BASE>;

return std::move(createBranchConfiguration<0, type>(std::move(cargs), std::forward<Args>(args)...));

// vectors of messageable types

template <typename T>

struct StructureElementTypeTrait<T, std::enable_if_t<has_messageable_value_type<T>::value &&

using value_type = T;

using store_type = value_type*;

using specialization_id = MessageableVectorSpecialization;

// types marked as ROOT serialized

template <typename T>

using value_type = typename T::wrapped_type;

using store_type = value_type*;

using specialization_id = ROOTTypeSpecialization;