#include <cstddef>
#include <utility>

Go to the source code of this file.

Classes
struct	o2::framework::pack<... >

struct	o2::framework::pack_element< I, pack< Head, Tail... > >

struct	o2::framework::pack_element< 0, pack< Head, Tail... > >

struct	o2::framework::intersect_pack< S1, S2 >
	Intersect two packs. More...

struct	o2::framework::subtract_pack< S1, S2 >
	Subtract two packs. More...

Namespaces
namespace	o2
	a couple of static helper functions to create timestamp values for CCDB queries or override obsolete objects

namespace	o2::framework
	Defining PrimaryVertex explicitly as messageable.

Concepts
concept	o2::framework::void_pack_element

concept	o2::framework::nonvoid_pack_element

Typedefs
template<std::size_t I, typename T >
using	o2::framework::pack_element_t = typename pack_element< I, T >::type

template<typename T >
using	o2::framework::pack_head_t = typename pack_element< 0, T >::type

template<typename... Ps>
using	o2::framework::concatenated_pack_t = decltype(concatenate_pack(Ps{}...))

template<typename P1 , typename P2 >
using	o2::framework::interleaved_pack_t = decltype(interleave_pack(P1{}, P2{}))

template<template< typename... > typename Condition, typename... Ts>
using	o2::framework::with_condition_pack = pack< std::conditional_t< Condition< Ts >::value, Ts, void >... >
	Marks as void the types that do not satisfy the condition.

template<template< typename... > typename Condition, typename... Types>
using	o2::framework::selected_pack = std::decay_t< decltype(prune_voids_pack(pack<>{}, with_condition_pack< Condition, Types... >{}))>

template<template< typename... > typename Condition, typename CondPack , typename Pack >
using	o2::framework::selected_pack_multicondition = std::decay_t< decltype(select_pack< Condition >(pack<>{}, Pack{}, CondPack{}))>

template<template< typename > typename Condition, typename... Types>
using	o2::framework::filtered_pack = std::decay_t< decltype(filter_pack< Condition >(pack<>{}, pack< Types... >{}))>

template<typename S1 , typename S2 >
using	o2::framework::intersected_pack_t = typename intersect_pack< S1, S2 >::type

template<typename... Ps>
using	o2::framework::full_intersected_pack_t = decltype(intersected_pack(Ps{}...))

template<typename... Ps>
using	o2::framework::concatenated_pack_unique_t = decltype(concatenate_pack_unique(Ps{}...))

template<typename P >
using	o2::framework::unique_pack_t = decltype(unique_pack(P{}, pack<>{}))

template<typename P >
using	o2::framework::pack_to_tuple_t = decltype(pack_to_tuple(P{}))

template<typename T , std::size_t N>
using	o2::framework::repeated_type_pack_t = decltype(sequence_to_pack< T >(std::make_index_sequence< N >()))

Functions
template<typename... Ts>
constexpr std::size_t	o2::framework::pack_size (pack< Ts... > const &)
	template function to determine number of types in a pack

template<typename Head , typename... Tail>
constexpr auto	o2::framework::pack_tail (pack< Head, Tail... >)

template<typename... Args1, typename... Args2>
constexpr auto	o2::framework::concatenate_pack (pack< Args1... >, pack< Args2... >)

template<typename P1 , typename P2 , typename... Ps>
constexpr auto	o2::framework::concatenate_pack (P1 p1, P2 p2, Ps... ps)

template<typename... Args1, typename... Args2>
constexpr auto	o2::framework::interleave_pack (pack< Args1... >, pack< Args2... >)

template<typename... Ts>
consteval auto	o2::framework::count_non_void_pack (pack< Ts... > const &)

template<typename Result >
consteval auto	o2::framework::prune_voids_pack (Result result, pack<>)

template<typename... Rs, nonvoid_pack_element T, typename... Ts>
consteval auto	o2::framework::prune_voids_pack (pack< Rs... > result, pack< T, Ts... >)

template<typename... Rs, void_pack_element V, typename... Ts>
consteval auto	o2::framework::prune_voids_pack (pack< Rs... > result, pack< V, Ts... >)

template<typename... Rs, nonvoid_pack_element T1, nonvoid_pack_element T2, typename... Ts>
consteval auto	o2::framework::prune_voids_pack (pack< Rs... > result, pack< T1, T2, Ts... >)

template<typename... Rs, nonvoid_pack_element T1, nonvoid_pack_element T2, nonvoid_pack_element T3, nonvoid_pack_element T4, typename... Ts>
consteval auto	o2::framework::prune_voids_pack (pack< Rs... > result, pack< T1, T2, T3, T4, Ts... >)

template<typename... Rs, nonvoid_pack_element T1, nonvoid_pack_element T2, nonvoid_pack_element T3, nonvoid_pack_element T4, nonvoid_pack_element T5, nonvoid_pack_element T6, nonvoid_pack_element T7, nonvoid_pack_element T8, typename... Ts>
consteval auto	o2::framework::prune_voids_pack (pack< Rs... > result, pack< T1, T2, T3, T4, T5, T6, T7, T8, Ts... >)

template<template< typename... > typename Condition, typename Result , typename... Cs>
consteval auto	o2::framework::select_pack (Result result, pack<>, pack< Cs... >)

template<template< typename... > typename Condition, typename Result , typename T , typename... Cs, typename... Ts>
consteval auto	o2::framework::select_pack (Result result, pack< T, Ts... >, pack< Cs... > condPack)

template<template< typename > typename Condition, typename Result >
constexpr auto	o2::framework::filter_pack (Result result, pack<>)
	Select only the items of a pack which match Condition.

template<template< typename > typename Condition, typename Result , typename T , typename... Ts>
constexpr auto	o2::framework::filter_pack (Result result, pack< T, Ts... >)

template<typename T >
void	o2::framework::print_pack ()

template<typename T , typename... Us>
bool consteval	o2::framework::has_type (framework::pack< Us... >)

template<template< typename, typename > typename Condition, typename T , typename... Us>
bool consteval	o2::framework::has_type_conditional (framework::pack< Us... >)

template<typename T , typename... Ts>
consteval size_t	o2::framework::has_type_at_v (pack< Ts... >)

template<template< typename, typename > typename Condition, typename T , typename... Ts>
consteval size_t	o2::framework::has_type_at_conditional_v (pack< Ts... >)

template<typename... A1, typename... A2>
constexpr auto	o2::framework::intersected_pack (pack< A1... >, pack< A2... >)

template<typename P1 , typename P2 , typename... Ps>
constexpr auto	o2::framework::intersected_pack (P1 p1, P2 p2, Ps... ps)

template<typename... Args1, typename... Args2>
constexpr auto	o2::framework::concatenate_pack_unique (pack< Args1... >, pack< Args2... >)

template<typename P1 >
constexpr auto	o2::framework::concatenate_pack_unique (P1 p1)

template<typename P1 , typename P2 , typename... Ps>
constexpr auto	o2::framework::concatenate_pack_unique (P1 p1, P2 p2, Ps... ps)

template<typename PT >
constexpr auto	o2::framework::unique_pack (pack<>, PT p2)

template<typename PT , typename T , typename... Ts>
constexpr auto	o2::framework::unique_pack (pack< T, Ts... >, PT p2)

template<typename... Ts>
constexpr std::tuple< Ts... >	o2::framework::pack_to_tuple (pack< Ts... >)

template<typename T , std::size_t... Is>
auto	o2::framework::sequence_to_pack (std::integer_sequence< std::size_t, Is... >)

Variables
template<typename T , typename P >
constexpr bool	o2::framework::has_type_v = has_type<T>(P{})

template<template< typename, typename > typename Condition, typename T , typename P >
constexpr bool	o2::framework::has_type_conditional_v = has_type_conditional<Condition, T>(P{})

Classes

Namespaces

Concepts

Typedefs

Functions

Variables