Defining PrimaryVertex explicitly as messageable. More...

Namespaces
namespace	analysis_task_parsers

namespace	binning_helpers

namespace	data_inspector

namespace	data_matcher

namespace	detail

namespace	ecs

namespace	expressions

namespace	gui
	State for the main GUI window.

namespace	internal

namespace	pid

namespace	raw_parser
	workspace for raw parser internal utilities

namespace	readers

namespace	rtr

namespace	staticFor_details

namespace	test

namespace	workflow

namespace	writers

Classes
struct	AlgorithmPlugin
	Helper class for an algorithm which is loaded as a plugin. More...

struct	AlgorithmSpec

struct	always_static_assert

struct	AnalysisContext

struct	AnalysisSupportHelpers

struct	AnalysisTask

struct	any_type

struct	AODToHepMCPostRun

struct	Array2D

class	ArrowContext

struct	ArrowSupport
	A few ServiceSpecs data sending backends. More...

struct	ArrowTableSlicingCache

struct	ArrowTableSlicingCacheDef

struct	AsyncQueue

struct	AsyncQueueHelpers

struct	AsyncTask
	An actuatual task to be executed. More...

struct	AsyncTaskId

struct	AsyncTaskSpec

struct	AxisSpec

struct	BacktraceHelpers

struct	BinningPolicyBase

class	BoostOptionsRetriever

struct	BranchFieldMapping

class	BranchToColumn

struct	BuilderHolder

struct	BuilderMaker

struct	BuilderMaker< bool >

struct	BuilderMaker< std::array< T, N > >

struct	BuilderMaker< std::pair< ITERATOR, ITERATOR > >

struct	BuilderMaker< std::vector< T > >

struct	BuilderMaker< T(&)[N]>

struct	BuilderMaker< T[N]>

struct	BuilderTraits

struct	BuilderTraits< std::pair< ITERATOR, ITERATOR > >

struct	BuilderTraits< std::vector< T > >

struct	BuilderTraits< T[N]>

struct	BuilderUtils

struct	Builds

struct	BulkExtractor

struct	BulkWriteRequestContext

struct	CachedInsertion

class	CallbackRegistry

class	CallbackService

struct	CallbacksPolicy

struct	can_assign

struct	can_assign< From, To, std::conditional_t< false, class_member_checker< decltype(&From::operator())>, void > >

struct	Capability

struct	CapabilityPlugin

struct	CCDBFetcherHelper

struct	CCDBHelpers

struct	CCDBMetadata

struct	CCDBMetadataExtractor

class	CCDBSerialized

struct	CCDBSupport

struct	ChannelConfigurationPolicy

struct	ChannelConfigurationPolicyHelpers
	A set of helpers for common ChannelConfigurationPolicy behaviors. More...

struct	ChannelIndex

struct	ChannelProperties

struct	ChannelRewriter

struct	ChannelSpecHelpers

struct	ChunkedArrayIterator

struct	class_member_checker

struct	ClientWebSocketHandler

struct	ColumnBinningPolicy

struct	ColumnReaderTrait

class	ColumnToBranch

struct	CommandInfo

struct	CommonDataProcessors
	Helpers to create a few general data processors. More...

struct	CommonDriverServices

struct	CommonMessageBackends
	A few ServiceSpecs data sending backends. More...

struct	CommonMessageBackendsHelpers

struct	CommonServices

struct	CompletionPolicy

struct	CompletionPolicyHelpers
	Helper class which holds commonly used policies. More...

struct	ComputingOffer

class	ComputingQuotaEvaluator

struct	ComputingQuotaInfo

struct	ComputingQuotaOffer

struct	ComputingQuotaOfferRef

struct	ComputingQuotaStats
	Statistics on the offers consumed, expired. More...

struct	ComputingResource
	A computing resource which can be offered to run a device. More...

struct	ComputingResourceHelpers

struct	ConcreteDataMatcher

struct	ConcreteDataTypeMatcher

struct	Condition

struct	ConditionGroup

class	ConfigContext

struct	ConfigDiscovery

struct	ConfigDiscoveryPlugin

struct	ConfigParamDiscovery

class	ConfigParamRegistry

struct	ConfigParamsHelper

class	ConfigParamSpec

class	ConfigParamStore

struct	Configurable

struct	ConfigurableBase

struct	ConfigurableGroup

struct	ConfigurableHelpers

struct	ConfigurablePolicyConst

struct	ConfigurablePolicyMutable

class	ConfigurationOptionsRetriever
	ParamRetriever which uses AliceO2Group/Configuration to get the options. More...

struct	ConnectionContext

struct	ContextElementTraits

struct	ContextElementTraits< ConfigParamRegistry const >

struct	ContextElementTraits< ConfigParamRegistry, S >

struct	ContextElementTraits< DataAllocator >

struct	ContextElementTraits< InitContext >

struct	ContextElementTraits< Input< L, T > >

struct	ContextElementTraits< Input< L, T > const >

struct	ContextElementTraits< InputRecord >

struct	ContextElementTraits< ProcessingContext >

struct	ContextHelpers

class	ControlService

struct	ControlServiceHelpers

struct	ControlWebSocketHandler
	An handler for a websocket message stream. More...

class	CustomMergerTestGenerator

class	DanglingContext

class	DataAllocator

class	DataChunk

struct	DataDescriptorQuery

struct	DataDescriptorQueryBuilder
	Various utilities to manipulate InputSpecs. More...

class	DataInputDescriptor

class	DataInputDirector

class	DataInspectorProxyService

struct	DataMatcherId

struct	DataOutputDescriptor

struct	DataOutputDirector

class	DataProcessingDevice

struct	DataProcessingHeader

struct	DataProcessingHelpers
	Generic helpers for DataProcessing releated functions. More...

struct	DataProcessingStates

struct	DataProcessingStats
	Helper struct to hold statistics about the data processing happening. More...

struct	DataProcessingStatsHelpers

struct	DataProcessor

struct	DataProcessorContext

struct	DataProcessorInfo

struct	DataProcessorLabel
	A label that can be associated to a DataProcessorSpec. More...

struct	DataProcessorMatchers

struct	DataProcessorMetadata

struct	DataProcessorPoliciesInfo

struct	DataProcessorSpec

struct	DataProcessorSpecHelpers

struct	DataRef

struct	DataRefUtils

class	DataRelayer

struct	DataRelayerHelpers

class	DataSender
	Allow injecting policies on send. More...

struct	DataSpecUtils

struct	DataTakingContext

struct	DDSConfigHelpers

struct	DebugGUI
	Plugin interface for DPL GUIs. More...

struct	DecongestionContext

struct	DecongestionService

struct	DefaultsHelpers

struct	DeviceConfig

struct	DeviceConfigHelper

struct	DeviceConfigurationHelpers

struct	DeviceConnectionEdge

struct	DeviceConnectionId

struct	DeviceContext

struct	DeviceControl

struct	DeviceController

struct	DeviceExecution

struct	DeviceId

struct	DeviceIndex

struct	DeviceInfo

struct	DeviceMatchers

struct	DeviceMessageHandle

struct	DeviceMetricsHelper

struct	DeviceMetricsInfo

struct	DeviceMetricsInfoHelpers

struct	DevicesManager

struct	DeviceSpec

struct	DeviceSpecHelpers

struct	DeviceState
	Running state information of a given device. More...

struct	DeviceStateHelpers

struct	DirectInsertion

struct	DIServicePlugin

struct	DispatchControl
	Control for the message dispatching within message context. Depending on dispatching policy, objects which get ready to be sent during computing can be scheduled to be sent immediately. The trigger callback is used to decide when to sent the scheduled messages via the actual dispatch callback. More...

struct	DispatchPolicy

struct	DomainId

struct	DomainInfoHeader
	a BaseHeader with domain information from the source More...

struct	DPLModelAdapterConfig

class	DPLMonitoringBackend
	Prints metrics to standard output via std::cout. More...

class	DPLRawPageSequencer
	This utility handles transparently the DPL inputs and triggers a customizable action on sequences of consecutive raw pages following similar RDH features, e.g. the same FEE ID. More...

class	DPLRawParser
	The parser handles transparently input in the format of raw pages. More...

class	DriverClient
	A service API to communicate with the driver. More...

struct	DriverClientContext
	Context for the client callbacks. More...

struct	DriverConfig

struct	DriverControl

struct	DriverEventMatcher

struct	DriverServerContext

struct	EdgeAction

struct	EdgeMatchers

class	EmptyFragment

struct	enable_root_serialization

struct	enable_root_serialization< T, std::enable_if_t< has_root_dictionary< T >::value &&is_messageable< T >::value==false > >

class	EndOfStreamContext

struct	Enumeration

class	ErrorContext

struct	Exclusive

struct	ExpirationHandler

struct	ExpirationHandlerHelpers

class	FairInputTBuffer

struct	FairMQChannelConfigParser
	Handler to parse the description of the –channel-config. More...

struct	FairMQChannelConfigSpec

class	FairMQDeviceProxy

class	FairMQOutputStream

class	FairMQResizableBuffer

class	FairOptionsRetriever

class	FairOutputTBuffer

struct	FileAndFolder

struct	FileNameHolder

struct	FlexibleBinningPolicy

struct	FlexibleBinningPolicy< std::tuple< Ls... >, Ts... >

struct	ForwardChannelInfo
	Forward channel information. More...

struct	ForwardChannelState

struct	ForwardingPolicy

struct	ForwardRoute

class	FragmentToBatch

class	FreePortFinder
	Helper class to find a free port range. More...

class	GenericRootTreeReader

struct	get_function

struct	get_function< Ret(Class::*)(Args...) const >

struct	GraphvizHelpers

struct	GroupedCombinationsGenerator

struct	GroupSlicer

struct	GuiCallbackContext

struct	GUIData

struct	GUIMetrics

struct	GuiRenderer

struct	GUIWebSocketHandler
	An handler for a websocket message stream. More...

struct	has_messageable_value_type

struct	has_messageable_value_type< T, std::conditional_t< false, typename T::value_type, void > >

struct	has_root_dictionary

struct	has_root_dictionary< std::unordered_map< o2::dcs::DataPointIdentifier, o2::dcs::DataPointValue >, void >

struct	has_root_dictionary< T, std::conditional_t< false, class_member_checker< decltype(std::declval< T >().Class())>, void > >

class	has_root_dictionary< T, typename std::enable_if< is_container< T >::value >::type >

struct	has_root_dictionary_mapped_type

struct	has_root_dictionary_mapped_type< T, std::conditional_t< false, typename T::mapped_type, void > >

struct	HistFactory

struct	HistFiller

struct	HistogramConfigSpec

class	HistogramRegistry

struct	HistogramSpec

class	HistosMergerTestGenerator

struct	HolderMaker

struct	HolderMaker< T[N]>

struct	HTTPParser

struct	HTTPParserHelpers

struct	IndexBuilder

class	IndexColumnBuilder

class	InitContext

class	InitErrorContext

struct	Input

struct	InputChannelInfo

struct	InputChannelSpec

struct	InputIndex

class	InputRecord
	The input API of the Data Processing Layer This class holds the inputs which are valid for processing. The user can get an instance for it via the ProcessingContext and can use it to retrieve the inputs, either by name or by index. A few utility methods are provided to automatically cast the (deserialized) inputs to known types. More...

class	InputRecordWalker
	A helper class to iteratate over all parts of all input routes. More...

struct	InputRoute

struct	InputRouteHelpers

class	InputSpan

struct	InputSpec

struct	InsertionTrait

struct	InspectorHelpers
	A helper class for inpsection of device information. More...

struct	intersect_pack
	Intersect two packs. More...

struct	is_braces_constructible

struct	is_container

struct	is_container< T, std::conditional_t< false, class_member_checker< typename T::value_type, typename T::size_type, typename T::allocator_type, typename T::iterator, typename T::const_iterator, decltype(std::declval< T >().size()), decltype(std::declval< T >().begin()), decltype(std::declval< T >().end()), decltype(std::declval< T >().cbegin()), decltype(std::declval< T >().cend())>, void > >

struct	is_forced_non_messageable

struct	is_forced_non_messageable< T, typename std::enable_if< std::is_same< typename T::non_messageable, MarkAsNonMessageable >::value >::type >

struct	is_messageable

struct	is_messageable< gsl::span< T > >

struct	is_messageable< o2::cpv::Cluster >

struct	is_messageable< o2::cpv::CPVCalibParams >

struct	is_messageable< o2::cpv::CPVSimParams >

struct	is_messageable< o2::ctp::CTPDigit >

struct	is_messageable< o2::ctp::TriggerOffsetsParam >

struct	is_messageable< o2::dataformats::PrimaryVertex >

struct	is_messageable< o2::dataformats::PrimaryVertexExt >

struct	is_messageable< o2::dataformats::Vertex< o2::dataformats::TimeStamp< int > > >

struct	is_messageable< o2::dataformats::Vertex< o2::dataformats::TimeStampWithError< float, float > > >

struct	is_messageable< o2::dataformats::VertexBase >

struct	is_messageable< o2::dcs::DataPointCompositeObject >

struct	is_messageable< o2::dcs::DataPointIdentifier >

struct	is_messageable< o2::emcal::EMCALCalibParams >

struct	is_messageable< o2::emcal::SimParam >

struct	is_messageable< o2::globaltracking::MatchTPCITSParams >

struct	is_messageable< o2::hmpid::Cluster >

struct	is_messageable< o2::itsmft::Cluster >

struct	is_messageable< o2::mft::TrackMFT >

struct	is_messageable< o2::phos::PHOSSimParams >

struct	is_messageable< o2::tof::Cluster >

struct	is_messageable< o2::tpc::CorrMapParam >

struct	is_messageable< o2::tpc::ParameterGas >

struct	is_messageable< o2::tpc::ParameterGEM >

struct	is_messageable< o2::trd::TrackTRD >

struct	is_messageable< o2::vertexing::SVertexerParams >

struct	is_overriding

struct	is_span

struct	is_span< T, std::conditional_t< false, typename T::value_type, void > >

struct	is_specialization

struct	is_specialization< Ref< Args... >, Ref >

class	LabeledArray

struct	LabelMap

struct	LifetimeHelpers

struct	LifetimeHolder

struct	LoadableServicePlugin

class	LocalRootFileService
	A simple service to create ROOT files in the local folder. More...

struct	locked_execution

struct	LogicalChannelDomain

struct	LogicalChannelRange

struct	LogicalForwardInfo

struct	LogicalOutputInfo

struct	LogParsingHelpers
	A set of helpers to parse device logs. More...

class	MakeRootTreeWriterSpec
	Generate a processor spec for the RootTreeWriter utility. More...

struct	MarkAsNonMessageable

struct	MatcherInfo

struct	memfun_type< Ret(Class::*)(Args...) const >

struct	MermaidHelpers

class	MessageContext

struct	MessageSet

struct	Metric2DViewIndex

struct	MetricIndices

struct	MetricInfo

struct	MetricLabel

struct	MetricLabelIndex

struct	MetricPrefix

struct	MetricPrefixIndex

struct	MissingService

struct	NoBinningPolicy

struct	NoLocking

struct	O2DatabasePDG

struct	O2DatabasePDGImpl

struct	O2DataModelHelpers

struct	ObjectCache

struct	OptionsHelpers

struct	Output

struct	OutputChannelInfo
	Output channel information. More...

struct	OutputChannelSpec

struct	OutputChannelSpecConfigParser
	A parser which creates an OutputChannelSpec from the –channel-config. More...

struct	OutputChannelState

struct	OutputForTable

struct	OutputLabel

struct	OutputObj

struct	OutputObjectInfo

struct	OutputObjHeader
	O2 header for OutputObj metadata. More...

struct	OutputRef

struct	OutputRoute

struct	OutputSpec

struct	OutputTaskInfo

struct	overloaded
	From https://en.cppreference.com/w/cpp/utility/variant/visit. More...

struct	OverrideServiceSpec

struct	pack

struct	pack_element

struct	pack_element< 0, pack< Head, Tail... > >

struct	pack_element< I, pack< Head, Tail... > >

struct	PaletteHelpers
	An helper class for colors and palettes. More...

class	ParallelContext

class	ParamRetriever

struct	ParsedConfigMatch
	Temporary struct to hold a configuration parameter. More...

struct	ParsedMetricMatch
	Temporary struct to hold a metric after it has been parsed. More...

struct	Partition

struct	PartRef
	Reference to an inflight part. More...

struct	PhysicalChannelDomain

struct	PhysicalChannelRange

struct	PluginManager

struct	PollerContext

class	PreallocatedOutputStream

struct	PresliceBase

struct	PreslicePolicyBase

struct	PreslicePolicyGeneral

struct	PreslicePolicySorted

struct	ProcessConfigurable

class	ProcessingContext

struct	ProcessingPolicies

struct	Produces

struct	ProducesGroup

struct	PropertyTreeHelpers
	Helpers to manipulate property_trees. More...

struct	QuotaEvaluatorStats

struct	RateLimitConfig

class	RateLimiter

class	RawDeviceService

class	RawParser

struct	ReaderHolder

struct	ReaderHolder< T[N]>

struct	ReadOps

struct	RegistryPair

struct	Remap64Bit

struct	Remap64Bit< int64_t >

struct	Remap64Bit< int64_t[N]>

struct	Remap64Bit< uint64_t >

struct	Remap64Bit< uint64_t[N]>

class	ResourceManager

struct	ResourcePolicy

struct	ResourcePolicyHelpers

struct	ResourcesMonitoringHelper

class	RNTupleFileFormat

class	RNTupleFileFragment

class	RNTupleFileSystem

class	RNTupleFileWriteOptions

class	RNTupleFileWriter

struct	RNTupleObjectReadingImplementation

struct	RNTuplePluginContext

struct	root_serializer

struct	root_serializer< T, std::enable_if_t< has_root_dictionary< T >::value\|\|is_specialization< T, ROOTSerialized >::value==true > >

struct	RootArrowFactory

struct	RootArrowFactoryPlugin

struct	RootConfigParamHelpers
	Helpers to Serialise / Deserialise ROOT objects using the ConfigParamSpec mechanism. More...

class	RootFileService

struct	RootNTupleVisitor

struct	RootObjectHandler

struct	RootObjectReadingCapability

struct	RootObjectReadingCapabilityPlugin

struct	RootObjectReadingFactory

struct	RootSerializationSupport

class	ROOTSerialized

class	RootSerializedObject

struct	RootTableBuilderHelpers

struct	RootTransientIndexType

class	RootTreeWriter
	A generic writer interface for ROOT TTree objects. More...

struct	ROOTTypeInfo

struct	RouteConfigurator

struct	RouteIndex

struct	RouteState
	Keeps current state of a given route. More...

struct	RunningDeviceRef

struct	RunningWorkflowInfo
	Information about the running workflow. More...

struct	RuntimeError

struct	RuntimeErrorRef

struct	SelfIndexColumnBuilder

struct	SendingPolicy

struct	Service

class	service_ptr

struct	ServiceConfigureHandle

struct	ServiceDanglingHandle

struct	ServiceDispatchingHandle

struct	ServiceDomainInfoHandle

struct	ServiceEOSHandle

struct	ServiceExitHandle

struct	ServiceForwardingHandle

struct	ServiceHandle

struct	ServiceKindExtractor

struct	ServiceKindExtractor< ConfigurationInterface >

struct	ServiceKindExtractor< InfoLoggerContext >
	This is a global service because read only. More...

struct	ServiceKindExtractor< o2::monitoring::Monitoring >

struct	ServiceKindExtractor< T, std::void_t< decltype(T::service_kind)> >

struct	ServiceMeta

struct	ServiceMetricsInfo

struct	ServicePlugin

struct	ServicePostRenderGUIHandle

struct	ServicePreLoopHandle

struct	ServicePreSendingMessagesHandle

struct	ServiceProcessingHandle

struct	ServiceRegistry

struct	ServiceRegistryHelpers
	Helpers for ServiceRegistry manipulations. More...

class	ServiceRegistryRef

struct	ServiceSpec

struct	ServiceSpecHelpers

struct	ServiceStartHandle

struct	ServiceStartStreamHandle

struct	ServiceStopHandle

struct	ServiceTypeHash

struct	SetDefaultProcesses

class	SimpleOptionsRetriever

class	SimpleRawDeviceService

class	SimpleResourceManager

class	SingleRNTupleFileSystem

class	SingleTreeFileSystem

struct	SliceCache

struct	SliceInfoPtr

struct	SliceInfoUnsortedPtr

struct	SourceInfoHeader
	a BaseHeader with state information from the source More...

struct	Sparse

struct	Spawns

struct	SpyGUIPlugin

class	SpyService

class	SpyServiceHelpers

struct	StreamContext

class	StringContext

struct	StringLiteral

struct	StringMetric

struct	subtract_pack
	Subtract two packs. More...

class	TableBuilder

struct	TableBuilderHelpers

class	TableConsumer

class	TableToTree

struct	TableTransform
	Helper template for table transformations. More...

class	Task

struct	TaskName
	Struct to differentiate task names from possible task string arguments. More...

struct	TaskStreamInfo

struct	TaskStreamRef

class	TBufferFileFS

class	TDirectoryFileOutputStream

class	TextDriverClient
	A text based way of communicating with the driver. More...

class	TFileFileSystem

struct	ThreadPool

struct	TimerSpec

struct	TimesliceId

class	TimesliceIndex

struct	TimesliceSlot

struct	TimingHelpers

struct	TimingInfo

struct	TMessageSerializer

struct	TopoIndexInfo
	Helper struct to keep track of the results of the topological sort. More...

struct	TopologyPolicy

struct	TopologyPolicyHelpers

struct	TracingInfrastructure

struct	TreeReaderValueTraits

struct	TreeReaderValueTraits< TTreeReaderArray< VALUE > >

struct	TreeReaderValueTraits< TTreeReaderValue< T > >

class	TreeToTable

class	TTreeDeferredReadOutputStream

class	TTreeFileFormat

class	TTreeFileFragment

class	TTreeFileSystem

class	TTreeFileWriteOptions

class	TTreeFileWriter

struct	TTreeObjectReadingImplementation

class	TTreeOutputStream

struct	TTreePluginContext

struct	TypeIdHelpers

struct	unique_type_id

struct	UniversalType

struct	VariableContextHelpers
	Helpers to fetch common variables. More...

class	Variant
	Variant for configuration parameter storage. Owns stored data. More...

struct	variant_array_element_type

struct	variant_array_symbol

struct	variant_array_symbol< bool >

struct	variant_array_symbol< double >

struct	variant_array_symbol< float >

struct	variant_array_symbol< int >

struct	variant_array_symbol< std::string >

struct	variant_helper

struct	variant_helper< const char * >

struct	variant_helper< std::string >

struct	variant_helper< std::string_view >

struct	variant_helper< std::vector< std::string > >

struct	variant_trait

struct	variant_type

struct	VariantJSONHelpers

class	VectorMergerTestGenerator

class	VirtualRootFileSystemBase

struct	WaitBackpressurePolicy

struct	WebSocketConstants

struct	WebSocketHandler
	An handler for a websocket message stream. More...

struct	WorkflowCustomizationHelpers

struct	WorkflowHelpers
	A set of internal helper classes to manipulate a Workflow. More...

struct	WorkflowImporter

struct	WorkflowSerializationHelpers

struct	WorkflowSpecNode

struct	WriteRequestContext

struct	WritingCursor

struct	WSDPLClient

struct	WSDPLHandler

class	WSDriverClient

struct	WSError

Concepts
concept	is_producable

concept	is_produces

concept	is_produces_group

concept	is_spawnable

concept	is_spawns

concept	is_builds

concept	is_outputobj

concept	is_service

concept	is_partition

concept	is_enumeration

concept	is_preslice

concept	is_condition

concept	is_condition_group

concept	is_configurable

concept	is_configurable_axis

concept	is_process_configurable

concept	is_configurable_group

concept	VectorOfMessageableTypes

concept	DeviceMetricValue

concept	DeviceMetricNumericValue

concept	DeviceMetricEnumValue

concept	is_combinations_generator

concept	FillValue

concept	ValidTH3

concept	ValidTH2

concept	ValidTH1

concept	ValidTProfile3D

concept	ValidTProfile2D

concept	ValidTProfile

concept	ValidSimpleFill

concept	ValidComplexFill

concept	ValidComplexFillStep

concept	ValidFill

concept	is_histogram_registry

concept	is_slice_cache

concept	BulkInsertable

concept	ShouldNotDeconstruct

concept	void_pack_element

concept	nonvoid_pack_element

concept	specialization_of_template

concept	base_of_template

Typedefs
using	GID = o2::dataformats::GlobalTrackID

using	WorkflowSpec = std::vector< DataProcessorSpec >

using	labelmap_t = std::unordered_map< std::string, uint32_t >

using	ListVector = std::vector< std::vector< int64_t > >

using	StringPair = std::pair< std::string, std::string >

template<typename T >
using	PresliceUnsorted = PresliceBase< T, PreslicePolicyGeneral, false >

template<typename T >
using	PresliceUnsortedOptional = PresliceBase< T, PreslicePolicyGeneral, true >

template<typename T >
using	Preslice = PresliceBase< T, PreslicePolicySorted, false >

template<typename T >
using	PresliceOptional = PresliceBase< T, PreslicePolicySorted, true >

using	ComputingQuotaRequest = std::function< OfferScore(ComputingQuotaOffer const &offer, ComputingQuotaOffer const &accumulated)>

using	ComputingQuotaConsumer = std::function< void(int id, std::array< ComputingQuotaOffer, 16 > &, ComputingQuotaStats &, std::function< void(ComputingQuotaOffer const &, ComputingQuotaStats &stats)>)>

using	options_description = boost::program_options::options_description

template<typename T , ConfigParamKind K = ConfigParamKind::kGeneric>
using	MutableConfigurable = Configurable< T, K, ConfigurablePolicyMutable< T, K > >

using	ConfigurableAxis = Configurable< std::vector< double >, ConfigParamKind::kAxisSpec, ConfigurablePolicyConst< std::vector< double >, ConfigParamKind::kAxisSpec > >

using	OnWorkflowTerminationHook = std::function< void(const char *)>

using	DataProcessorMatcher = std::function< bool(DataProcessorSpec const &spec)>

using	DeviceMatcher = std::function< bool(DeviceSpec const &spec, ConfigContext const &context)>

using	EdgeMatcher = std::function< bool(DataProcessorSpec const &source, DataProcessorSpec const &dest, ConfigContext const &context)>

using	Inputs = std::vector< InputSpec >

using	Outputs = std::vector< OutputSpec >

using	Options = std::vector< ConfigParamSpec >

template<typename T >
using	MetricsStorage = std::array< T, metricStorageSize< T >()>

template<typename T >
using	TimestampsStorage = std::array< size_t, metricStorageSize< T >()>

using	ChannelRetriever = std::function< std::string const &(OutputSpec const &, DataProcessingHeader::StartTime)>

using	InjectorFunction = std::function< bool(TimingInfo &, ServiceRegistryRef const &services, fair::mq::Parts &inputs, ChannelRetriever, size_t newTimesliceId, bool &stop)>

using	ChannelSelector = std::function< std::string(InputSpec const &input, const std::unordered_map< std::string, std::vector< fair::mq::Channel > > &channels)>

template<typename T , typename G >
using	is_index_to_g_t = typename std::conditional< o2::soa::is_binding_compatible_v< G, typename T::binding_t >(), std::true_type, std::false_type >::type

template<typename G , typename A1 , typename A2 , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G>>
using	Pair = GroupedCombinationsGenerator< T1, GroupingPolicy, BP, G, A1, A2 >

template<typename G , typename A , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G>>
using	SameKindPair = GroupedCombinationsGenerator< T1, GroupingPolicy, BP, G, A, A >

template<typename G , typename A1 , typename A2 , typename A3 , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G, G>>
using	Triple = GroupedCombinationsGenerator< T1, GroupingPolicy, BP, G, A1, A2, A3 >

template<typename G , typename A , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G, G>>
using	SameKindTriple = GroupedCombinationsGenerator< T1, GroupingPolicy, BP, G, A, A, A >

using	HistPtr = std::variant< std::shared_ptr< THn >, std::shared_ptr< THnSparse >, std::shared_ptr< TH3 >, std::shared_ptr< TH2 >, std::shared_ptr< TH1 >, std::shared_ptr< TProfile3D >, std::shared_ptr< TProfile2D >, std::shared_ptr< TProfile >, std::shared_ptr< StepTHn > >

template<typename T >
using	Remap64Bit_t = typename Remap64Bit< T >::type

using	ServiceId = std::function< unsigned int()>
	A callback which returns the uniqueId of the service when invoked.

using	ServiceInit = ServiceHandle(*)(ServiceRegistryRef, DeviceState &, fair::mq::ProgOptions &)
	A callback to create a given Service.

using	ServiceStartCallback = void()(ServiceRegistryRef, void )
	A callback invoked whenever we start running, before the user processing callback.

using	ServiceStopCallback = void()(ServiceRegistryRef, void )
	A callback invoked whenever we stop running, after the user processing callback.

using	ServiceExitCallback = void()(ServiceRegistryRef, void )
	A callback invoked whenever we stop running completely, before we exit.

using	ServiceConfigureCallback = void ()(InitContext &, void *)

using	ServiceProcessingCallback = void()(ProcessingContext &, void )
	A callback which is executed before each processing loop.

using	ServiceDanglingCallback = void()(DanglingContext &, void )
	A callback which is executed before each dangling input loop.

using	ServiceEOSCallback = void()(EndOfStreamContext &, void )
	A callback which is executed before the end of stream loop.

using	ServicePreFork = std::function< void(ServiceRegistryRef, DeviceConfig const &)>

using	ServicePostForkChild = std::function< void(ServiceRegistryRef)>

using	ServicePostForkParent = std::function< void(ServiceRegistryRef)>

using	ServicePreSchedule = void(*)(ServiceRegistryRef, DeviceConfig const &)
	Callback executed before each redeployment of the whole configuration.

using	ServicePostSchedule = void(*)(ServiceRegistryRef, DeviceConfig const &)
	Callback executed after each redeployment of the whole configuration.

using	ServiceMetricHandling = void(*)(ServiceRegistryRef, ServiceMetricsInfo const &, size_t timestamp)
	Callback executed in the driver in order to process a metric.

using	ServiceSummaryHandling = void(*)(ServiceMetricsInfo const &metrics)

using	ServicePostDispatching = void()(ProcessingContext &, void )
	Callback executed in the child after dispatching happened.

using	ServicePostForwarding = void()(ProcessingContext &, void )
	Callback executed in the child after late forwarding happened.

using	ServiceDriverInit = void(*)(ServiceRegistryRef, DeviceConfig const &)
	Callback invoked when the driver enters the init phase.

using	ServiceDriverStartup = void(*)(ServiceRegistryRef, DeviceConfig const &)
	Callback invoked when the driver enters the init phase.

using	ServicePreLoop = void()(ServiceRegistryRef, void )

using	ServiceTopologyInject = void(*)(WorkflowSpecNode &, ConfigContext &)
	Callback invoked when we inject internal devices in the topology.

using	ServiceTopologyAdjust = void(*)(WorkflowSpecNode &, ConfigContext const &)
	Callback invoked when we amend the topology.

using	ServiceDomainInfoUpdated = void(*)(ServiceRegistryRef, size_t tileslice, ChannelIndex channel)
	Callback invoked whenever we get updated about the oldest possible timeslice we can process.

using	ServicePreSendingMessages = void(*)(ServiceRegistryRef, fair::mq::Parts &, ChannelIndex channel)
	Callback invoked whenever we are about sending a message.

using	ServicePostRenderGUI = void(*)(ServiceRegistryRef)

using	OverrideServiceSpecs = std::vector< OverrideServiceSpec >

using	ServiceSpecs = std::vector< ServiceSpec >

template<typename... ARGS>
using	IndexedHoldersTuple = decltype(makeHolderTypes< ARGS... >())

template<typename... T>
using	iterator_tuple_t = std::tuple< typename T::iterator... >

template<VariantType V>
using	variant_array_element_type_t = typename variant_array_element_type< V >::type

using	DataHeader = o2::header::DataHeader

using	DataDescription = o2::header::DataDescription

using	DataProcessingHeader = o2::framework::DataProcessingHeader

using	LogicalChannelsMap = std::map< LogicalChannelRange, size_t >

using	LogLevel = o2::framework::LogParsingHelpers::LogLevel

using	UnifiedDataSpecType = std::variant< InputSpec, OutputSpec >

using	Validator = std::function< bool(std::ostream &errors, DataProcessorSpec const &producer, OutputSpec const &output, DataProcessorPoliciesInfo const &producerPolicies, DataProcessorSpec const &consumer, InputSpec const &input, DataProcessorPoliciesInfo const &consumerPolicies)>

using	CheckMatrix = std::map< std::string, std::vector< std::pair< std::string, std::string > > >

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

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

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

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

template<template< typename... > typename Condition, typename... Ts>
using	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	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	selected_pack_multicondition = std::decay_t< decltype(select_pack< Condition >(pack<>{}, Pack{}, CondPack{}))>

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

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

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

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

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

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

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

using	RootTreeReader = GenericRootTreeReader< rtr::DefaultKey >

using	V7 = header::RAWDataHeaderV7

using	V6 = header::RAWDataHeaderV6

using	V5 = header::RAWDataHeaderV5

using	V4 = header::RAWDataHeaderV4

using	SubSpecificationType = header::DataHeader::SubSpecificationType

template<size_t Size>
using	ExpectedType = std::array< float, Size >

Enumerations
enum struct	ReadOpKind { Unknown , Offsets , Values , Booleans , VLA }

enum	BasicOp : unsigned int { LogicalAnd , LogicalOr , Addition , Subtraction , Division , Multiplication , BitwiseAnd , BitwiseOr , BitwiseXor , LessThan , LessThanOrEqual , GreaterThan , GreaterThanOrEqual , Equal , NotEqual , Atan2 , Power , Sqrt , Exp , Log , Log10 , Sin , Cos , Tan , Asin , Acos , Atan , Abs , Round , BitwiseNot , Conditional }

enum struct	InputChannelState { Running , Paused , Completed , Pull }

enum struct	ChannelAccountingType { Unknown , DPL , RAWFMQ }

enum struct	ChannelMethod { Bind , Connect }

enum struct	ChannelType { Pub , Sub , Push , Pull , Pair }
	These map to zeromq types for the channels. More...

enum struct	ChannelProtocol { Network , IPC }
	The kind of backend to use for the channels. More...

enum struct	OfferScore { Enough , More , Unneeded , Unsuitable }

enum	ConfigParamKind : int { kGeneric = 0 , kAxisSpec = 1 , kProcessFlag = 2 }

enum struct	QuitRequest { Me = 0 , All = 1 }
	Kind of request we want to issue to control. More...

enum struct	ProcessingStateId : short { DUMMY_STATE = 0 , DATA_QUERIES = 1 , OUTPUT_MATCHERS = 2 , CONTEXT_VARIABLES_BASE = 1024 , DATA_RELAYER_BASE = 1536 }
	Helper struct to define some known states. More...

enum struct	ProcessingStatsId : short { ERROR_COUNT , EXCEPTION_COUNT , PENDING_INPUTS , INCOMPLETE_INPUTS , TOTAL_INPUTS , LAST_ELAPSED_TIME_MS , TOTAL_WALL_TIME_MS , LAST_PROCESSED_SIZE , TOTAL_PROCESSED_SIZE , TOTAL_SIGUSR1 , CONSUMED_TIMEFRAMES , AVAILABLE_MANAGED_SHM , LAST_SLOW_METRIC_SENT_TIMESTAMP , LAST_VERY_SLOW_METRIC_SENT_TIMESTAMP , LAST_METRIC_FLUSHED_TIMESTAMP , BEGIN_ITERATION_TIMESTAMP , PERFORMED_COMPUTATIONS , LAST_REPORTED_PERFORMED_COMPUTATIONS , TOTAL_BYTES_IN , TOTAL_BYTES_OUT , LAST_MIN_LATENCY , LAST_MAX_LATENCY , TOTAL_RATE_IN_MB_S , TOTAL_RATE_OUT_MB_S , PROCESSING_RATE_HZ , MALFORMED_INPUTS , DROPPED_COMPUTATIONS , DROPPED_INCOMING_MESSAGES , RELAYED_MESSAGES , CPU_USAGE_FRACTION , ARROW_BYTES_CREATED , ARROW_BYTES_DESTROYED , ARROW_MESSAGES_CREATED , ARROW_MESSAGES_DESTROYED , ARROW_BYTES_EXPIRED , RESOURCE_OFFER_EXPIRED , SHM_OFFER_BYTES_CONSUMED , RESOURCES_MISSING , RESOURCES_INSUFFICIENT , RESOURCES_SATISFACTORY , AVAILABLE_MANAGED_SHM_BASE = 512 }

enum struct	CacheEntryStatus : int { EMPTY , PENDING , RUNNING , DONE }

enum struct	DeploymentMode { Local , OnlineECS , OnlineDDS , OnlineAUX , Grid , FST }

enum class	MetricType { Int = 0 , String = 1 , Float = 2 , Uint64 = 3 , Enum = 16 , Unknown }

enum struct	StreamingState { Streaming = 0 , EndOfStreaming = 1 , Idle = 2 }

enum struct	TransitionHandlingState { NoTransition , Requested , Expired }

enum struct	DriverControlState { STEP , PLAY , PAUSE }

enum	HistType : unsigned int { kUndefinedHist = 0 , kTH1D , kTH1F , kTH1I , kTH1C , kTH1S , kTH2D , kTH2F , kTH2I , kTH2C , kTH2S , kTH3D , kTH3F , kTH3I , kTH3C , kTH3S , kTHnD , kTHnF , kTHnI , kTHnC , kTHnS , kTHnL , kTHnSparseD , kTHnSparseF , kTHnSparseI , kTHnSparseC , kTHnSparseS , kTHnSparseL , kTProfile , kTProfile2D , kTProfile3D , kStepTHnF , kStepTHnD }

enum struct	Lifetime { Timeframe = 0 , Condition = 1 , QA = 2 , Sporadic = 2 , Transient = 3 , Timer = 4 , Enumeration = 5 , Signal = 6 , Optional = 7 , OutOfBand = 8 }
	Possible Lifetime of objects being exchanged by the DPL. More...

enum	OutputObjHandlingPolicy : unsigned int { AnalysisObject , QAObject , TransientObject , numPolicies }
	Policy enum to determine OutputObj handling when writing. More...

enum	OutputObjSourceType : unsigned int { OutputObjSource , HistogramRegistrySource , numTypes }

enum struct	DplPluginKind : int { CustomAlgorithm , DebugGUIImpl , CustomService , ConfigDiscovery , Capability , RootObjectReadingCapability , RootObjectReadingImplementation , Unknown }

enum struct	TerminationPolicy { QUIT , WAIT , RESTART }

enum struct	EarlyForwardPolicy { NEVER , NORAW , ALWAYS }
	When to enable the early forwarding optimization: More...

enum struct	DriverMode { STANDALONE , EMBEDDED }

enum struct	ServiceKind { DeviceSerial , DeviceGlobal , DeviceStream , DataProcessorSerial , DataProcessorGlobal , DataProcessorStream , Serial = DataProcessorSerial , Global = DataProcessorGlobal , Stream = DataProcessorStream }
	The kind of service we are asking for. More...

enum class	VariantType : int { Int = 0 , Int64 , Float , Double , String , Bool , ArrayInt , ArrayFloat , ArrayDouble , ArrayBool , ArrayString , Array2DInt , Array2DFloat , Array2DDouble , LabeledArrayInt , LabeledArrayFloat , LabeledArrayDouble , UInt8 , UInt16 , UInt32 , UInt64 , Int8 , Int16 , LabeledArrayString , Empty , Dict , Unknown }

enum struct	RateLimitingState { UNKNOWN = 0 , STARTED = 1 , CHANGED = 2 , BELOW_LIMIT = 3 , NEXT_ITERATION_FROM_BELOW = 4 , ABOVE_LIMIT = 5 , EMPTY = 6 }

enum struct	ChannelConfigParserState { BEGIN , BEGIN_CHANNEL , END_CHANNEL , BEGIN_KEY , BEGIN_VALUE , END_VALUE , END , ERROR }

enum	QueryBuilderState { IN_BEGIN_QUERY , IN_BEGIN_MATCHER , IN_BEGIN_BINDING , IN_END_BINDING , IN_BEGIN_ORIGIN , IN_END_ORIGIN , IN_BEGIN_DESCRIPTION , IN_END_DESCRIPTION , IN_BEGIN_SUBSPEC , IN_END_SUBSPEC , IN_BEGIN_TIMEMODULO , IN_END_TIMEMODULO , IN_END_MATCHER , IN_END_QUERY , IN_STRING , IN_NUMBER , IN_NEGATION , IN_ERROR , IN_BEGIN_ATTRIBUTES , IN_END_ATTRIBUTES , IN_BEGIN_KEY , IN_END_KEY , IN_BEGIN_VALUE , IN_END_VALUE }

enum struct	DataProcessingStatus : uint32_t { ID = 0 , IN_DPL_OVERHEAD , IN_DPL_USER_CALLBACK , IN_DPL_ERROR_CALLBACK }
	Describe the possible states for DataProcessing. More...

enum struct	MonitoringStatus : uint32_t { ID = 1 , SEND = 0 , FLUSH = 1 }
	Describe the possible states for Monitoring. More...

enum struct	DriverStatus : uint32_t { ID = 2 , BYTES_READ = 0 , BYTES_PROCESSED = 1 , BUFFER_OVERFLOWS = 2 }

enum struct	ParsingState { IN_START , IN_PREFIX , IN_BEGIN_INDEX , IN_END_INDEX , IN_TYPE , IN_INT_VALUE , IN_UINT64_VALUE , IN_FLOAT_VALUE , IN_STRING_VALUE , IN_TIMESTAMP , IN_TAGS , IN_EXIT , IN_ERROR }

enum struct	GUIOpcodes : uint8_t { Mousepos = 1 , Mouseclick = 2 , Mousewheel = 3 , Window = 4 , Latency = 5 , Keydown = 6 , Keyup = 7 , Charin = 8 }

enum struct	WebSocketFrameKind { Tiny , Short , Huge }

enum struct	WebSocketOpCode : uint8_t { Continuation = 0 , Text = 1 , Binary = 2 , Close = 8 , Ping = 9 , Pong = 10 }

enum struct	HTTPState { IN_START , IN_START_REPLY , BEGIN_REPLY_VERSION , END_REPLY_VERSION , BEGIN_REPLY_CODE , END_REPLY_CODE , BEGIN_REPLY_MESSAGE , END_REPLY_MESSAGE , BEGIN_METHOD , END_METHOD , BEGIN_TARGET , END_TARGET , BEGIN_VERSION , END_VERSION , BEGIN_HEADERS , BEGIN_HEADER , BEGIN_HEADER_KEY , END_HEADER_KEY , BEGIN_HEADER_VALUE , END_HEADER_VALUE , END_HEADER , END_HEADERS , BEGIN_BODY , IN_DONE , IN_ERROR , IN_SKIP_CHARS , IN_CAPTURE_DELIMITERS , IN_CAPTURE_SEPARATOR , IN_SEPARATOR , IN_CHUNKED }

enum struct	ConnectionKind { Out = 0 , Forward = 1 , In = 2 , Unknown = 3 }

enum struct	WorkflowParsingState : int { Valid , Empty }

Functions
bool	isMasterWorkflowDefinition (ConfigContext const &configcontext)

bool	isDumpWorkflowInvocation (ConfigContext const &configcontext)

bool	isInternalDPL (std::string const &name)

std::string	whoAmI (ConfigContext const &configcontext)

o2::framework::DataProcessorSpec	specCombiner (std::string const &name, std::vector< DataProcessorSpec > const &speccollection, std::vector< DataProcessorSpec > &remaining)

DataProcessorSpec	getFDDDCSConfigProcessorSpec ()

DataProcessorSpec	getFDDDCSDataProcessorSpec ()

DataProcessorSpec	getFT0DCSConfigProcessorSpec ()

DataProcessorSpec	getFT0DCSDataProcessorSpec ()

DataProcessorSpec	getFV0DCSConfigProcessorSpec ()

DataProcessorSpec	getFV0DCSDataProcessorSpec ()

FileNameHolder *	makeFileNameHolder (std::string fileName)

std::unique_ptr< ROOT::Experimental::RFieldBase >	rootFieldFromArrow (std::shared_ptr< arrow::Field > field, std::string name)

DEFINE_DPL_PLUGINS_BEGIN	DEFINE_DPL_PLUGIN_INSTANCE (RNTupleObjectReadingImplementation, RootObjectReadingImplementation)

TBufferFile &	rootBuffer ()

char const *	rootSuffixFromArrow (arrow::Type::type id)

auto	arrowTypeFromROOT (EDataType type, int size)

DEFINE_DPL_PLUGINS_BEGIN	DEFINE_DPL_PLUGIN_INSTANCE (TTreeObjectReadingImplementation, RootObjectReadingImplementation)

bool	isPrefix (std::string_view prefix, std::string_view full)

auto	getOrbitResetTime (o2::pmr::vector< char > const &v) -> Long64_t

bool	isOnlineRun (DataTakingContext const &dtc)

auto	populateCacheWith (std::shared_ptr< CCDBFetcherHelper > const &helper, int64_t timestamp, TimingInfo &timingInfo, DataTakingContext &dtc, DataAllocator &allocator) -> void

template<typename... CONTEXTELEMENT>
AlgorithmSpec::ProcessCallback	adaptStatelessF (std::function< void(CONTEXTELEMENT &...)> callback)

template<typename... CONTEXTELEMENT>
AlgorithmSpec::InitCallback	adaptStatefulF (std::function< AlgorithmSpec::ProcessCallback(CONTEXTELEMENT &...)> callback)

template<typename R , typename... ARGS>
AlgorithmSpec::ProcessCallback	adaptStatelessP (R(*callback)(ARGS...))

template<typename LAMBDA >
AlgorithmSpec::ProcessCallback	adaptStateless (LAMBDA l)

template<typename LAMBDA >
AlgorithmSpec::InitCallback	adaptStateful (LAMBDA l)

template<soa::is_table T>
consteval auto	typeWithRef () -> T
	Helper to define output for a Table.

template<is_spawnable T>
constexpr auto	transformBase ()
	This helper struct allows you to declare index tables to be created in a task.

auto	getTableFromFilter (soa::is_filtered_table auto const &table, soa::SelectionVector &&selection)

auto	getTableFromFilter (soa::is_not_filtered_table auto const &table, soa::SelectionVector &&selection)

void	initializePartitionCaches (std::set< uint32_t > const &hashes, std::shared_ptr< arrow::Schema > const &schema, expressions::Filter const &filter, gandiva::NodePtr &tree, gandiva::FilterPtr &gfilter)

template<typename T , typename... Args>
DataProcessorSpec	adaptAnalysisTask (ConfigContext const &ctx, Args &&... args)

void	updatePairList (std::vector< StringPair > &list, std::string const &binding, std::string const &key)

std::string	cutString (std::string &&str)

std::string	strToUpper (std::string &&str)

ConfigParamSpec	ccdbPathSpec (std::string const &path)

ConfigParamSpec	ccdbRunDependent (int defaultValue=1)

std::vector< ConfigParamSpec >	ccdbParamSpec (std::string const &path, int runDependent, std::vector< CCDBMetadata > metadata={}, int qrate=0)

std::vector< ConfigParamSpec >	ccdbParamSpec (std::string const &path, std::vector< CCDBMetadata > metadata={}, int qrate=0)

ConfigParamSpec	startTimeParamSpec (int64_t t)

std::vector< ConfigParamSpec >	channelParamSpec (std::string const &name)

std::ostream &	operator<< (std::ostream &s, ChannelType const &type)
	Stream operators so that we can use ChannelType with Boost.Test.

std::ostream &	operator<< (std::ostream &s, ChannelMethod const &method)
	Stream operators so that we can use ChannelString with Boost.Test.

std::ostream &	operator<< (std::ostream &oss, CompletionPolicy::CompletionOp const &val)

template<typename T , ConfigParamKind K, typename IP >
std::ostream &	operator<< (std::ostream &os, Configurable< T, K, IP > const &c)

std::ostream &	operator<< (std::ostream &oss, MetricType const &val)

template<typename T >
constexpr size_t	metricStorageSize ()

std::ostream &	operator<< (std::ostream &oss, DispatchPolicy::DispatchOp const &val)

std::string	formatExternalChannelConfiguration (InputChannelSpec const &)
	helper method to format a configuration string for an external channel

std::string	formatExternalChannelConfiguration (OutputChannelSpec const &)
	helper method to format a configuration string for an external channel

void	sendOnChannel (fair::mq::Device &device, o2::header::Stack &&headerStack, fair::mq::MessagePtr &&payloadMessage, OutputSpec const &spec, ChannelRetriever &channelRetriever)

void	sendOnChannel (fair::mq::Device &device, fair::mq::Parts &messages, std::string const &channel, size_t timeSlice)

void	appendForSending (fair::mq::Device &device, o2::header::Stack &&headerStack, size_t timeSliceID, fair::mq::MessagePtr &&payloadMessage, OutputSpec const &spec, fair::mq::Parts &messageCache, ChannelRetriever &channelRetriever)

InjectorFunction	incrementalConverter (OutputSpec const &spec, o2::header::SerializationMethod method, uint64_t startTime, uint64_t step)

InjectorFunction	o2DataModelAdaptor (OutputSpec const &spec, uint64_t startTime, uint64_t step)

InjectorFunction	dplModelAdaptor (std::vector< OutputSpec > const &specs={{header::gDataOriginAny, header::gDataDescriptionAny}}, DPLModelAdapterConfig config=DPLModelAdapterConfig{})

InjectorFunction	dplModelAdaptor (std::vector< OutputSpec > const &specs, bool throwOnUnmatchedInputs)
	legacy function

std::string	defaultOutputProxyChannelSelector (InputSpec const &input, const std::unordered_map< std::string, std::vector< fair::mq::Channel > > &channels)
	Default way to select an output channel for multi-output proxy.

DataProcessorSpec	specifyExternalFairMQDeviceProxy (char const label, std::vector< OutputSpec > const &outputs, const char defaultChannelConfig, InjectorFunction converter, uint64_t minSHM=0, bool sendTFcounter=false, bool doInjectMissingData=false, unsigned int doPrintSizes=0)

DataProcessorSpec	specifyFairMQDeviceOutputProxy (char const label, Inputs const &inputSpecs, const char defaultChannelConfig)

DataProcessorSpec	specifyFairMQDeviceMultiOutputProxy (char const label, Inputs const &inputSpecs, const char defaultChannelConfig, ChannelSelector channelSelector=defaultOutputProxyChannelSelector)

template<typename... T1s, typename... T2s, std::size_t... Is>
auto	interleaveTuplesImpl (std::tuple< T1s... > &t1, std::tuple< T2s... > &t2, std::index_sequence< Is... >)

template<typename... T1s, typename... T2s>
auto	interleaveTuples (std::tuple< T1s... > &t1, std::tuple< T2s... > &t2)

template<typename G , typename A >
expressions::BindingNode	getMatchingIndexNode ()

	DECLAREEXT (TH1D)

	DECLAREEXT (TH1F)

	DECLAREEXT (TH1I)

	DECLAREEXT (TH1C)

	DECLAREEXT (TH1S)

	DECLAREEXT (TH2D)

	DECLAREEXT (TH2F)

	DECLAREEXT (TH2I)

	DECLAREEXT (TH2C)

	DECLAREEXT (TH2S)

	DECLAREEXT (TH3D)

	DECLAREEXT (TH3F)

	DECLAREEXT (TH3I)

	DECLAREEXT (TH3C)

	DECLAREEXT (TH3S)

	DECLAREEXT (THnD)

	DECLAREEXT (THnF)

	DECLAREEXT (THnI)

	DECLAREEXT (THnC)

	DECLAREEXT (THnS)

	DECLAREEXT (THnL)

	DECLAREEXT (THnSparseD)

	DECLAREEXT (THnSparseF)

	DECLAREEXT (THnSparseI)

	DECLAREEXT (THnSparseC)

	DECLAREEXT (THnSparseS)

	DECLAREEXT (THnSparseL)

	DECLAREEXT (TProfile)

	DECLAREEXT (TProfile2D)

	DECLAREEXT (TProfile3D)

	DECLAREEXT (StepTHnF)

void	cannotBuildAnArray ()

std::shared_ptr< arrow::Table >	makeArrowTable (const char *label, std::vector< std::shared_ptr< arrow::ChunkedArray > > &&columns, std::vector< std::shared_ptr< arrow::Field > > &&fields)

std::ostream &	operator<< (std::ostream &oss, Lifetime const &val)

struct	O2_DPL_CAPABILITY ("mutex") MutexLock

void	addLabelToSchema (std::shared_ptr< arrow::Schema > &schema, const char *label)

template<typename... ARGS>
auto	make_builders ()

template<typename... ARGS>
constexpr auto	tuple_to_pack (std::tuple< ARGS... > &&)

template<class T >
auto constexpr	to_tuple (T &&object) noexcept

template<typename... ARGS>
constexpr auto	makeHolderTypes ()

template<typename... ARGS>
auto	makeHolders (arrow::MemoryPool *pool, size_t nRows)

template<typename T >
auto	makeEmptyTable (const char *name)

template<soa::TableRef R>
auto	makeEmptyTable ()

template<typename... Cs>
auto	makeEmptyTable (const char *name, framework::pack< Cs... > p)

std::shared_ptr< arrow::Table >	spawnerHelper (std::shared_ptr< arrow::Table > const &fullTable, std::shared_ptr< arrow::Schema > newSchema, size_t nColumns, expressions::Projector projectors, std::vector< std::shared_ptr< arrow::Field > > const &fields, const char name)

template<aod::is_aod_hash D>
auto	spawner (std::vector< std::shared_ptr< arrow::Table > > &&tables, const char *name)
	Expression-based column generator to materialize columns.

template<aod::is_aod_hash D>
auto	spawner (std::shared_ptr< arrow::Table > const &fullTable, const char *name)

template<typename... C>
auto	spawner (framework::pack< C... > columns, std::vector< std::shared_ptr< arrow::Table > > &&tables, const char *name)

auto	basicROOTTypeFromArrow (arrow::Type::type id)

template<typename T , typename... Args>
AlgorithmSpec	adaptFromTask (Args &&... args)

template<typename T >
AlgorithmSpec	adoptTask (std::shared_ptr< T > task)

std::vector< ConfigParamSpec >	timerSpecs (std::vector< TimerSpec > intervals)

template<VariantType V>
constexpr auto	isArray ()

template<VariantType V>
constexpr auto	isArray2D ()

template<VariantType V>
constexpr auto	isLabeledArrayString ()

template<VariantType V>
constexpr auto	isLabeledArray ()

template<VariantType V>
constexpr auto	isSimpleVariant ()

	DECLARE_VARIANT_TRAIT (int, Int)

	DECLARE_VARIANT_TRAIT (int8_t, Int8)

	DECLARE_VARIANT_TRAIT (int16_t, Int16)

	DECLARE_VARIANT_TRAIT (long int, Int64)

	DECLARE_VARIANT_TRAIT (long long int, Int64)

	DECLARE_VARIANT_TRAIT (uint8_t, UInt8)

	DECLARE_VARIANT_TRAIT (uint16_t, UInt16)

	DECLARE_VARIANT_TRAIT (uint32_t, UInt32)

	DECLARE_VARIANT_TRAIT (unsigned long int, UInt64)

	DECLARE_VARIANT_TRAIT (unsigned long long int, UInt64)

	DECLARE_VARIANT_TRAIT (float, Float)

	DECLARE_VARIANT_TRAIT (double, Double)

	DECLARE_VARIANT_TRAIT (bool, Bool)

	DECLARE_VARIANT_TRAIT (const char *, String)

	DECLARE_VARIANT_TRAIT (char *, String)

	DECLARE_VARIANT_TRAIT (std::string_view, String)

	DECLARE_VARIANT_TRAIT (std::string, String)

	DECLARE_VARIANT_TRAIT (int *, ArrayInt)

	DECLARE_VARIANT_TRAIT (float *, ArrayFloat)

	DECLARE_VARIANT_TRAIT (double *, ArrayDouble)

	DECLARE_VARIANT_TRAIT (bool *, ArrayBool)

	DECLARE_VARIANT_TRAIT (std::string *, ArrayString)

	DECLARE_VARIANT_TRAIT (std::vector< int >, ArrayInt)

	DECLARE_VARIANT_TRAIT (std::vector< float >, ArrayFloat)

	DECLARE_VARIANT_TRAIT (std::vector< double >, ArrayDouble)

	DECLARE_VARIANT_TRAIT (std::vector< bool >, ArrayBool)

	DECLARE_VARIANT_TRAIT (std::vector< std::string >, ArrayString)

	DECLARE_VARIANT_TRAIT (Array2D< int >, Array2DInt)

	DECLARE_VARIANT_TRAIT (Array2D< float >, Array2DFloat)

	DECLARE_VARIANT_TRAIT (Array2D< double >, Array2DDouble)

	DECLARE_VARIANT_TRAIT (LabeledArray< int >, LabeledArrayInt)

	DECLARE_VARIANT_TRAIT (LabeledArray< float >, LabeledArrayFloat)

	DECLARE_VARIANT_TRAIT (LabeledArray< double >, LabeledArrayDouble)

	DECLARE_VARIANT_TRAIT (LabeledArray< std::string >, LabeledArrayString)

	DECLARE_VARIANT_TYPE (int, Int)

	DECLARE_VARIANT_TYPE (int8_t, Int8)

	DECLARE_VARIANT_TYPE (int16_t, Int16)

	DECLARE_VARIANT_TYPE (int64_t, Int64)

	DECLARE_VARIANT_TYPE (uint8_t, UInt8)

	DECLARE_VARIANT_TYPE (uint16_t, UInt16)

	DECLARE_VARIANT_TYPE (uint32_t, UInt32)

	DECLARE_VARIANT_TYPE (uint64_t, UInt64)

	DECLARE_VARIANT_TYPE (float, Float)

	DECLARE_VARIANT_TYPE (double, Double)

	DECLARE_VARIANT_TYPE (const char *, String)

	DECLARE_VARIANT_TYPE (bool, Bool)

	DECLARE_VARIANT_TYPE (int *, ArrayInt)

	DECLARE_VARIANT_TYPE (float *, ArrayFloat)

	DECLARE_VARIANT_TYPE (double *, ArrayDouble)

	DECLARE_VARIANT_TYPE (bool *, ArrayBool)

	DECLARE_VARIANT_TYPE (std::string *, ArrayString)

	DECLARE_VARIANT_TYPE (Array2D< int >, Array2DInt)

	DECLARE_VARIANT_TYPE (Array2D< float >, Array2DFloat)

	DECLARE_VARIANT_TYPE (Array2D< double >, Array2DDouble)

	DECLARE_VARIANT_TYPE (LabeledArray< int >, LabeledArrayInt)

	DECLARE_VARIANT_TYPE (LabeledArray< float >, LabeledArrayFloat)

	DECLARE_VARIANT_TYPE (LabeledArray< double >, LabeledArrayDouble)

	DECLARE_VARIANT_TYPE (LabeledArray< std::string >, LabeledArrayString)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (int, ArrayInt)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (int, Array2DInt)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (float, ArrayFloat)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (float, Array2DFloat)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (double, ArrayDouble)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (double, Array2DDouble)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (bool, ArrayBool)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (std::string, ArrayString)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (int, LabeledArrayInt)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (float, LabeledArrayFloat)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (double, LabeledArrayDouble)

	DECLARE_VARIANT_ARRAY_ELEMENT_TYPE (std::string, LabeledArrayString)

Variant	emptyDict ()

template<typename T >
boost::property_tree::ptree	basicVectorToBranch (T *values, size_t size)

template<typename T >
boost::property_tree::ptree	basicVectorToBranch (std::vector< T > &&values)

template<typename T >
boost::property_tree::ptree	vectorToBranch (T *values, size_t size)

template<typename T >
boost::property_tree::ptree	vectorToBranch (std::vector< T > &&values)

template<typename T >
boost::property_tree::ptree	basicArray2DToBranch (Array2D< T > &&array)

template<typename T >
boost::property_tree::ptree	array2DToBranch (Array2D< T > &&array)

template<typename T >
std::vector< T >	basicVectorFromBranch (boost::property_tree::ptree const &branch)

template<typename T >
std::vector< T >	vectorFromBranch (boost::property_tree::ptree const &branch)

template<typename T >
Array2D< T >	basicArray2DFromBranch (boost::property_tree::ptree const &branch)

template<typename T >
Array2D< T >	array2DFromBranch (boost::property_tree::ptree const &ptree)

std::pair< std::vector< std::string >, std::vector< std::string > >	extractLabels (boost::property_tree::ptree const &tree)

template<typename T >
LabeledArray< T >	labeledArrayFromBranch (boost::property_tree::ptree const &tree)

template<typename T >
boost::property_tree::ptree	labeledArrayToBranch (LabeledArray< T > &&array)

WorkflowSpec	parallel (DataProcessorSpec original, size_t maxIndex, std::function< void(DataProcessorSpec &, size_t id)> amendCallback)

WorkflowSpec	parallel (WorkflowSpec specs, size_t maxIndex, std::function< void(DataProcessorSpec &, size_t id)> amendCallback)

WorkflowSpec	parallelPipeline (const WorkflowSpec &specs, size_t nPipelines, std::function< size_t()> getNumberOfSubspecs, std::function< size_t(size_t)> getSubSpec)

Inputs	mergeInputs (InputSpec original, size_t maxIndex, std::function< void(InputSpec &, size_t)> amendCallback)

Inputs	mergeInputs (Inputs inputs, size_t maxIndex, std::function< void(InputSpec &, size_t)> amendCallback)

DataProcessorSpec	timePipeline (DataProcessorSpec original, size_t count)

std::vector< InputSpec >	select (char const *matcher="")

std::vector< MetricIndices >	createDefaultIndices (std::vector< DeviceMetricsInfo > &allDevicesMetrics)

uint64_t	calculateAvailableSharedMemory (ServiceRegistryRef registry)

CallbacksPolicy	epnProcessReporting ()

ConfigParamSpec	ccdbQueryRateSpec (int r)

ConfigParamSpec	ccdbMetadataSpec (std::string const &key, std::string const &defaultValue)

bool	isIPAddress (const std::string &address)

void	retryMetricCallback (uv_async_t *async)

long	getTotalNumberOfBytes ()

template LabeledArray< std::string >	ConfigParamRegistry::get< LabeledArray< std::string > > (const char *key) const

template Array2D< std::string >	ConfigParamRegistry::get< Array2D< std::string > > (const char *key) const

template std::vector< std::string >	ConfigParamRegistry::get< std::vector< std::string > > (const char *key) const

template std::vector< double >	ConfigParamRegistry::get< std::vector< double > > (const char *key) const

template std::vector< float >	ConfigParamRegistry::get< std::vector< float > > (const char *key) const

template std::vector< int >	ConfigParamRegistry::get< std::vector< int > > (const char *key) const

template std::string	ConfigParamRegistry::get< std::string > (const char *key) const

void	doWriteTable (std::shared_ptr< FairMQResizableBuffer > b, arrow::Table *table)

void	doWriteBatch (std::shared_ptr< FairMQResizableBuffer > b, arrow::RecordBatch *batch)

std::string	SpectoString (InputSpec input)

void	on_idle_timer (uv_timer_t *handle)

bool	hasOnlyTimers (DeviceSpec const &spec)

bool	hasOnlyGenerated (DeviceSpec const &spec)

void	on_transition_requested_expired (uv_timer_t *handle)

void	on_data_processing_expired (uv_timer_t *handle)

void	on_communication_requested (uv_async_t *s)

DeviceSpec const &	getRunningDevice (RunningDeviceRef const &running, ServiceRegistryRef const &services)

void	run_callback (uv_work_t *handle)

void	run_completion (uv_work_t *handle, int status)

void	on_socket_polled (uv_poll_t *poller, int status, int events)

void	on_out_of_band_polled (uv_poll_t *poller, int status, int events)

void	on_signal_callback (uv_signal_t *handle, int signum)

void	handleRegionCallbacks (ServiceRegistryRef registry, std::vector< fair::mq::RegionInfo > &infos)
	Invoke the callbacks for the mPendingRegionInfos.

void	doSendOldestPossibleTimeframe (ServiceRegistryRef ref, fair::mq::TransportFactory *transport, ChannelIndex index, SendingPolicy::SendingCallback const &callback, size_t timeslice)

size_t	matchToContext (void const *data, std::vector< DataDescriptorMatcher > const &matchers, std::vector< size_t > const &index, VariableContext &context)

void	sendVariableContextMetrics (VariableContext &context, TimesliceSlot slot, DataProcessingStates &states)

bool	isCalibrationData (std::unique_ptr< fair::mq::Message > &first)

MatcherInfo	extractMatcherInfo (DataDescriptorMatcher const &top)

std::string	xmlEncode (std::string const &source)

size_t	levenshteinDistance (const char s, int len_s, const char t, int len_t)

std::string	findBestCandidate (const std::string &candidate, const LogicalChannelsMap &map)

DeviceState::LoopReason	loopReasonFromString (std::string_view reason)

unsigned long	convertTimestamp (const std::chrono::time_point< std::chrono::system_clock > &timestamp)

void	websocket_server_close_callback (uv_handle_t *handle)
	Free any resource associated with the device - driver channel.

void	ws_error_write_callback (uv_write_t *h, int status)

void	websocket_server_callback (uv_stream_t stream, ssize_t nread, const uv_buf_t buf)
	Actually replies to any incoming websocket stuff.

void	ws_handshake_done_callback (uv_write_t *h, int status)

void	populateHeader (std::map< std::string, std::string > &headers, std::string_view const &k, std::string_view const &v)

void	remoteGuiCallback (uv_timer_s *ctx)

void	ws_server_write_callback (uv_write_t *h, int status)

void	ws_server_bulk_write_callback (uv_write_t *h, int status)

void	close_client_websocket (uv_handle_t *stream)

void	websocket_client_callback (uv_stream_t stream, ssize_t nread, const uv_buf_t buf)

void	ws_client_write_callback (uv_write_t *h, int status)

void	ws_client_bulk_write_callback (uv_write_t *h, int status)

void	sendOnChannel (fair::mq::Device &device, fair::mq::Parts &messages, OutputSpec const &spec, DataProcessingHeader::StartTime tslice, ChannelRetriever &channelRetriever)

void	sendOnChannel (fair::mq::Device &device, fair::mq::MessagePtr &&headerMessage, fair::mq::MessagePtr &&payloadMessage, OutputSpec const &spec, ChannelRetriever &channelRetriever)

auto	getFinalIndex (DataHeader const &dh, size_t msgidx) -> size_t

void	injectMissingData (fair::mq::Device &device, fair::mq::Parts &parts, std::vector< OutputRoute > const &routes, bool doInjectMissingData, unsigned int doPrintSizes)

template<typename T >
T *	generateHist (const std::string &name, const std::string &title, const std::size_t nDim, const int nBins[], const double lowerBounds[], const double upperBounds[], const int nSteps)

	EXPIMPL (TH1D)

	EXPIMPL (TH1F)

	EXPIMPL (TH1I)

	EXPIMPL (TH1C)

	EXPIMPL (TH1S)

	EXPIMPL (TH2D)

	EXPIMPL (TH2F)

	EXPIMPL (TH2I)

	EXPIMPL (TH2C)

	EXPIMPL (TH2S)

	EXPIMPL (TH3D)

	EXPIMPL (TH3F)

	EXPIMPL (TH3I)

	EXPIMPL (TH3C)

	EXPIMPL (TH3S)

	EXPIMPL (THnD)

	EXPIMPL (THnF)

	EXPIMPL (THnI)

	EXPIMPL (THnC)

	EXPIMPL (THnS)

	EXPIMPL (THnL)

	EXPIMPL (THnSparseD)

	EXPIMPL (THnSparseF)

	EXPIMPL (THnSparseI)

	EXPIMPL (THnSparseC)

	EXPIMPL (THnSparseS)

	EXPIMPL (THnSparseL)

	EXPIMPL (TProfile)

	EXPIMPL (TProfile2D)

	EXPIMPL (TProfile3D)

	EXPIMPL (StepTHnF)

void	encode_websocket_frames (std::vector< uv_buf_t > &outputs, char const *src, size_t size, WebSocketOpCode opcode, uint32_t mask)

void	decode_websocket (char *start, size_t size, WebSocketHandler &handler)

std::string	encode_websocket_handshake_request (const char endpoint, const char protocol, int version, char const *nonce, std::vector< std::pair< std::string, std::string > > headers)

std::string	encode_websocket_handshake_reply (char const *nonce)

void	parse_http_request (char start, size_t size, HTTPParser parser)

std::pair< std::string, unsigned short >	parse_websocket_url (char const *url)

struct	__attribute__ ((__packed__)) WebSocketFrameTiny

size_t	readToBuffer (void p, size_t size, size_t nmemb, void userdata)

size_t	readToMessage (void p, size_t size, size_t nmemb, void userdata)

void	dumpDeviceSpec2O2Control (std::string workflowName, std::vector< DeviceSpec > const &specs, std::vector< DeviceExecution > const &executions, CommandInfo const &commandInfo)
	Dumps the AliECS compatible workflow and task templates for a DPL workflow.

void	dumpWorkflow (std::ostream &dumpOut, const std::vector< DeviceSpec > &specs, const std::vector< DeviceExecution > &executions, const CommandInfo &commandInfo, std::string workflowName, std::string indLevel)
	Dumps only the workflow file.

void	dumpTask (std::ostream &dumpOut, const DeviceSpec &spec, const DeviceExecution &execution, std::string taskName, std::string indLevel)
	Dumps only one task.

std::istream &	operator>> (std::istream &in, enum TerminationPolicy &policy)

std::ostream &	operator<< (std::ostream &out, const enum DriverMode &mode)

std::istream &	operator>> (std::istream &in, enum DriverMode &mode)

std::ostream &	operator<< (std::ostream &out, const enum TerminationPolicy &policy)

std::istream &	operator>> (std::istream &in, enum EarlyForwardPolicy &policy)

std::ostream &	operator<< (std::ostream &out, const enum EarlyForwardPolicy &policy)

std::istream &	operator>> (std::istream &in, enum LogParsingHelpers::LogLevel &level)

std::ostream &	operator<< (std::ostream &out, const enum LogParsingHelpers::LogLevel &level)

template<typename T >
auto	replaceLabels (LabeledArray< T > &input, LabeledArray< T > &&spec)

template<>
void	PropertyTreeHelpers::traverse< boost::property_tree::ptree > (const boost::property_tree::ptree &parent, PropertyTreeHelpers::WalkerFunction< boost::property_tree::ptree > &method)

std::ostream &	operator<< (std::ostream &stream, o2::framework::InputSpec const &arg)

std::ostream &	operator<< (std::ostream &stream, o2::framework::OutputSpec const &arg)

bool	dataDeps (DataProcessorSpec const &a, DataProcessorSpec const &b)

bool	expendableDataDeps (DataProcessorSpec const &a, DataProcessorSpec const &b)

std::ostream &	operator<< (std::ostream &oss, Variant const &val)

std::ostream &	operator<< (std::ostream &out, TopoIndexInfo const &info)

std::string	defaultConditionBackend ()

int	defaultConditionQueryRate ()

int	defaultConditionQueryRateMultiplier ()

bool	validateLifetime (std::ostream &errors, DataProcessorSpec const &producer, OutputSpec const &output, DataProcessorPoliciesInfo const &producerPolicies, DataProcessorSpec const &consumer, InputSpec const &input, DataProcessorPoliciesInfo const &consumerPolicies)

bool	validateExpendable (std::ostream &errors, DataProcessorSpec const &producer, OutputSpec const &output, DataProcessorPoliciesInfo const &producerPolicies, DataProcessorSpec const &consumer, InputSpec const &input, DataProcessorPoliciesInfo const &consumerPolicies)

WorkflowSpec	parallel (DataProcessorSpec original, size_t maxIndex, std::function< void(DataProcessorSpec &, size_t)> amendCallback)

WorkflowSpec	parallel (WorkflowSpec specs, size_t maxIndex, std::function< void(DataProcessorSpec &, size_t)> amendCallback)

void	on_connect (uv_connect_t *connection, int status)

void	on_awake_main_thread (uv_async_t *handle)

void	sendMessageToDriver (std::unique_ptr< o2::framework::WSDPLClient > &client, char const *message, size_t s)

bool	search (DeviceExecution const &execution, std::string const &option, std::string const &argument)

void	check (const std::vector< std::string > &arguments, const std::vector< ConfigParamSpec > &workflowOptions, const std::vector< DeviceSpec > &deviceSpecs, CheckMatrix &matrix)

	TEST_CASE ("test_prepareArguments")

	TEST_CASE ("CheckOptionReworking")

	TEST_CASE ("CheckIntegerReworking")

	TEST_CASE ("Check validity of the workflow")

	TEST_CASE ("CheckReworkingEnv")

template<typename T , typename TDefined , typename TUndefined >
void	call_if_defined_full (TDefined &&onDefined, TUndefined &&onUndefined)

template<typename T , typename TDefined , typename TUndefined >
T	call_if_defined_full_forward (TDefined &&onDefined, TUndefined &&onUndefined)

template<typename T , typename TDefined >
void	call_if_defined (TDefined &&onDefined)

template<typename T , typename TDefined >
T	call_if_defined_forward (TDefined &&onDefined)

template<typename F >
memfun_type< decltype(&F::operator())>::type	FFL (F const &func)

template<typename F >
memfun_type< decltype(&F::operator())>	FunctionMetadata (F const &func)

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

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

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

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

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

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

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

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

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

template<typename... Rs, nonvoid_pack_element T1, nonvoid_pack_element T2, typename... Ts>
consteval auto	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	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	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	select_pack (Result result, pack<>, pack< Cs... >)

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

template<template< typename > typename Condition, typename Result >
constexpr auto	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	filter_pack (Result result, pack< T, Ts... >)

template<typename T >
void	print_pack ()

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

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

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

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

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

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

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

template<typename P1 >
constexpr auto	concatenate_pack_unique (P1 p1)

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

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

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

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

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

RuntimeErrorRef	runtime_error (const char *)

RuntimeErrorRef	runtime_error_f (const char *,...)

RuntimeError &	error_from_ref (RuntimeErrorRef)

void	throw_error (RuntimeErrorRef)

void	clean_all_runtime_errors ()

template<typename T >
consteval auto	brace_constructible_size (auto... Members)

template<bool B, typename T >
consteval int	nested_brace_constructible_size ()

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 9)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 8)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 7)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 6)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 5)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 4)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 3)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 2)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 1)
auto	homogeneous_apply_refs (L l, T &&object)

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10> requires (D == 0)
auto	homogeneous_apply_refs (L l, T &&object)

template<class... Ts>
	overloaded (Ts...) -> overloaded< Ts... >

void	clean_runtime_error (int i)

template<typename RDH , typename Container >
void	fillPages (Container &buffer)

	TEMPLATE_TEST_CASE ("test_RawParser", "[RDH][template]", V5, V6, V7)

template<typename Deleter , size_t Size>
bool	operator== (const std::unique_ptr< const std::vector< TObject * >, Deleter > &vectorOfHistos, std::vector< ExpectedType< Size > > &expected)

Variables
auto	readValues

auto	readBoolValues

auto	readVLAValues

auto	readOffsets

constexpr int	MAX_USER_FILTER_SIZE = 256

constexpr double	VARIABLE_WIDTH = 0.

template<typename T >
constexpr ServiceKind	service_kind_v = ServiceKindExtractor<T>::kind

template<typename T >
constexpr VariantType	variant_trait_v = variant_trait<T>::value

auto	decongestionCallback

auto	decongestionCallbackOrdered

auto	decongestionCallbackLate

volatile int	region_read_global_dummy_variable

constexpr int	INVALID_INPUT = -1

auto	storeIdx

auto	createMetricInfo

auto	findOverrideByName

template<typename , typename = void>
constexpr bool	is_type_complete_v = false

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

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

template<typename T , template< typename... > class Ref>
constexpr bool	is_specialization_v = is_specialization<T, Ref>::value

template<typename... T>
constexpr bool	always_static_assert_v = always_static_assert<T...>::value

template<template< typename... > typename B, typename D >
constexpr bool	is_base_of_template_v = base_of_template<B, D>

template<typename T >
constexpr auto	unique_type_id_v = unique_type_id<T>::value

constexpr size_t	PageSize = 8192

Detailed Description

Defining PrimaryVertex explicitly as messageable.

Helper struct which holds all the lists the Driver needs to know about.

Defining DataPointIdentifier explicitly as messageable.

Defining DataPointCompositeObject explicitly as messageable.

Defining PrimaryVertexExt explicitly as messageable.

Defining o2::itsmft::Cluster explicitly as messageable

o2::itsmft::Cluster does not fulfill is_messageable because the underlying ROOT classes of Point3D are note trivially copyable. std::is_trivially_copyable<ROOT::Math::Cartesian3D<float>> fails because the class implements a copy constructor, although it does not much more than the default copy constructor. Have been trying to specialize std::is_trivially_copyable for Point3D alias in MathUtils/Cartesian.h, but structures with a member of Point3D are still not fulfilling the condition. Need to understand how the type trait checks the condition for members. We believe that o2::itsmft::Cluster is messageable and explicitly specialize the type trait, adding a corresponding unit test to go beyond make-believe

Defining o2::tof::Cluster explicitly as messageable

o2::tof::Cluster does not fulfill is_messageable because the underlying ROOT classes of Point3D are note trivially copyable. std::is_trivially_copyable<ROOT::Math::Cartesian3D<float>> fails because the class implements a copy constructor, although it does not much more than the default copy constructor. Have been trying to specialize std::is_trivially_copyable for Point3D alias in MathUtils/Cartesian.h, but structures with a member of Point3D are still not fulfilling the condition. Need to understand how the type trait checks the condition for members. We believe that o2::tof::Cluster is messageable and explicitly specialize the type trait, adding a corresponding unit test to go beyond make-believe

This class holds the information about timing of the messages being processed.

Typedef Documentation

◆ ChannelRetriever

using o2::framework::ChannelRetriever = typedef std::function<std::string const&(OutputSpec const&, DataProcessingHeader::StartTime)>

A callback function to retrieve the fair::mq::Channel name to be used for sending messages of the specified OutputSpec

Definition at line 25 of file ExternalFairMQDeviceProxy.h.

◆ ChannelSelector

using o2::framework::ChannelSelector = typedef std::function<std::string(InputSpec const& input, const std::unordered_map<std::string, std::vector<fair::mq::Channel> >& channels)>

Definition at line 36 of file ExternalFairMQDeviceProxy.h.

◆ CheckMatrix

using o2::framework::CheckMatrix = typedef std::map<std::string, std::vector<std::pair<std::string, std::string> >>

Definition at line 31 of file test_DeviceSpecHelpers.cxx.

◆ ComputingQuotaConsumer

using o2::framework::ComputingQuotaConsumer = typedef std::function<void(int id, std::array<ComputingQuotaOffer, 16>&, ComputingQuotaStats&, std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats& stats)>)>

A consumer is a function which updates a given function removing the amount of resources which are considered as consumed.

Definition at line 83 of file ComputingQuotaOffer.h.

◆ ComputingQuotaRequest

using o2::framework::ComputingQuotaRequest = typedef std::function<OfferScore(ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated)>

A request is a function which gets applied to all available offers one after the other. If the offer itself is deemed is ok for running.

Definition at line 79 of file ComputingQuotaOffer.h.

◆ concatenated_pack_t

template<typename... Ps>

using o2::framework::concatenated_pack_t = typedef decltype(concatenate_pack(Ps{}...))

Definition at line 90 of file Pack.h.

◆ concatenated_pack_unique_t

template<typename... Ps>

using o2::framework::concatenated_pack_unique_t = typedef decltype(concatenate_pack_unique(Ps{}...))

Definition at line 319 of file Pack.h.

◆ ConfigurableAxis

using o2::framework::ConfigurableAxis = typedef Configurable<std::vector<double>, ConfigParamKind::kAxisSpec, ConfigurablePolicyConst<std::vector<double>, ConfigParamKind::kAxisSpec> >

Definition at line 93 of file Configurable.h.

◆ DataDescription

using o2::framework::DataDescription = typedef o2::header::DataDescription

Definition at line 46 of file DataAllocator.cxx.

◆ DataHeader

typedef o2::header::DataHeader o2::framework::DataHeader

Definition at line 45 of file DataAllocator.cxx.

◆ DataProcessingHeader

using o2::framework::DataProcessingHeader = typedef o2::framework::DataProcessingHeader

Definition at line 47 of file DataAllocator.cxx.

◆ DataProcessorMatcher

using o2::framework::DataProcessorMatcher = typedef std::function<bool(DataProcessorSpec const& spec)>

Definition at line 23 of file DataProcessorMatchers.h.

◆ DeviceMatcher

using o2::framework::DeviceMatcher = typedef std::function<bool(DeviceSpec const& spec, ConfigContext const& context)>

Definition at line 25 of file DataProcessorMatchers.h.

◆ EdgeMatcher

using o2::framework::EdgeMatcher = typedef std::function<bool(DataProcessorSpec const& source, DataProcessorSpec const& dest, ConfigContext const& context)>

Definition at line 30 of file DataProcessorMatchers.h.

◆ ExpectedType

template<size_t Size>

using o2::framework::ExpectedType = typedef std::array<float, Size>

Definition at line 48 of file vectorTopologyCommon.h.

◆ filtered_pack

template<template< typename > typename Condition, typename... Types>

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

Definition at line 207 of file Pack.h.

◆ full_intersected_pack_t

template<typename... Ps>

using o2::framework::full_intersected_pack_t = typedef decltype(intersected_pack(Ps{}...))

Definition at line 283 of file Pack.h.

◆ GID

using o2::framework::GID = typedef o2::dataformats::GlobalTrackID

Definition at line 127 of file ITSTPCMatchingQCSpec.cxx.

◆ HistPtr

using o2::framework::HistPtr = typedef std::variant<std::shared_ptr<THn>, std::shared_ptr<THnSparse>, std::shared_ptr<TH3>, std::shared_ptr<TH2>, std::shared_ptr<TH1>, std::shared_ptr<TProfile3D>, std::shared_ptr<TProfile2D>, std::shared_ptr<TProfile>, std::shared_ptr<StepTHn> >

Definition at line 73 of file HistogramSpec.h.

◆ IndexedHoldersTuple

template<typename... ARGS>

using o2::framework::IndexedHoldersTuple = typedef decltype(makeHolderTypes<ARGS...>())

Definition at line 624 of file TableBuilder.h.

◆ InjectorFunction

using o2::framework::InjectorFunction = typedef std::function<bool(TimingInfo&, ServiceRegistryRef const& services, fair::mq::Parts& inputs, ChannelRetriever, size_t newTimesliceId, bool& stop)>

The callback which actually does the heavy lifting of converting the input data into DPL messages. The callback is invoked with the following parameters:

Parameters

timingInfo	is the timing information of the current timeslice
services	is the service registry
inputs	is the list of input messages
channelRetriever	is a callback to retrieve the fair::mq::Channel name to be used for sending the messages
newTimesliceId	is the timeslice ID of the current timeslice

Returns: true if any message were sent, false otherwise

Definition at line 35 of file ExternalFairMQDeviceProxy.h.

◆ Inputs

typedef std::vector< InputSpec > o2::framework::Inputs

Definition at line 29 of file DataProcessorSpec.h.

◆ interleaved_pack_t

template<typename P1 , typename P2 >

using o2::framework::interleaved_pack_t = typedef decltype(interleave_pack(P1{}, P2{}))

Definition at line 99 of file Pack.h.

◆ intersected_pack_t

template<typename S1 , typename S2 >

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

Definition at line 268 of file Pack.h.

◆ is_index_to_g_t

template<typename T , typename G >

using o2::framework::is_index_to_g_t = typedef typename std::conditional<o2::soa::is_binding_compatible_v<G, typename T::binding_t>(), std::true_type, std::false_type>::type

Definition at line 38 of file GroupedCombinations.h.

◆ iterator_tuple_t

template<typename... T>

using o2::framework::iterator_tuple_t = typedef std::tuple<typename T::iterator...>

Definition at line 925 of file TableBuilder.h.

◆ labelmap_t

using o2::framework::labelmap_t = typedef std::unordered_map<std::string, uint32_t>

Definition at line 127 of file Array2D.h.

◆ ListVector

typedef std::vector< std::vector< int64_t > > o2::framework::ListVector

Definition at line 21 of file ArrowTableSlicingCache.h.

◆ LogicalChannelsMap

using o2::framework::LogicalChannelsMap = typedef std::map<LogicalChannelRange, size_t>

Definition at line 27 of file DeviceSpec.cxx.

◆ LogLevel

using o2::framework::LogLevel = typedef o2::framework::LogParsingHelpers::LogLevel

Definition at line 25 of file LogParsingHelpers.cxx.

◆ MetricsStorage

template<typename T >

using o2::framework::MetricsStorage = typedef std::array<T, metricStorageSize<T>()>

Definition at line 141 of file DeviceMetricsInfo.h.

◆ MutableConfigurable

template<typename T , ConfigParamKind K = ConfigParamKind::kGeneric>

using o2::framework::MutableConfigurable = typedef Configurable<T, K, ConfigurablePolicyMutable<T, K> >

Definition at line 84 of file Configurable.h.

◆ OnWorkflowTerminationHook

using o2::framework::OnWorkflowTerminationHook = typedef std::function<void(const char*)>

A callback definition for a hook to be invoked when processes terminate

The parameter is the nullptr if the process is the main driver, for all child processes, the id string is passed. This allows to customize the hook depending on the process. Note that the callback hook is invoked for every process, i.e. main driver and all children.

Usage:

The customize the hook, add a function with the following signature before including heder file runDataProcessing.h:

void customize(o2::framework::OnWorkflowTerminationHook& hook)
{
  hook = [](const char* idstring){
    if (idstring == nullptr) {
      std::cout << "hook" << std::endl;
    } else {
      std::cout << "child process " << idstring << " terminating" << std::endl;
    }
  };
}
#include "Framework/runDataProcessing.h"

Definition at line 42 of file CustomWorkflowTerminationHook.h.

◆ Options

typedef std::vector< ConfigParamSpec > o2::framework::Options

Definition at line 31 of file DataProcessorSpec.h.

◆ options_description

using o2::framework::options_description = typedef boost::program_options::options_description

Definition at line 25 of file ConfigParamsHelper.h.

◆ Outputs

typedef std::vector< OutputSpec > o2::framework::Outputs

Definition at line 30 of file DataProcessorSpec.h.

◆ OverrideServiceSpecs

using o2::framework::OverrideServiceSpecs = typedef std::vector<OverrideServiceSpec>

Definition at line 229 of file ServiceSpec.h.

◆ pack_element_t

template<std::size_t I, typename T >

using o2::framework::pack_element_t = typedef typename pack_element<I, T>::type

Definition at line 56 of file Pack.h.

◆ pack_head_t

template<typename T >

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

Definition at line 59 of file Pack.h.

◆ pack_to_tuple_t

template<typename P >

using o2::framework::pack_to_tuple_t = typedef decltype(pack_to_tuple(P{}))

Definition at line 343 of file Pack.h.

◆ Pair

template<typename G , typename A1 , typename A2 , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G>>

using o2::framework::Pair = typedef GroupedCombinationsGenerator<T1, GroupingPolicy, BP, G, A1, A2>

Definition at line 253 of file GroupedCombinations.h.

◆ Preslice

template<typename T >

using o2::framework::Preslice = typedef PresliceBase<T, PreslicePolicySorted, false>

Definition at line 1453 of file ASoA.h.

◆ PresliceOptional

template<typename T >

using o2::framework::PresliceOptional = typedef PresliceBase<T, PreslicePolicySorted, true>

Definition at line 1455 of file ASoA.h.

◆ PresliceUnsorted

template<typename T >

using o2::framework::PresliceUnsorted = typedef PresliceBase<T, PreslicePolicyGeneral, false>

Definition at line 1449 of file ASoA.h.

◆ PresliceUnsortedOptional

template<typename T >

using o2::framework::PresliceUnsortedOptional = typedef PresliceBase<T, PreslicePolicyGeneral, true>

Definition at line 1451 of file ASoA.h.

◆ Remap64Bit_t

template<typename T >

using o2::framework::Remap64Bit_t = typedef typename Remap64Bit<T>::type

Definition at line 91 of file RootTableBuilderHelpers.h.

◆ repeated_type_pack_t

template<typename T , std::size_t N>

using o2::framework::repeated_type_pack_t = typedef decltype(sequence_to_pack<T>(std::make_index_sequence<N>()))

Definition at line 352 of file Pack.h.

◆ RootTreeReader

using o2::framework::RootTreeReader = typedef GenericRootTreeReader<rtr::DefaultKey>

Definition at line 557 of file RootTreeReader.h.

◆ SameKindPair

template<typename G , typename A , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G>>

using o2::framework::SameKindPair = typedef GroupedCombinationsGenerator<T1, GroupingPolicy, BP, G, A, A>

Definition at line 255 of file GroupedCombinations.h.

◆ SameKindTriple

template<typename G , typename A , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G, G>>

using o2::framework::SameKindTriple = typedef GroupedCombinationsGenerator<T1, GroupingPolicy, BP, G, A, A, A>

Definition at line 261 of file GroupedCombinations.h.

◆ selected_pack

template<template< typename... > typename Condition, typename... Types>

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

Definition at line 179 of file Pack.h.

◆ selected_pack_multicondition

template<template< typename... > typename Condition, typename CondPack , typename Pack >

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

Definition at line 181 of file Pack.h.

◆ ServiceConfigureCallback

using o2::framework::ServiceConfigureCallback = typedef void* (*)(InitContext&, void*)

A callback to configure a given Service. Notice that the service itself is type erased and it's responsibility of the configuration itself to cast it to the correct value

Definition at line 59 of file ServiceSpec.h.

◆ ServiceDanglingCallback

using o2::framework::ServiceDanglingCallback = typedef void (*)(DanglingContext&, void*)

A callback which is executed before each dangling input loop.

Definition at line 65 of file ServiceSpec.h.

◆ ServiceDomainInfoUpdated

using o2::framework::ServiceDomainInfoUpdated = typedef void (*)(ServiceRegistryRef, size_t tileslice, ChannelIndex channel)

Callback invoked whenever we get updated about the oldest possible timeslice we can process.

Definition at line 122 of file ServiceSpec.h.

◆ ServiceDriverInit

using o2::framework::ServiceDriverInit = typedef void (*)(ServiceRegistryRef, DeviceConfig const&)

Callback invoked when the driver enters the init phase.

Definition at line 105 of file ServiceSpec.h.

◆ ServiceDriverStartup

using o2::framework::ServiceDriverStartup = typedef void (*)(ServiceRegistryRef, DeviceConfig const&)

Callback invoked when the driver enters the init phase.

Definition at line 108 of file ServiceSpec.h.

◆ ServiceEOSCallback

using o2::framework::ServiceEOSCallback = typedef void (*)(EndOfStreamContext&, void*)

A callback which is executed before the end of stream loop.

Definition at line 68 of file ServiceSpec.h.

◆ ServiceExitCallback

using o2::framework::ServiceExitCallback = typedef void (*)(ServiceRegistryRef, void*)

A callback invoked whenever we stop running completely, before we exit.

Definition at line 54 of file ServiceSpec.h.

◆ ServiceId

using o2::framework::ServiceId = typedef std::function<unsigned int()>

A callback which returns the uniqueId of the service when invoked.

Definition at line 46 of file ServiceSpec.h.

◆ ServiceInit

using o2::framework::ServiceInit = typedef ServiceHandle (*)(ServiceRegistryRef, DeviceState&, fair::mq::ProgOptions&)

A callback to create a given Service.

Definition at line 48 of file ServiceSpec.h.

◆ ServiceMetricHandling

using o2::framework::ServiceMetricHandling = typedef void (*)(ServiceRegistryRef, ServiceMetricsInfo const&, size_t timestamp)

Callback executed in the driver in order to process a metric.

Definition at line 90 of file ServiceSpec.h.

◆ ServicePostDispatching

using o2::framework::ServicePostDispatching = typedef void (*)(ProcessingContext&, void*)

Callback executed in the child after dispatching happened.

Definition at line 99 of file ServiceSpec.h.

◆ ServicePostForkChild

using o2::framework::ServicePostForkChild = typedef std::function<void(ServiceRegistryRef)>

Callback executed after forking a given device in the driver, but before doing exec / starting the device.

Definition at line 77 of file ServiceSpec.h.

◆ ServicePostForkParent

using o2::framework::ServicePostForkParent = typedef std::function<void(ServiceRegistryRef)>

Callback executed after forking a given device in the driver, but before doing exec / starting the device.

Definition at line 81 of file ServiceSpec.h.

◆ ServicePostForwarding

using o2::framework::ServicePostForwarding = typedef void (*)(ProcessingContext&, void*)

Callback executed in the child after late forwarding happened.

Definition at line 102 of file ServiceSpec.h.

◆ ServicePostRenderGUI

using o2::framework::ServicePostRenderGUI = typedef void (*)(ServiceRegistryRef)

Callback invoked right after the main gui is drawn this can be used to draw additional gui elements, which are service specific

Definition at line 130 of file ServiceSpec.h.

◆ ServicePostSchedule

using o2::framework::ServicePostSchedule = typedef void (*)(ServiceRegistryRef, DeviceConfig const&)

Callback executed after each redeployment of the whole configuration.

Definition at line 87 of file ServiceSpec.h.

◆ ServicePreFork

using o2::framework::ServicePreFork = typedef std::function<void(ServiceRegistryRef, DeviceConfig const&)>

Callback executed before the forking of a given device in the driver Notice the forking can happen multiple times. It's responsibility of the service to track how many times it happens and act accordingly.

Definition at line 73 of file ServiceSpec.h.

◆ ServicePreLoop

using o2::framework::ServicePreLoop = typedef void (*)(ServiceRegistryRef, void*)

Callback executed every time we are about to enter the uv_run loop. This is the last chance to queue something on the loop before it will wait for events.

Definition at line 113 of file ServiceSpec.h.

◆ ServicePreSchedule

using o2::framework::ServicePreSchedule = typedef void (*)(ServiceRegistryRef, DeviceConfig const&)

Callback executed before each redeployment of the whole configuration.

Definition at line 84 of file ServiceSpec.h.

◆ ServicePreSendingMessages

using o2::framework::ServicePreSendingMessages = typedef void (*)(ServiceRegistryRef, fair::mq::Parts&, ChannelIndex channel)

Callback invoked whenever we are about sending a message.

Definition at line 125 of file ServiceSpec.h.

◆ ServiceProcessingCallback

using o2::framework::ServiceProcessingCallback = typedef void (*)(ProcessingContext&, void*)

A callback which is executed before each processing loop.

Definition at line 62 of file ServiceSpec.h.

◆ ServiceSpecs

using o2::framework::ServiceSpecs = typedef std::vector<ServiceSpec>

Definition at line 230 of file ServiceSpec.h.

◆ ServiceStartCallback

using o2::framework::ServiceStartCallback = typedef void (*)(ServiceRegistryRef, void*)

A callback invoked whenever we start running, before the user processing callback.

Definition at line 50 of file ServiceSpec.h.

◆ ServiceStopCallback

using o2::framework::ServiceStopCallback = typedef void (*)(ServiceRegistryRef, void*)

A callback invoked whenever we stop running, after the user processing callback.

Definition at line 52 of file ServiceSpec.h.

◆ ServiceSummaryHandling

using o2::framework::ServiceSummaryHandling = typedef void (*)(ServiceMetricsInfo const& metrics)

Callback exectuted in the driver in order to provide summary information at the end of a run.

Definition at line 96 of file ServiceSpec.h.

◆ ServiceTopologyAdjust

using o2::framework::ServiceTopologyAdjust = typedef void (*)(WorkflowSpecNode&, ConfigContext const&)

Callback invoked when we amend the topology.

Definition at line 119 of file ServiceSpec.h.

◆ ServiceTopologyInject

using o2::framework::ServiceTopologyInject = typedef void (*)(WorkflowSpecNode&, ConfigContext&)

Callback invoked when we inject internal devices in the topology.

Definition at line 116 of file ServiceSpec.h.

◆ StringPair

using o2::framework::StringPair = typedef std::pair<std::string, std::string>

Definition at line 37 of file ArrowTableSlicingCache.h.

◆ SubSpecificationType

typedef header::DataHeader::SubSpecificationType o2::framework::SubSpecificationType

Definition at line 40 of file customTopologyCommon.h.

◆ TimestampsStorage

template<typename T >

using o2::framework::TimestampsStorage = typedef std::array<size_t, metricStorageSize<T>()>

Definition at line 144 of file DeviceMetricsInfo.h.

◆ Triple

template<typename G , typename A1 , typename A2 , typename A3 , typename BP , typename T1 = int, typename GroupingPolicy = o2::soa::CombinationsBlockStrictlyUpperSameIndexPolicy<BP, T1, G, G, G>>

using o2::framework::Triple = typedef GroupedCombinationsGenerator<T1, GroupingPolicy, BP, G, A1, A2, A3>

Definition at line 259 of file GroupedCombinations.h.

◆ UnifiedDataSpecType

using o2::framework::UnifiedDataSpecType = typedef std::variant<InputSpec, OutputSpec>

Definition at line 985 of file WorkflowHelpers.cxx.

◆ unique_pack_t

template<typename P >

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

Definition at line 334 of file Pack.h.

◆ V4

using o2::framework::V4 = typedef header::RAWDataHeaderV4

Definition at line 22 of file test_RawParser.cxx.

◆ V5

using o2::framework::V5 = typedef header::RAWDataHeaderV5

Definition at line 21 of file test_RawParser.cxx.

◆ V6

using o2::framework::V6 = typedef header::RAWDataHeaderV6

Definition at line 20 of file test_RawParser.cxx.

◆ V7

using o2::framework::V7 = typedef header::RAWDataHeaderV7

Definition at line 19 of file test_RawParser.cxx.

◆ Validator

using o2::framework::Validator = typedef std::function<bool(std::ostream& errors, DataProcessorSpec const& producer, OutputSpec const& output, DataProcessorPoliciesInfo const& producerPolicies, DataProcessorSpec const& consumer, InputSpec const& input, DataProcessorPoliciesInfo const& consumerPolicies)>

Definition at line 1109 of file WorkflowHelpers.cxx.

◆ variant_array_element_type_t

template<VariantType V>

using o2::framework::variant_array_element_type_t = typedef typename variant_array_element_type<V>::type

Definition at line 255 of file Variant.h.

◆ with_condition_pack

template<template< typename... > typename Condition, typename... Ts>

using o2::framework::with_condition_pack = typedef pack<std::conditional_t<Condition<Ts>::value, Ts, void>...>

Marks as void the types that do not satisfy the condition.

Definition at line 103 of file Pack.h.

◆ WorkflowSpec

typedef std::vector< DataProcessorSpec > o2::framework::WorkflowSpec

Definition at line 39 of file HBFUtilsInitializer.h.

Enumeration Type Documentation

◆ BasicOp

enum o2::framework::BasicOp : unsigned int

Enumerator
LogicalAnd
LogicalOr
Addition
Subtraction
Division
Multiplication
BitwiseAnd
BitwiseOr
BitwiseXor
LessThan
LessThanOrEqual
GreaterThan
GreaterThanOrEqual
Equal
NotEqual
Atan2
Power
Sqrt
Exp
Log
Log10
Sin
Cos
Tan
Asin
Acos
Atan
Abs
Round
BitwiseNot
Conditional

Definition at line 16 of file BasicOps.h.

◆ CacheEntryStatus

enum struct o2::framework::CacheEntryStatus : int

strong

Enumerator
EMPTY
PENDING
RUNNING
DONE

Definition at line 40 of file DataRelayer.h.

◆ ChannelAccountingType

enum struct o2::framework::ChannelAccountingType

strong

Enumerator
Unknown	A channel which was not explicitly set.
DPL	The channel is a normal input channel.
RAWFMQ	A raw FairMQ channel which is not accounted by the framework.

Definition at line 36 of file ChannelInfo.h.

◆ ChannelConfigParserState

enum struct o2::framework::ChannelConfigParserState

strong

Enumerator
BEGIN
BEGIN_CHANNEL
END_CHANNEL
BEGIN_KEY
BEGIN_VALUE
END_VALUE
END
ERROR

Definition at line 205 of file ChannelSpecHelpers.cxx.

◆ ChannelMethod

enum struct o2::framework::ChannelMethod

strong

These map to zeromq connection methods.

Enumerator
Bind
Connect

Definition at line 21 of file ChannelSpec.h.

◆ ChannelProtocol

enum struct o2::framework::ChannelProtocol

strong

The kind of backend to use for the channels.

Enumerator
Network
IPC

Definition at line 36 of file ChannelSpec.h.

◆ ChannelType

enum struct o2::framework::ChannelType

strong

These map to zeromq types for the channels.

Enumerator
Pub
Sub
Push
Pull
Pair

Definition at line 27 of file ChannelSpec.h.

◆ ConfigParamKind

enum o2::framework::ConfigParamKind : int

Enumerator
kGeneric
kAxisSpec
kProcessFlag

Definition at line 15 of file ConfigurableKinds.h.

◆ ConnectionKind

enum struct o2::framework::ConnectionKind

strong

Enumerator
Out
Forward
In
Unknown

Definition at line 66 of file WorkflowHelpers.h.

◆ DataProcessingStatus

enum struct o2::framework::DataProcessingStatus : uint32_t

strong

Describe the possible states for DataProcessing.

Enumerator
ID
IN_DPL_OVERHEAD
IN_DPL_USER_CALLBACK
IN_DPL_ERROR_CALLBACK

Definition at line 24 of file DataProcessingStatus.h.

◆ DeploymentMode

enum struct o2::framework::DeploymentMode

strong

Enumerator
Local
OnlineECS
OnlineDDS
OnlineAUX
Grid
FST

Definition at line 21 of file DataTakingContext.h.

◆ DplPluginKind

enum struct o2::framework::DplPluginKind : int

strong

Enumerator
CustomAlgorithm
DebugGUIImpl
CustomService
ConfigDiscovery
Capability
RootObjectReadingCapability
RootObjectReadingImplementation
Unknown

Definition at line 20 of file Plugins.h.

◆ DriverControlState

enum struct o2::framework::DriverControlState

strong

These are the possible states for the driver controller and determine what should happen of state machine transitions.

Enumerator
STEP
PLAY
PAUSE

Definition at line 28 of file DriverControl.h.

◆ DriverMode

enum struct o2::framework::DriverMode

strong

The mode in which the driver is running. Should be MASTER when running locally, EMBEDDED when running under a control system.

Enumerator
STANDALONE	Default mode. The master is responsible for spawning and controlling the devices.
EMBEDDED	The master is also running under a control system, so it does not control the devices, however, it does receive metrics and information from them and displays it via the RemoteGUI.

Definition at line 39 of file ProcessingPolicies.h.

◆ DriverStatus

enum struct o2::framework::DriverStatus : uint32_t

strong

Enumerator
ID
BYTES_READ
BYTES_PROCESSED
BUFFER_OVERFLOWS

Definition at line 38 of file DataProcessingStatus.h.

◆ EarlyForwardPolicy

enum struct o2::framework::EarlyForwardPolicy

strong

When to enable the early forwarding optimization:

Enumerator
NEVER
NORAW
ALWAYS

Definition at line 26 of file ProcessingPolicies.h.

◆ GUIOpcodes

enum struct o2::framework::GUIOpcodes : uint8_t

strong

Enumerator
Mousepos
Mouseclick
Mousewheel
Window
Latency
Keydown
Keyup
Charin

Definition at line 96 of file DPLWebSocket.cxx.

◆ HistType

enum o2::framework::HistType : unsigned int

Enumerator
kUndefinedHist
kTH1D
kTH1F
kTH1I
kTH1C
kTH1S
kTH2D
kTH2F
kTH2I
kTH2C
kTH2S
kTH3D
kTH3F
kTH3I
kTH3C
kTH3S
kTHnD
kTHnF
kTHnI
kTHnC
kTHnS
kTHnL
kTHnSparseD
kTHnSparseF
kTHnSparseI
kTHnSparseC
kTHnSparseS
kTHnSparseL
kTProfile
kTProfile2D
kTProfile3D
kStepTHnF
kStepTHnD

Definition at line 36 of file HistogramSpec.h.

◆ HTTPState

enum struct o2::framework::HTTPState

strong

Enumerator
IN_START
IN_START_REPLY
BEGIN_REPLY_VERSION
END_REPLY_VERSION
BEGIN_REPLY_CODE
END_REPLY_CODE
BEGIN_REPLY_MESSAGE
END_REPLY_MESSAGE
BEGIN_METHOD
END_METHOD
BEGIN_TARGET
END_TARGET
BEGIN_VERSION
END_VERSION
BEGIN_HEADERS
BEGIN_HEADER
BEGIN_HEADER_KEY
END_HEADER_KEY
BEGIN_HEADER_VALUE
END_HEADER_VALUE
END_HEADER
END_HEADERS
BEGIN_BODY
IN_DONE
IN_ERROR
IN_SKIP_CHARS
IN_CAPTURE_DELIMITERS	skip any "delimiters" char.
IN_CAPTURE_SEPARATOR	capture until any or the "delimiters" characters
IN_SEPARATOR	capture until a specific "separator"
IN_CHUNKED	skip a specific "separator"

Definition at line 170 of file HTTPParser.h.

◆ InputChannelState

enum struct o2::framework::InputChannelState

strong

Enumerator
Running	The channel is actively receiving data.
Paused	The channel was paused.
Completed	The channel was signaled it will not receive any data.
Pull	The channel can be used to retrieve data, but it will not send it on its own.

Definition at line 24 of file ChannelInfo.h.

◆ Lifetime

enum struct o2::framework::Lifetime

strong

Possible Lifetime of objects being exchanged by the DPL.

Enumerator
Timeframe	A message which is associated to a timeframe. DPL will wait indefinitely for it by default.
Condition	Eventually a message whose content is retrieved from CCDB.
QA	To be used when data is not produced for every timeframe but it can be result of a sampling process (like in the case of QC) or an aggregating one (like in the case of analysis histograms).
Sporadic
Transient	Do not use for now.
Timer	A message which is created whenever a Timer expires.
Enumeration	A message which is created immediately, with payload / containing a single value which gets incremented for every / invokation.
Signal	A message which is created every time a SIGUSR1 is received.
Optional	An optional message. When data arrives, if not already part of the data, a dummy entry will be generated. This comes handy e.g. to handle Raw Data, since DataDistribution will provide everything in one go so whatever is expected but not there, for whatever reason will be substituted with a dummy entry.
OutOfBand	An input which is materialised with the contents of some out of band FairMQ channel.

Definition at line 18 of file Lifetime.h.

◆ MetricType

enum class o2::framework::MetricType

strong

Enumerator
Int
String
Float
Uint64
Enum
Unknown

Definition at line 28 of file DeviceMetricsInfo.h.

◆ MonitoringStatus

enum struct o2::framework::MonitoringStatus : uint32_t

strong

Describe the possible states for Monitoring.

Enumerator
ID
SEND
FLUSH

Definition at line 32 of file DataProcessingStatus.h.

◆ OfferScore

enum struct o2::framework::OfferScore

strong

Enumerator
Enough
More
Unneeded
Unsuitable

Definition at line 26 of file ComputingQuotaOffer.h.

◆ OutputObjHandlingPolicy

enum o2::framework::OutputObjHandlingPolicy : unsigned int

Policy enum to determine OutputObj handling when writing.

Enumerator
AnalysisObject
QAObject
TransientObject
numPolicies

Definition at line 23 of file OutputObjHeader.h.

◆ OutputObjSourceType

enum o2::framework::OutputObjSourceType : unsigned int

Enumerator
OutputObjSource
HistogramRegistrySource
numTypes

Definition at line 30 of file OutputObjHeader.h.

◆ ParsingState

enum struct o2::framework::ParsingState

strong

Enumerator
IN_START
IN_PREFIX
IN_BEGIN_INDEX
IN_END_INDEX
IN_TYPE
IN_INT_VALUE
IN_UINT64_VALUE
IN_FLOAT_VALUE
IN_STRING_VALUE
IN_TIMESTAMP
IN_TAGS
IN_EXIT
IN_ERROR

Definition at line 31 of file DeviceMetricsHelper.cxx.

◆ ProcessingStateId

enum struct o2::framework::ProcessingStateId : short

strong

Helper struct to define some known states.

Enumerator
DUMMY_STATE
DATA_QUERIES
OUTPUT_MATCHERS
CONTEXT_VARIABLES_BASE
DATA_RELAYER_BASE

Definition at line 35 of file DataProcessingStates.h.

◆ ProcessingStatsId

enum struct o2::framework::ProcessingStatsId : short

strong

Enumerator
ERROR_COUNT
EXCEPTION_COUNT
PENDING_INPUTS
INCOMPLETE_INPUTS
TOTAL_INPUTS
LAST_ELAPSED_TIME_MS
TOTAL_WALL_TIME_MS
LAST_PROCESSED_SIZE
TOTAL_PROCESSED_SIZE
TOTAL_SIGUSR1
CONSUMED_TIMEFRAMES
AVAILABLE_MANAGED_SHM
LAST_SLOW_METRIC_SENT_TIMESTAMP
LAST_VERY_SLOW_METRIC_SENT_TIMESTAMP
LAST_METRIC_FLUSHED_TIMESTAMP
BEGIN_ITERATION_TIMESTAMP
PERFORMED_COMPUTATIONS
LAST_REPORTED_PERFORMED_COMPUTATIONS
TOTAL_BYTES_IN
TOTAL_BYTES_OUT
LAST_MIN_LATENCY
LAST_MAX_LATENCY
TOTAL_RATE_IN_MB_S
TOTAL_RATE_OUT_MB_S
PROCESSING_RATE_HZ
MALFORMED_INPUTS
DROPPED_COMPUTATIONS
DROPPED_INCOMING_MESSAGES
RELAYED_MESSAGES
CPU_USAGE_FRACTION
ARROW_BYTES_CREATED
ARROW_BYTES_DESTROYED
ARROW_MESSAGES_CREATED
ARROW_MESSAGES_DESTROYED
ARROW_BYTES_EXPIRED
RESOURCE_OFFER_EXPIRED
SHM_OFFER_BYTES_CONSUMED
RESOURCES_MISSING
RESOURCES_INSUFFICIENT
RESOURCES_SATISFACTORY
AVAILABLE_MANAGED_SHM_BASE

Definition at line 27 of file DataProcessingStats.h.

◆ QueryBuilderState

enum o2::framework::QueryBuilderState

Enumerator
IN_BEGIN_QUERY
IN_BEGIN_MATCHER
IN_BEGIN_BINDING
IN_END_BINDING
IN_BEGIN_ORIGIN
IN_END_ORIGIN
IN_BEGIN_DESCRIPTION
IN_END_DESCRIPTION
IN_BEGIN_SUBSPEC
IN_END_SUBSPEC
IN_BEGIN_TIMEMODULO
IN_END_TIMEMODULO
IN_END_MATCHER
IN_END_QUERY
IN_STRING
IN_NUMBER
IN_NEGATION
IN_ERROR
IN_BEGIN_ATTRIBUTES
IN_END_ATTRIBUTES
IN_BEGIN_KEY
IN_END_KEY
IN_BEGIN_VALUE
IN_END_VALUE

Definition at line 28 of file DataDescriptorQueryBuilder.cxx.

◆ QuitRequest

enum struct o2::framework::QuitRequest

strong

Kind of request we want to issue to control.

Enumerator
Me	Only quit this data processor.
All	Quit all data processor, regardless of their state.

Definition at line 29 of file ControlService.h.

◆ RateLimitingState

enum struct o2::framework::RateLimitingState

strong

Enumerator
UNKNOWN
STARTED
CHANGED
BELOW_LIMIT
NEXT_ITERATION_FROM_BELOW
ABOVE_LIMIT
EMPTY

Definition at line 55 of file ArrowSupport.cxx.

◆ ReadOpKind

enum struct o2::framework::ReadOpKind

strong

Enumerator
Unknown
Offsets
Values
Booleans
VLA

Definition at line 45 of file TTreePlugin.cxx.

◆ ServiceKind

enum struct o2::framework::ServiceKind

strong

The kind of service we are asking for.

Enumerator
DeviceSerial	A Service which is not thread safe, therefore all accesses to it must be mutexed.
DeviceGlobal	A Service which is thread safe and therefore can be used by many threads the same time without risk.
DeviceStream	A Service which is specific to a given thread in a thread pool.
DataProcessorSerial
DataProcessorGlobal
DataProcessorStream
Serial
Global
Stream

Definition at line 21 of file ServiceHandle.h.

◆ StreamingState

enum struct o2::framework::StreamingState

strong

enumeration representing the current state of a given device.

Enumerator
Streaming	Data is being processed.
EndOfStreaming	End of streaming requested, but not notified.
Idle	End of streaming notified.

Definition at line 19 of file DeviceStateEnums.h.

◆ TerminationPolicy

enum struct o2::framework::TerminationPolicy

strong

These are the possible actions we can do when a workflow is deemed complete (e.g. when we are done reading from file) or when a data processor has an error.

Enumerator
QUIT
WAIT
RESTART

Definition at line 21 of file ProcessingPolicies.h.

◆ TransitionHandlingState

enum struct o2::framework::TransitionHandlingState

strong

Enumerator
NoTransition	No pending transitions.
Requested	A transition was notified to be requested.
Expired	A transition needs to be fullfilled ASAP.

Definition at line 28 of file DeviceStateEnums.h.

◆ VariantType

enum class o2::framework::VariantType : int

strong

Enumerator
Int
Int64
Float
Double
String
Bool
ArrayInt
ArrayFloat
ArrayDouble
ArrayBool
ArrayString
Array2DInt
Array2DFloat
Array2DDouble
LabeledArrayInt
LabeledArrayFloat
LabeledArrayDouble
UInt8
UInt16
UInt32
UInt64
Int8
Int16
LabeledArrayString
Empty
Dict
Unknown

Definition at line 30 of file Variant.h.

◆ WebSocketFrameKind

enum struct o2::framework::WebSocketFrameKind

strong

Enumerator
Tiny
Short
Huge

Definition at line 93 of file HTTPParser.h.

◆ WebSocketOpCode

enum struct o2::framework::WebSocketOpCode : uint8_t

strong

Enumerator
Continuation
Text
Binary
Close
Ping
Pong

Definition at line 99 of file HTTPParser.h.

◆ WorkflowParsingState

enum struct o2::framework::WorkflowParsingState : int

strong

Enumerator
Valid
Empty

Definition at line 151 of file WorkflowHelpers.h.

Function Documentation

◆ attribute()

struct o2::framework::__attribute__ ( (__packed__) )

Definition at line 1 of file HTTPParser.h.

◆ adaptAnalysisTask()

template<typename T , typename... Args>

DataProcessorSpec o2::framework::adaptAnalysisTask	(	ConfigContext const &	ctx,
		Args &&...	args
	)

Adaptor to make an AlgorithmSpec from a o2::framework::Task

make sure options and configurables are set before expression infos are created

extract conditions and append them as inputs

parse process functions defined by corresponding configurables

update configurables in filters and partitions

create for filters gandiva trees matched to schemas and store the pointers into expressionInfos

Definition at line 509 of file AnalysisTask.h.

◆ adaptFromTask()

template<typename T , typename... Args>

AlgorithmSpec o2::framework::adaptFromTask ( Args &&... args )

Adaptor to make an AlgorithmSpec from a o2::framework::Task

Definition at line 59 of file Task.h.

◆ adaptStateful()

template<typename LAMBDA >

AlgorithmSpec::InitCallback o2::framework::adaptStateful ( LAMBDA l )

Definition at line 236 of file AlgorithmSpec.h.

◆ adaptStatefulF()

template<typename... CONTEXTELEMENT>

AlgorithmSpec::InitCallback o2::framework::adaptStatefulF ( std::function< AlgorithmSpec::ProcessCallback(CONTEXTELEMENT &...)> callback )

Definition at line 189 of file AlgorithmSpec.h.

◆ adaptStateless()

template<typename LAMBDA >

AlgorithmSpec::ProcessCallback o2::framework::adaptStateless ( LAMBDA l )

This helper allows us to create a process callback without having to use a context object from which the services and the inputs hang, but it simply uses templates magic to extract them from the context itself and pass them by reference. So instead of writing:

AlgorithmSpec{[](ProcessingContext& ctx) { ctx.inputs().get<int>("someInt"); // do something with the inputs } }

you can simply do:

AlgorithmSpec{[](InputRecord& inputs){ inputs.get<int>("someInt"); }}

and if you have C++20 enabled you can also do:

AlgorithmSpec{[](Input<"someInt", int> someInt){ someInt.value; // do something with the inputs } Notice you can specify in any order any of InputRecord, DataAllocator, ConfigParamRegistry or any of the services which are usually hanging from the ServiceRegistry, e.g. ControlService.

Definition at line 229 of file AlgorithmSpec.h.

◆ adaptStatelessF()

template<typename... CONTEXTELEMENT>

AlgorithmSpec::ProcessCallback o2::framework::adaptStatelessF ( std::function< void(CONTEXTELEMENT &...)> callback )

Definition at line 181 of file AlgorithmSpec.h.

◆ adaptStatelessP()

template<typename R , typename... ARGS>

AlgorithmSpec::ProcessCallback o2::framework::adaptStatelessP ( R(*)(ARGS...) callback )

Definition at line 197 of file AlgorithmSpec.h.

◆ addLabelToSchema()

void o2::framework::addLabelToSchema	(	std::shared_ptr< arrow::Schema > &	schema,
		const char *	label
	)

Definition at line 51 of file TableBuilder.cxx.

◆ adoptTask()

template<typename T >

AlgorithmSpec o2::framework::adoptTask ( std::shared_ptr< T > task )

Definition at line 89 of file Task.h.

◆ appendForSending()

void o2::framework::appendForSending	(	fair::mq::Device &	device,
		o2::header::Stack &&	headerStack,
		size_t	timeSliceID,
		fair::mq::MessagePtr &&	payloadMessage,
		OutputSpec const &	spec,
		fair::mq::Parts &	messageCache,
		ChannelRetriever &	channelRetriever
	)

append a header/payload part to multipart message for aggregate sending, a channel retriever callback is required to get the associated fair::mq::Channel

Definition at line 180 of file ExternalFairMQDeviceProxy.cxx.

◆ array2DFromBranch()

template<typename T >

template o2::framework::Array2D< double > o2::framework::array2DFromBranch< double > ( boost::property_tree::ptree const & ptree )

Definition at line 117 of file VariantPropertyTreeHelpers.h.

◆ array2DToBranch()

template<typename T >

boost::property_tree::ptree o2::framework::array2DToBranch ( Array2D< T > && array )

Definition at line 69 of file VariantPropertyTreeHelpers.h.

◆ arrowTypeFromROOT()

auto o2::framework::arrowTypeFromROOT	(	EDataType	type,
		int	size
	)

Definition at line 837 of file TTreePlugin.cxx.

◆ basicArray2DFromBranch()

template<typename T >

Array2D< T > o2::framework::basicArray2DFromBranch ( boost::property_tree::ptree const & branch )

Definition at line 94 of file VariantPropertyTreeHelpers.h.

◆ basicArray2DToBranch()

template<typename T >

boost::property_tree::ptree o2::framework::basicArray2DToBranch ( Array2D< T > && array )

Definition at line 53 of file VariantPropertyTreeHelpers.h.

◆ basicROOTTypeFromArrow()

auto o2::framework::basicROOTTypeFromArrow ( arrow::Type::type id )

Definition at line 76 of file TableTreeHelpers.cxx.

◆ basicVectorFromBranch()

template<typename T >

template std::vector< double > o2::framework::basicVectorFromBranch< double > ( boost::property_tree::ptree const & branch )

Definition at line 77 of file VariantPropertyTreeHelpers.h.

◆ basicVectorToBranch() [1/2]

template<typename T >

boost::property_tree::ptree o2::framework::basicVectorToBranch ( std::vector< T > && values )

Definition at line 33 of file VariantPropertyTreeHelpers.h.

◆ basicVectorToBranch() [2/2]

template<typename T >

boost::property_tree::ptree o2::framework::basicVectorToBranch	(	T *	values,
		size_t	size
	)

Definition at line 21 of file VariantPropertyTreeHelpers.h.

◆ brace_constructible_size()

template<typename T >

consteval auto o2::framework::brace_constructible_size ( auto... Members )

Definition at line 138 of file StructToTuple.h.

◆ calculateAvailableSharedMemory()

uint64_t o2::framework::calculateAvailableSharedMemory ( ServiceRegistryRef registry )

Definition at line 100 of file ArrowSupport.cxx.

◆ call_if_defined()

template<typename T , typename TDefined >

void o2::framework::call_if_defined ( TDefined && onDefined )

Definition at line 56 of file CheckTypes.h.

◆ call_if_defined_forward()

template<typename T , typename TDefined >

T o2::framework::call_if_defined_forward ( TDefined && onDefined )

Definition at line 62 of file CheckTypes.h.

◆ call_if_defined_full()

template<typename T , typename TDefined , typename TUndefined >

void o2::framework::call_if_defined_full	(	TDefined &&	onDefined,
		TUndefined &&	onUndefined
	)

Helper which will invoke onDefined if the type T is actually available or onUndefined if the type T is a forward declaration. Can be used to check for existence or not of a given type.

Definition at line 33 of file CheckTypes.h.

◆ call_if_defined_full_forward()

template<typename T , typename TDefined , typename TUndefined >

T o2::framework::call_if_defined_full_forward	(	TDefined &&	onDefined,
		TUndefined &&	onUndefined
	)

Helper which will invoke onDefined if the type T is actually available or onUndefined if the type T is a forward declaration. Can be used to check for existence or not of a given type.

Definition at line 46 of file CheckTypes.h.

◆ cannotBuildAnArray()

void o2::framework::cannotBuildAnArray ( )

Definition at line 23 of file IndexBuilderHelpers.cxx.

◆ ccdbMetadataSpec()

ConfigParamSpec o2::framework::ccdbMetadataSpec	(	std::string const &	key,
		std::string const &	defaultValue
	)

Definition at line 34 of file CCDBParamSpec.cxx.

◆ ccdbParamSpec() [1/2]

std::vector< ConfigParamSpec > o2::framework::ccdbParamSpec	(	std::string const &	path,
		int	runDependent,
		std::vector< CCDBMetadata >	metadata = `{}`,
		int	qrate = `0`
	)

Definition at line 48 of file CCDBParamSpec.cxx.

◆ ccdbParamSpec() [2/2]

std::vector< ConfigParamSpec > o2::framework::ccdbParamSpec	(	std::string const &	path,
		std::vector< CCDBMetadata >	metadata = `{}`,
		int	qrate = `0`
	)

Helper to create an InputSpec which will read from a CCDB Notice that those input specs have some convetions for their metadata:

ccdb-path: is the path in CCDB for the entry ccdb-run-dependent: is a boolean flag to indicate if the entry is run dependent ccdb-metadata-<key>: is a list of metadata to be added to the query, where key is the metadata key

Definition at line 43 of file CCDBParamSpec.cxx.

◆ ccdbPathSpec()

ConfigParamSpec o2::framework::ccdbPathSpec ( std::string const & path )

Definition at line 19 of file CCDBParamSpec.cxx.

◆ ccdbQueryRateSpec()

ConfigParamSpec o2::framework::ccdbQueryRateSpec ( int r )

Definition at line 29 of file CCDBParamSpec.cxx.

◆ ccdbRunDependent()

ConfigParamSpec o2::framework::ccdbRunDependent ( int defaultValue = 1 )

Definition at line 24 of file CCDBParamSpec.cxx.

◆ channelParamSpec()

std::vector< ConfigParamSpec > o2::framework::channelParamSpec ( std::string const & name )

Definition at line 15 of file ChannelParamSpec.cxx.

◆ check()

void o2::framework::check	(	const std::vector< std::string > &	arguments,
		const std::vector< ConfigParamSpec > &	workflowOptions,
		const std::vector< DeviceSpec > &	deviceSpecs,
		CheckMatrix &	matrix
	)

Definition at line 55 of file test_DeviceSpecHelpers.cxx.

◆ clean_all_runtime_errors()

void o2::framework::clean_all_runtime_errors ( )

Definition at line 43 of file RuntimeError.cxx.

◆ clean_runtime_error()

void o2::framework::clean_runtime_error ( int i )

Definition at line 50 of file RuntimeError.cxx.

◆ close_client_websocket()

void o2::framework::close_client_websocket ( uv_handle_t * stream )

Definition at line 387 of file DPLWebSocket.cxx.

◆ concatenate_pack() [1/2]

template<typename P1 , typename P2 , typename... Ps>

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

constexpr

Definition at line 84 of file Pack.h.

◆ concatenate_pack() [2/2]

template<typename... Args1, typename... Args2>

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

constexpr

Templates for manipulating type lists in pack (see https://codereview.stackexchange.com/questions/201209/filter-template-meta-function/201222#201222) Example of use: template<typename T> struct is_not_double: std::true_type{}; template<> struct is_not_double<double>: std::false_type{}; The following will return a pack, excluding double filtered_pack<is_not_double, double, int, char, float*, double, char*, double>()

Definition at line 78 of file Pack.h.

◆ concatenate_pack_unique() [1/3]

template<typename P1 >

constexpr auto o2::framework::concatenate_pack_unique ( P1 p1 )

constexpr

Definition at line 307 of file Pack.h.

◆ concatenate_pack_unique() [2/3]

template<typename P1 , typename P2 , typename... Ps>

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

constexpr

Definition at line 313 of file Pack.h.

◆ concatenate_pack_unique() [3/3]

template<typename... Args1, typename... Args2>

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

constexpr

Definition at line 300 of file Pack.h.

◆ ConfigParamRegistry::get< Array2D< std::string > >()

template Array2D< std::string > o2::framework::ConfigParamRegistry::get< Array2D< std::string > > ( const char * key ) const

◆ ConfigParamRegistry::get< LabeledArray< std::string > >()

template LabeledArray< std::string > o2::framework::ConfigParamRegistry::get< LabeledArray< std::string > > ( const char * key ) const

◆ ConfigParamRegistry::get< std::string >()

template std::string o2::framework::ConfigParamRegistry::get< std::string > ( const char * key ) const

◆ ConfigParamRegistry::get< std::vector< double > >()

template std::vector< double > o2::framework::ConfigParamRegistry::get< std::vector< double > > ( const char * key ) const

◆ ConfigParamRegistry::get< std::vector< float > >()

template std::vector< float > o2::framework::ConfigParamRegistry::get< std::vector< float > > ( const char * key ) const

◆ ConfigParamRegistry::get< std::vector< int > >()

template std::vector< int > o2::framework::ConfigParamRegistry::get< std::vector< int > > ( const char * key ) const

◆ ConfigParamRegistry::get< std::vector< std::string > >()

template std::vector< std::string > o2::framework::ConfigParamRegistry::get< std::vector< std::string > > ( const char * key ) const

◆ convertTimestamp()

unsigned long o2::framework::convertTimestamp ( const std::chrono::time_point< std::chrono::system_clock > & timestamp )

inline

Definition at line 41 of file DPLMonitoringBackend.cxx.

◆ count_non_void_pack()

template<typename... Ts>

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

Definition at line 106 of file Pack.h.

◆ createDefaultIndices()

std::vector< MetricIndices > o2::framework::createDefaultIndices ( std::vector< DeviceMetricsInfo > & allDevicesMetrics )

Definition at line 81 of file ArrowSupport.cxx.

◆ cutString()

std::string o2::framework::cutString ( std::string && str )

Definition at line 180 of file ASoA.cxx.

◆ dataDeps()

bool o2::framework::dataDeps	(	DataProcessorSpec const &	a,
		DataProcessorSpec const &	b
	)

Return true if a depends on b, i.e. if any of the inputs of a is satisfied by any of the outputs of b.

Definition at line 56 of file TopologyPolicy.cxx.

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [1/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	bool	,
		ArrayBool
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [2/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	double	,
		Array2DDouble
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [3/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	double	,
		ArrayDouble
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [4/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	double	,
		LabeledArrayDouble
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [5/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	float	,
		Array2DFloat
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [6/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	float	,
		ArrayFloat
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [7/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	float	,
		LabeledArrayFloat
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [8/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	int	,
		Array2DInt
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [9/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	int	,
		ArrayInt
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [10/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	int	,
		LabeledArrayInt
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [11/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	std::string	,
		ArrayString
	)

◆ DECLARE_VARIANT_ARRAY_ELEMENT_TYPE() [12/12]

o2::framework::DECLARE_VARIANT_ARRAY_ELEMENT_TYPE	(	std::string	,
		LabeledArrayString
	)

◆ DECLARE_VARIANT_TRAIT() [1/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	Array2D< double >	,
		Array2DDouble
	)

◆ DECLARE_VARIANT_TRAIT() [2/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	Array2D< float >	,
		Array2DFloat
	)

◆ DECLARE_VARIANT_TRAIT() [3/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	Array2D< int >	,
		Array2DInt
	)

◆ DECLARE_VARIANT_TRAIT() [4/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	bool *	,
		ArrayBool
	)

◆ DECLARE_VARIANT_TRAIT() [5/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	bool	,
		Bool
	)

◆ DECLARE_VARIANT_TRAIT() [6/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	char *	,
		String
	)

◆ DECLARE_VARIANT_TRAIT() [7/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	const char *	,
		String
	)

◆ DECLARE_VARIANT_TRAIT() [8/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	double *	,
		ArrayDouble
	)

◆ DECLARE_VARIANT_TRAIT() [9/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	double	,
		Double
	)

◆ DECLARE_VARIANT_TRAIT() [10/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	float *	,
		ArrayFloat
	)

◆ DECLARE_VARIANT_TRAIT() [11/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	float	,
		Float
	)

◆ DECLARE_VARIANT_TRAIT() [12/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	int *	,
		ArrayInt
	)

◆ DECLARE_VARIANT_TRAIT() [13/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	int	,
		Int
	)

◆ DECLARE_VARIANT_TRAIT() [14/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	int16_t	,
		Int16
	)

◆ DECLARE_VARIANT_TRAIT() [15/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	int8_t	,
		Int8
	)

◆ DECLARE_VARIANT_TRAIT() [16/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	LabeledArray< double >	,
		LabeledArrayDouble
	)

◆ DECLARE_VARIANT_TRAIT() [17/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	LabeledArray< float >	,
		LabeledArrayFloat
	)

◆ DECLARE_VARIANT_TRAIT() [18/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	LabeledArray< int >	,
		LabeledArrayInt
	)

◆ DECLARE_VARIANT_TRAIT() [19/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	LabeledArray< std::string >	,
		LabeledArrayString
	)

◆ DECLARE_VARIANT_TRAIT() [20/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	long int	,
		Int64
	)

◆ DECLARE_VARIANT_TRAIT() [21/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	long long int	,
		Int64
	)

◆ DECLARE_VARIANT_TRAIT() [22/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::string *	,
		ArrayString
	)

◆ DECLARE_VARIANT_TRAIT() [23/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::string	,
		String
	)

◆ DECLARE_VARIANT_TRAIT() [24/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::string_view	,
		String
	)

◆ DECLARE_VARIANT_TRAIT() [25/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::vector< bool >	,
		ArrayBool
	)

◆ DECLARE_VARIANT_TRAIT() [26/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::vector< double >	,
		ArrayDouble
	)

◆ DECLARE_VARIANT_TRAIT() [27/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::vector< float >	,
		ArrayFloat
	)

◆ DECLARE_VARIANT_TRAIT() [28/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::vector< int >	,
		ArrayInt
	)

◆ DECLARE_VARIANT_TRAIT() [29/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	std::vector< std::string >	,
		ArrayString
	)

◆ DECLARE_VARIANT_TRAIT() [30/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	uint16_t	,
		UInt16
	)

◆ DECLARE_VARIANT_TRAIT() [31/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	uint32_t	,
		UInt32
	)

◆ DECLARE_VARIANT_TRAIT() [32/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	uint8_t	,
		UInt8
	)

◆ DECLARE_VARIANT_TRAIT() [33/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	unsigned long int	,
		UInt64
	)

◆ DECLARE_VARIANT_TRAIT() [34/34]

o2::framework::DECLARE_VARIANT_TRAIT	(	unsigned long long int	,
		UInt64
	)

◆ DECLARE_VARIANT_TYPE() [1/24]

o2::framework::DECLARE_VARIANT_TYPE	(	Array2D< double >	,
		Array2DDouble
	)

◆ DECLARE_VARIANT_TYPE() [2/24]

o2::framework::DECLARE_VARIANT_TYPE	(	Array2D< float >	,
		Array2DFloat
	)

◆ DECLARE_VARIANT_TYPE() [3/24]

o2::framework::DECLARE_VARIANT_TYPE	(	Array2D< int >	,
		Array2DInt
	)

◆ DECLARE_VARIANT_TYPE() [4/24]

o2::framework::DECLARE_VARIANT_TYPE	(	bool *	,
		ArrayBool
	)

◆ DECLARE_VARIANT_TYPE() [5/24]

o2::framework::DECLARE_VARIANT_TYPE	(	bool	,
		Bool
	)

◆ DECLARE_VARIANT_TYPE() [6/24]

o2::framework::DECLARE_VARIANT_TYPE	(	const char *	,
		String
	)

◆ DECLARE_VARIANT_TYPE() [7/24]

o2::framework::DECLARE_VARIANT_TYPE	(	double *	,
		ArrayDouble
	)

◆ DECLARE_VARIANT_TYPE() [8/24]

o2::framework::DECLARE_VARIANT_TYPE	(	double	,
		Double
	)

◆ DECLARE_VARIANT_TYPE() [9/24]

o2::framework::DECLARE_VARIANT_TYPE	(	float *	,
		ArrayFloat
	)

◆ DECLARE_VARIANT_TYPE() [10/24]

o2::framework::DECLARE_VARIANT_TYPE	(	float	,
		Float
	)

◆ DECLARE_VARIANT_TYPE() [11/24]

o2::framework::DECLARE_VARIANT_TYPE	(	int *	,
		ArrayInt
	)

◆ DECLARE_VARIANT_TYPE() [12/24]

o2::framework::DECLARE_VARIANT_TYPE	(	int	,
		Int
	)

◆ DECLARE_VARIANT_TYPE() [13/24]

o2::framework::DECLARE_VARIANT_TYPE	(	int16_t	,
		Int16
	)

◆ DECLARE_VARIANT_TYPE() [14/24]

o2::framework::DECLARE_VARIANT_TYPE	(	int64_t	,
		Int64
	)

◆ DECLARE_VARIANT_TYPE() [15/24]

o2::framework::DECLARE_VARIANT_TYPE	(	int8_t	,
		Int8
	)

◆ DECLARE_VARIANT_TYPE() [16/24]

o2::framework::DECLARE_VARIANT_TYPE	(	LabeledArray< double >	,
		LabeledArrayDouble
	)

◆ DECLARE_VARIANT_TYPE() [17/24]

o2::framework::DECLARE_VARIANT_TYPE	(	LabeledArray< float >	,
		LabeledArrayFloat
	)

◆ DECLARE_VARIANT_TYPE() [18/24]

o2::framework::DECLARE_VARIANT_TYPE	(	LabeledArray< int >	,
		LabeledArrayInt
	)

◆ DECLARE_VARIANT_TYPE() [19/24]

o2::framework::DECLARE_VARIANT_TYPE	(	LabeledArray< std::string >	,
		LabeledArrayString
	)

◆ DECLARE_VARIANT_TYPE() [20/24]

o2::framework::DECLARE_VARIANT_TYPE	(	std::string *	,
		ArrayString
	)

◆ DECLARE_VARIANT_TYPE() [21/24]

o2::framework::DECLARE_VARIANT_TYPE	(	uint16_t	,
		UInt16
	)

◆ DECLARE_VARIANT_TYPE() [22/24]

o2::framework::DECLARE_VARIANT_TYPE	(	uint32_t	,
		UInt32
	)

◆ DECLARE_VARIANT_TYPE() [23/24]

o2::framework::DECLARE_VARIANT_TYPE	(	uint64_t	,
		UInt64
	)

◆ DECLARE_VARIANT_TYPE() [24/24]

o2::framework::DECLARE_VARIANT_TYPE	(	uint8_t	,
		UInt8
	)

◆ DECLAREEXT() [1/31]

o2::framework::DECLAREEXT ( StepTHnF )

◆ DECLAREEXT() [2/31]

o2::framework::DECLAREEXT ( TH1C )

◆ DECLAREEXT() [3/31]

o2::framework::DECLAREEXT ( TH1D )

◆ DECLAREEXT() [4/31]

o2::framework::DECLAREEXT ( TH1F )

◆ DECLAREEXT() [5/31]

o2::framework::DECLAREEXT ( TH1I )

◆ DECLAREEXT() [6/31]

o2::framework::DECLAREEXT ( TH1S )

◆ DECLAREEXT() [7/31]

o2::framework::DECLAREEXT ( TH2C )

◆ DECLAREEXT() [8/31]

o2::framework::DECLAREEXT ( TH2D )

◆ DECLAREEXT() [9/31]

o2::framework::DECLAREEXT ( TH2F )

◆ DECLAREEXT() [10/31]

o2::framework::DECLAREEXT ( TH2I )

◆ DECLAREEXT() [11/31]

o2::framework::DECLAREEXT ( TH2S )

◆ DECLAREEXT() [12/31]

o2::framework::DECLAREEXT ( TH3C )

◆ DECLAREEXT() [13/31]

o2::framework::DECLAREEXT ( TH3D )

◆ DECLAREEXT() [14/31]

o2::framework::DECLAREEXT ( TH3F )

◆ DECLAREEXT() [15/31]

o2::framework::DECLAREEXT ( TH3I )

◆ DECLAREEXT() [16/31]

o2::framework::DECLAREEXT ( TH3S )

◆ DECLAREEXT() [17/31]

o2::framework::DECLAREEXT ( THnC )

◆ DECLAREEXT() [18/31]

o2::framework::DECLAREEXT ( THnD )

◆ DECLAREEXT() [19/31]

o2::framework::DECLAREEXT ( THnF )

◆ DECLAREEXT() [20/31]

o2::framework::DECLAREEXT ( THnI )

◆ DECLAREEXT() [21/31]

o2::framework::DECLAREEXT ( THnL )

◆ DECLAREEXT() [22/31]

o2::framework::DECLAREEXT ( THnS )

◆ DECLAREEXT() [23/31]

o2::framework::DECLAREEXT ( THnSparseC )

◆ DECLAREEXT() [24/31]

o2::framework::DECLAREEXT ( THnSparseD )

◆ DECLAREEXT() [25/31]

o2::framework::DECLAREEXT ( THnSparseF )

◆ DECLAREEXT() [26/31]

o2::framework::DECLAREEXT ( THnSparseI )

◆ DECLAREEXT() [27/31]

o2::framework::DECLAREEXT ( THnSparseL )

◆ DECLAREEXT() [28/31]

o2::framework::DECLAREEXT ( THnSparseS )

◆ DECLAREEXT() [29/31]

o2::framework::DECLAREEXT ( TProfile )

◆ DECLAREEXT() [30/31]

o2::framework::DECLAREEXT ( TProfile2D )

◆ DECLAREEXT() [31/31]

o2::framework::DECLAREEXT ( TProfile3D )

◆ decode_websocket()

void o2::framework::decode_websocket	(	char *	src,
		size_t	size,
		WebSocketHandler &	handler
	)

Decoder for websocket data. For now we assume that the frame was not split. However multiple frames might be present.

Definition at line 109 of file HTTPParser.cxx.

◆ defaultConditionBackend()

std::string o2::framework::defaultConditionBackend ( )

Definition at line 132 of file WorkflowHelpers.cxx.

◆ defaultConditionQueryRate()

int o2::framework::defaultConditionQueryRate ( )

Definition at line 146 of file WorkflowHelpers.cxx.

◆ defaultConditionQueryRateMultiplier()

int o2::framework::defaultConditionQueryRateMultiplier ( )

Definition at line 152 of file WorkflowHelpers.cxx.

◆ defaultOutputProxyChannelSelector()

std::string o2::framework::defaultOutputProxyChannelSelector	(	InputSpec const &	input,
		const std::unordered_map< std::string, std::vector< fair::mq::Channel > > &	channels
	)

Default way to select an output channel for multi-output proxy.

Definition at line 906 of file ExternalFairMQDeviceProxy.cxx.

◆ DEFINE_DPL_PLUGIN_INSTANCE() [1/2]

DEFINE_DPL_PLUGINS_BEGIN o2::framework::DEFINE_DPL_PLUGIN_INSTANCE	(	RNTupleObjectReadingImplementation	,
		RootObjectReadingImplementation
	)

◆ DEFINE_DPL_PLUGIN_INSTANCE() [2/2]

DEFINE_DPL_PLUGINS_BEGIN o2::framework::DEFINE_DPL_PLUGIN_INSTANCE	(	TTreeObjectReadingImplementation	,
		RootObjectReadingImplementation
	)

◆ doSendOldestPossibleTimeframe()

void o2::framework::doSendOldestPossibleTimeframe	(	ServiceRegistryRef	ref,
		fair::mq::TransportFactory *	transport,
		ChannelIndex	index,
		SendingPolicy::SendingCallback const &	callback,
		size_t	timeslice
	)

Definition at line 46 of file DataProcessingHelpers.cxx.

◆ doWriteBatch()

void o2::framework::doWriteBatch	(	std::shared_ptr< FairMQResizableBuffer >	b,
		arrow::RecordBatch *	batch
	)

Definition at line 214 of file DataAllocator.cxx.

◆ doWriteTable()

void o2::framework::doWriteTable	(	std::shared_ptr< FairMQResizableBuffer >	b,
		arrow::Table *	table
	)

Definition at line 167 of file DataAllocator.cxx.

◆ dplModelAdaptor() [1/2]

InjectorFunction o2::framework::dplModelAdaptor	(	std::vector< OutputSpec > const &	specs,
		bool	throwOnUnmatchedInputs
	)

inline

legacy function

Definition at line 90 of file ExternalFairMQDeviceProxy.h.

◆ dplModelAdaptor() [2/2]

InjectorFunction o2::framework::dplModelAdaptor	(	std::vector< OutputSpec > const &	specs = `{{header::gDataOriginAny, header::gDataDescriptionAny}}`,
		DPLModelAdapterConfig	config = `DPLModelAdapterConfig{}`
	)

This is to be used when the input data is already formatted like DPL expects it, i.e. with the DataProcessingHeader in the header stack The list of specs is used as a filter list, all incoming data matching an entry in the list will be send through the corresponding channel

Definition at line 438 of file ExternalFairMQDeviceProxy.cxx.

◆ dumpDeviceSpec2O2Control()

void o2::framework::dumpDeviceSpec2O2Control	(	std::string	workflowName,
		std::vector< DeviceSpec > const &	specs,
		std::vector< DeviceExecution > const &	executions,
		CommandInfo const &	commandInfo
	)

Dumps the AliECS compatible workflow and task templates for a DPL workflow.

Dumps the AliECS compatible workflow (WFT) and task templates (TT) for a DPL workflow. The current procedure to obtain working templates:

Build the project(s)
Enter the environment and go to ControlWorkflows local repository.
Run the DPL workflow(s) with the argument --o2-control <workflow-name>. The WFT will be created in the "workflows" directory and, analogously, TTs will be put in "tasks". It can be included by a mother workflow at the deployment time.
Replace arguments with templates if needed.
Commit, push, test, merge to master.

◆ dumpTask()

void o2::framework::dumpTask	(	std::ostream &	dumpOut,
		const DeviceSpec &	spec,
		const DeviceExecution &	execution,
		std::string	taskName,
		std::string	indLevel
	)

Dumps only one task.

◆ dumpWorkflow()

void o2::framework::dumpWorkflow	(	std::ostream &	dumpOut,
		const std::vector< DeviceSpec > &	specs,
		const std::vector< DeviceExecution > &	executions,
		const CommandInfo &	commandInfo,
		std::string	workflowName,
		std::string	indLevel
	)

Dumps only the workflow file.

◆ emptyDict()

Variant o2::framework::emptyDict ( )

inline

Definition at line 407 of file Variant.h.

◆ encode_websocket_frames()

void o2::framework::encode_websocket_frames	(	std::vector< uv_buf_t > &	outputs,
		char const *	src,
		size_t	size,
		WebSocketOpCode	opcode,
		uint32_t	mask
	)

Encodes the buffer src which is size long to a number of buffers suitable to be sent via libuv. If binary is provided the binary bit is set. If mask is non zero, payload will be xored with the mask, as required by the WebSockets RFC

Definition at line 48 of file HTTPParser.cxx.

◆ encode_websocket_handshake_reply()

std::string o2::framework::encode_websocket_handshake_reply ( char const * nonce )

Encodes the server reply for a given websocket connection nonce the nonce of the request.

Definition at line 217 of file HTTPParser.cxx.

◆ encode_websocket_handshake_request()

std::string o2::framework::encode_websocket_handshake_request	(	const char *	path,
		const char *	protocol,
		int	version,
		char const *	nonce,
		std::vector< std::pair< std::string, std::string > >	headers = `{}`
	)

Encodes the request handshake for a given path / protocol / version. path is the path of the websocket endpoint protocol is the protocol required for the websocket connection version is the protocol version nonce is a unique randomly selected 16-byte value that has been base64-encoded. headers with extra headers to be added to the request

Definition at line 189 of file HTTPParser.cxx.

◆ epnProcessReporting()

CallbacksPolicy o2::framework::epnProcessReporting ( )

Definition at line 46 of file CallbacksPolicy.cxx.

◆ error_from_ref()

RuntimeError & o2::framework::error_from_ref ( RuntimeErrorRef ref )

Definition at line 55 of file RuntimeError.cxx.

◆ expendableDataDeps()

bool o2::framework::expendableDataDeps	(	DataProcessorSpec const &	a,
		DataProcessorSpec const &	b
	)

If there is an actual dependency between a and b, we return true.

Definition at line 72 of file TopologyPolicy.cxx.

◆ EXPIMPL() [1/31]

o2::framework::EXPIMPL ( StepTHnF )

◆ EXPIMPL() [2/31]

o2::framework::EXPIMPL ( TH1C )

◆ EXPIMPL() [3/31]

o2::framework::EXPIMPL ( TH1D )

◆ EXPIMPL() [4/31]

o2::framework::EXPIMPL ( TH1F )

◆ EXPIMPL() [5/31]

o2::framework::EXPIMPL ( TH1I )

◆ EXPIMPL() [6/31]

o2::framework::EXPIMPL ( TH1S )

◆ EXPIMPL() [7/31]

o2::framework::EXPIMPL ( TH2C )

◆ EXPIMPL() [8/31]

o2::framework::EXPIMPL ( TH2D )

◆ EXPIMPL() [9/31]

o2::framework::EXPIMPL ( TH2F )

◆ EXPIMPL() [10/31]

o2::framework::EXPIMPL ( TH2I )

◆ EXPIMPL() [11/31]

o2::framework::EXPIMPL ( TH2S )

◆ EXPIMPL() [12/31]

o2::framework::EXPIMPL ( TH3C )

◆ EXPIMPL() [13/31]

o2::framework::EXPIMPL ( TH3D )

◆ EXPIMPL() [14/31]

o2::framework::EXPIMPL ( TH3F )

◆ EXPIMPL() [15/31]

o2::framework::EXPIMPL ( TH3I )

◆ EXPIMPL() [16/31]

o2::framework::EXPIMPL ( TH3S )

◆ EXPIMPL() [17/31]

o2::framework::EXPIMPL ( THnC )

◆ EXPIMPL() [18/31]

o2::framework::EXPIMPL ( THnD )

◆ EXPIMPL() [19/31]

o2::framework::EXPIMPL ( THnF )

◆ EXPIMPL() [20/31]

o2::framework::EXPIMPL ( THnI )

◆ EXPIMPL() [21/31]

o2::framework::EXPIMPL ( THnL )

◆ EXPIMPL() [22/31]

o2::framework::EXPIMPL ( THnS )

◆ EXPIMPL() [23/31]

o2::framework::EXPIMPL ( THnSparseC )

◆ EXPIMPL() [24/31]

o2::framework::EXPIMPL ( THnSparseD )

◆ EXPIMPL() [25/31]

o2::framework::EXPIMPL ( THnSparseF )

◆ EXPIMPL() [26/31]

o2::framework::EXPIMPL ( THnSparseI )

◆ EXPIMPL() [27/31]

o2::framework::EXPIMPL ( THnSparseL )

◆ EXPIMPL() [28/31]

o2::framework::EXPIMPL ( THnSparseS )

◆ EXPIMPL() [29/31]

o2::framework::EXPIMPL ( TProfile )

◆ EXPIMPL() [30/31]

o2::framework::EXPIMPL ( TProfile2D )

◆ EXPIMPL() [31/31]

o2::framework::EXPIMPL ( TProfile3D )

◆ extractLabels()

std::pair< std::vector< std::string >, std::vector< std::string > > o2::framework::extractLabels ( boost::property_tree::ptree const & tree )

Definition at line 233 of file Variant.cxx.

◆ extractMatcherInfo()

MatcherInfo o2::framework::extractMatcherInfo ( DataDescriptorMatcher const & top )

Definition at line 321 of file DataSpecUtils.cxx.

◆ FFL()

template<typename F >

memfun_type< decltype(&F::operator())>::type o2::framework::FFL ( F const & func )

Funtion From Lambda. Helper to create an std::function from a lambda and therefore being able to use the std::function type for template matching.

Returns: an std::function from a lambda (or anything actually callable). This allows doing further template matching tricks to extract the arguments of the function.

Definition at line 56 of file FunctionalHelpers.h.

◆ fillPages()

template<typename RDH , typename Container >

void o2::framework::fillPages ( Container & buffer )

Definition at line 25 of file test_RawParser.cxx.

◆ filter_pack() [1/2]

template<template< typename > typename Condition, typename Result , typename T , typename... Ts>

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

constexpr

Definition at line 191 of file Pack.h.

◆ filter_pack() [2/2]

template<template< typename > typename Condition, typename Result >

constexpr auto o2::framework::filter_pack	(	Result	result,
		pack<>
	)

constexpr

Select only the items of a pack which match Condition.

Definition at line 185 of file Pack.h.

◆ findBestCandidate()

std::string o2::framework::findBestCandidate	(	const std::string &	candidate,
		const LogicalChannelsMap &	map
	)

Definition at line 58 of file DeviceSpec.cxx.

◆ formatExternalChannelConfiguration() [1/2]

std::string o2::framework::formatExternalChannelConfiguration ( InputChannelSpec const & spec )

helper method to format a configuration string for an external channel

Definition at line 58 of file ExternalFairMQDeviceProxy.cxx.

◆ formatExternalChannelConfiguration() [2/2]

std::string o2::framework::formatExternalChannelConfiguration ( OutputChannelSpec const & )

helper method to format a configuration string for an external channel

Definition at line 63 of file ExternalFairMQDeviceProxy.cxx.

◆ FunctionMetadata()

template<typename F >

memfun_type< decltype(&F::operator())> o2::framework::FunctionMetadata ( F const & func )

Returns: metadata associated to method or a lambda.

Definition at line 64 of file FunctionalHelpers.h.

◆ generateHist()

template<typename T >

T * o2::framework::generateHist	(	const std::string &	name,
		const std::string &	title,
		const std::size_t	nDim,
		const int	nBins[],
		const double	lowerBounds[],
		const double	upperBounds[],
		const int	nSteps
	)

Definition at line 54 of file HistogramSpec.cxx.

◆ getFDDDCSConfigProcessorSpec()

DataProcessorSpec o2::framework::getFDDDCSConfigProcessorSpec ( )

Definition at line 34 of file FDDDCSConfigProcessorSpec.h.

◆ getFDDDCSDataProcessorSpec()

DataProcessorSpec o2::framework::getFDDDCSDataProcessorSpec ( )

Definition at line 30 of file FDDDCSDataProcessorSpec.h.

◆ getFinalIndex()

auto o2::framework::getFinalIndex	(	DataHeader const &	dh,
		size_t	msgidx
	)		-> size_t

Definition at line 220 of file ExternalFairMQDeviceProxy.cxx.

◆ getFT0DCSConfigProcessorSpec()

DataProcessorSpec o2::framework::getFT0DCSConfigProcessorSpec ( )

protected

Definition at line 53 of file FT0DCSConfigProcessorSpec.h.

◆ getFT0DCSDataProcessorSpec()

DataProcessorSpec o2::framework::getFT0DCSDataProcessorSpec ( )

Definition at line 30 of file FT0DCSDataProcessorSpec.h.

◆ getFV0DCSConfigProcessorSpec()

DataProcessorSpec o2::framework::getFV0DCSConfigProcessorSpec ( )

Definition at line 34 of file FV0DCSConfigProcessorSpec.h.

◆ getFV0DCSDataProcessorSpec()

DataProcessorSpec o2::framework::getFV0DCSDataProcessorSpec ( )

Definition at line 30 of file FV0DCSDataProcessorSpec.h.

◆ getMatchingIndexNode()

template<typename G , typename A >

expressions::BindingNode o2::framework::getMatchingIndexNode ( )

Definition at line 41 of file GroupedCombinations.h.

◆ getOrbitResetTime()

auto o2::framework::getOrbitResetTime ( o2::pmr::vector< char > const & v ) -> Long64_t

Definition at line 162 of file CCDBHelpers.cxx.

◆ getRunningDevice()

DeviceSpec const & o2::framework::getRunningDevice	(	RunningDeviceRef const &	running,
		ServiceRegistryRef const &	services
	)

Definition at line 166 of file DataProcessingDevice.cxx.

◆ getTableFromFilter() [1/2]

auto o2::framework::getTableFromFilter	(	soa::is_filtered_table auto const &	table,
		soa::SelectionVector &&	selection
	)

Definition at line 607 of file AnalysisHelpers.h.

◆ getTableFromFilter() [2/2]

auto o2::framework::getTableFromFilter	(	soa::is_not_filtered_table auto const &	table,
		soa::SelectionVector &&	selection
	)

Definition at line 612 of file AnalysisHelpers.h.

◆ getTotalNumberOfBytes()

long o2::framework::getTotalNumberOfBytes ( )

Definition at line 18 of file ComputingResourceHelpers.cxx.

◆ handleRegionCallbacks()

void o2::framework::handleRegionCallbacks	(	ServiceRegistryRef	registry,
		std::vector< fair::mq::RegionInfo > &	infos
	)

Invoke the callbacks for the mPendingRegionInfos.

Definition at line 778 of file DataProcessingDevice.cxx.

◆ has_type()

template<typename T , typename... Us>

bool consteval o2::framework::has_type ( framework::pack< Us... > )

Definition at line 210 of file Pack.h.

◆ has_type_at_conditional_v()

template<template< typename, typename > typename Condition, typename T , typename... Ts>

consteval size_t o2::framework::has_type_at_conditional_v ( pack< Ts... > )

Definition at line 241 of file Pack.h.

◆ has_type_at_v()

template<typename T , typename... Ts>

consteval size_t o2::framework::has_type_at_v ( pack< Ts... > )

Definition at line 228 of file Pack.h.

◆ has_type_conditional()

template<template< typename, typename > typename Condition, typename T , typename... Us>

bool consteval o2::framework::has_type_conditional ( framework::pack< Us... > )

Definition at line 219 of file Pack.h.

◆ hasOnlyGenerated()

bool o2::framework::hasOnlyGenerated ( DeviceSpec const & spec )

Definition at line 122 of file DataProcessingDevice.cxx.

◆ hasOnlyTimers()

bool o2::framework::hasOnlyTimers ( DeviceSpec const & spec )

Definition at line 117 of file DataProcessingDevice.cxx.

◆ homogeneous_apply_refs() [1/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 9)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 179 of file StructToTuple.h.

◆ homogeneous_apply_refs() [2/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 8)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 199 of file StructToTuple.h.

◆ homogeneous_apply_refs() [3/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 7)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 219 of file StructToTuple.h.

◆ homogeneous_apply_refs() [4/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 6)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 239 of file StructToTuple.h.

◆ homogeneous_apply_refs() [5/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 5)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 259 of file StructToTuple.h.

◆ homogeneous_apply_refs() [6/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 4)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 279 of file StructToTuple.h.

◆ homogeneous_apply_refs() [7/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 3)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 299 of file StructToTuple.h.

◆ homogeneous_apply_refs() [8/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 2)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 319 of file StructToTuple.h.

◆ homogeneous_apply_refs() [9/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 1)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 339 of file StructToTuple.h.

◆ homogeneous_apply_refs() [10/10]

template<bool B = false, typename L , class T , int D = nested_brace_constructible_size<B, T>() / 10>
requires (D == 0)

auto o2::framework::homogeneous_apply_refs	(	L	l,
		T &&	object
	)

Definition at line 359 of file StructToTuple.h.

◆ incrementalConverter()

InjectorFunction o2::framework::incrementalConverter	(	OutputSpec const &	spec,
		o2::header::SerializationMethod	method,
		uint64_t	startTime,
		uint64_t	step
	)

Helper function which takes a set of inputs coming from a device, massages them so that they are valid DPL messages using

Parameters

spec	as header and sends them to the downstream components.

Definition at line 610 of file ExternalFairMQDeviceProxy.cxx.

◆ initializePartitionCaches()

void o2::framework::initializePartitionCaches	(	std::set< uint32_t > const &	hashes,
		std::shared_ptr< arrow::Schema > const &	schema,
		expressions::Filter const &	filter,
		gandiva::NodePtr &	tree,
		gandiva::FilterPtr &	gfilter
	)

Definition at line 15 of file AnalysisHelpers.cxx.

◆ injectMissingData()

void o2::framework::injectMissingData	(	fair::mq::Device &	device,
		fair::mq::Parts &	parts,
		std::vector< OutputRoute > const &	routes,
		bool	doInjectMissingData,
		unsigned int	doPrintSizes
	)

Definition at line 239 of file ExternalFairMQDeviceProxy.cxx.

◆ interleave_pack()

template<typename... Args1, typename... Args2>

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

constexpr

Definition at line 93 of file Pack.h.

◆ interleaveTuples()

template<typename... T1s, typename... T2s>

auto o2::framework::interleaveTuples	(	std::tuple< T1s... > &	t1,
		std::tuple< T2s... > &	t2
	)

Definition at line 32 of file GroupedCombinations.h.

◆ interleaveTuplesImpl()

template<typename... T1s, typename... T2s, std::size_t... Is>

auto o2::framework::interleaveTuplesImpl	(	std::tuple< T1s... > &	t1,
		std::tuple< T2s... > &	t2,
		std::index_sequence< Is... >
	)

Definition at line 26 of file GroupedCombinations.h.

◆ intersected_pack() [1/2]

template<typename P1 , typename P2 , typename... Ps>

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

constexpr

Definition at line 277 of file Pack.h.

◆ intersected_pack() [2/2]

template<typename... A1, typename... A2>

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

constexpr

Definition at line 271 of file Pack.h.

◆ isArray()

template<VariantType V>

constexpr auto o2::framework::isArray ( )

constexpr

Definition at line 59 of file Variant.h.

◆ isArray2D()

template<VariantType V>

constexpr auto o2::framework::isArray2D ( )

constexpr

Definition at line 69 of file Variant.h.

◆ isCalibrationData()

bool o2::framework::isCalibrationData ( std::unique_ptr< fair::mq::Message > & first )

Definition at line 405 of file DataRelayer.cxx.

◆ isDumpWorkflowInvocation()

bool o2::framework::isDumpWorkflowInvocation ( ConfigContext const & configcontext )

Definition at line 65 of file DPLWorkflowUtils.h.

◆ isInternalDPL()

bool o2::framework::isInternalDPL ( std::string const & name )

Definition at line 81 of file DPLWorkflowUtils.h.

◆ isIPAddress()

bool o2::framework::isIPAddress ( const std::string & address )

Definition at line 48 of file ChannelSpecHelpers.cxx.

◆ isLabeledArray()

template<VariantType V>

constexpr auto o2::framework::isLabeledArray ( )

constexpr

Definition at line 83 of file Variant.h.

◆ isLabeledArrayString()

template<VariantType V>

constexpr auto o2::framework::isLabeledArrayString ( )

constexpr

Definition at line 77 of file Variant.h.

◆ isMasterWorkflowDefinition()

bool o2::framework::isMasterWorkflowDefinition ( ConfigContext const & configcontext )

Definition at line 46 of file DPLWorkflowUtils.h.

◆ isOnlineRun()

bool o2::framework::isOnlineRun ( DataTakingContext const & dtc )

Definition at line 181 of file CCDBHelpers.cxx.

◆ isPrefix()

bool o2::framework::isPrefix	(	std::string_view	prefix,
		std::string_view	full
	)

Definition at line 83 of file CCDBHelpers.cxx.

◆ isSimpleVariant()

template<VariantType V>

constexpr auto o2::framework::isSimpleVariant ( )

constexpr

Definition at line 92 of file Variant.h.

◆ labeledArrayFromBranch()

template<typename T >

template o2::framework::LabeledArray< double > o2::framework::labeledArrayFromBranch< double > ( boost::property_tree::ptree const & tree )

Definition at line 125 of file VariantPropertyTreeHelpers.h.

◆ labeledArrayToBranch()

template<typename T >

boost::property_tree::ptree o2::framework::labeledArrayToBranch ( LabeledArray< T > && array )

Definition at line 134 of file VariantPropertyTreeHelpers.h.

◆ levenshteinDistance()

size_t o2::framework::levenshteinDistance	(	const char *	s,
		int	len_s,
		const char *	t,
		int	len_t
	)

Definition at line 34 of file DeviceSpec.cxx.

◆ loopReasonFromString()

DeviceState::LoopReason o2::framework::loopReasonFromString ( std::string_view reason )

Definition at line 20 of file DeviceStateHelpers.cxx.

◆ make_builders()

template<typename... ARGS>

auto o2::framework::make_builders ( )

Definition at line 412 of file TableBuilder.h.

◆ makeArrowTable()

std::shared_ptr< arrow::Table > o2::framework::makeArrowTable	(	const char *	label,
		std::vector< std::shared_ptr< arrow::ChunkedArray > > &&	columns,
		std::vector< std::shared_ptr< arrow::Field > > &&	fields
	)

Definition at line 269 of file IndexBuilderHelpers.cxx.

◆ makeEmptyTable() [1/3]

template<soa::TableRef R>

auto o2::framework::makeEmptyTable ( )

Definition at line 840 of file TableBuilder.h.

◆ makeEmptyTable() [2/3]

template<typename T >

auto o2::framework::makeEmptyTable ( const char * name )

Definition at line 831 of file TableBuilder.h.

◆ makeEmptyTable() [3/3]

template<typename... Cs>

auto o2::framework::makeEmptyTable	(	const char *	name,
		framework::pack< Cs... >	p
	)

Definition at line 849 of file TableBuilder.h.

◆ makeFileNameHolder()

FileNameHolder * o2::framework::makeFileNameHolder ( std::string fileName )

Definition at line 42 of file DataInputDirector.cxx.

◆ makeHolders()

template<typename... ARGS>

auto o2::framework::makeHolders	(	arrow::MemoryPool *	pool,
		size_t	nRows
	)

Definition at line 616 of file TableBuilder.h.

◆ makeHolderTypes()

template<typename... ARGS>

constexpr auto o2::framework::makeHolderTypes ( )

constexpr

Definition at line 608 of file TableBuilder.h.

◆ matchToContext()

size_t o2::framework::matchToContext	(	void const *	data,
		std::vector< DataDescriptorMatcher > const &	matchers,
		std::vector< size_t > const &	index,
		VariableContext &	context
	)

This does the mapping between a route and a InputSpec. The reason why these might diffent is that when you have timepipelining you have one route per timeslice, even if the type is the same.

Definition at line 238 of file DataRelayer.cxx.

◆ mergeInputs() [1/2]

Inputs o2::framework::mergeInputs	(	Inputs	inputs,
		size_t	maxIndex,
		std::function< void(InputSpec &, size_t)>	amendCallback
	)

The purpose of this helper is to duplicate a list of InputSpec as many times as specified in maxIndex and to amend each instance by invoking amendCallback on them with their own id. This can be used to programmatically create mergers.

Definition at line 125 of file WorkflowSpec.cxx.

◆ mergeInputs() [2/2]

Inputs o2::framework::mergeInputs	(	InputSpec	original,
		size_t	maxIndex,
		std::function< void(InputSpec &, size_t)>	amendCallback
	)

The purpose of this helper is to duplicate an InputSpec original as many times as specified in maxIndex and to amend each instance by invoking amendCallback on them with their own id. This can be used to programmatically create mergers.

Definition at line 112 of file WorkflowSpec.cxx.

◆ metricStorageSize()

template<typename T >

constexpr size_t o2::framework::metricStorageSize ( )

inlineconstexpr

Definition at line 104 of file DeviceMetricsInfo.h.

◆ nested_brace_constructible_size()

template<bool B, typename T >

consteval int o2::framework::nested_brace_constructible_size ( )

Definition at line 170 of file StructToTuple.h.

◆ O2_DPL_CAPABILITY()

struct o2::framework::O2_DPL_CAPABILITY ( "mutex" )

Definition at line 1 of file ServiceRegistry.h.

◆ o2DataModelAdaptor()

InjectorFunction o2::framework::o2DataModelAdaptor	(	OutputSpec const &	spec,
		uint64_t	startTime,
		uint64_t	step
	)

This is to be used for sources which already have an O2 Data Model / (header, payload) structure for their output. At the moment what this / does is to add a DataProcessingHeader. In the future, it will hopefully not be required. Notice that as a requirement the tuple (origin, data description, data subspecification) must be unique for each message in a given multipart ensemble.

Definition at line 205 of file ExternalFairMQDeviceProxy.cxx.

◆ on_awake_main_thread()

void o2::framework::on_awake_main_thread ( uv_async_t * handle )

Definition at line 214 of file WSDriverClient.cxx.

◆ on_communication_requested()

void o2::framework::on_communication_requested ( uv_async_t * s )

Definition at line 160 of file DataProcessingDevice.cxx.

◆ on_connect()

void o2::framework::on_connect	(	uv_connect_t *	connection,
		int	status
	)

FIXME: for now we simply take any offer as 1GB of SHM available

Definition at line 78 of file WSDriverClient.cxx.

◆ on_data_processing_expired()

void o2::framework::on_data_processing_expired ( uv_timer_t * handle )

Definition at line 144 of file DataProcessingDevice.cxx.

◆ on_idle_timer()

void o2::framework::on_idle_timer ( uv_timer_t * handle )

We schedule a timer to reduce CPU usage. Watching stdin for commands probably a better approach.

Definition at line 111 of file DataProcessingDevice.cxx.

◆ on_out_of_band_polled()

void o2::framework::on_out_of_band_polled	(	uv_poll_t *	poller,
		int	status,
		int	events
	)

Definition at line 357 of file DataProcessingDevice.cxx.

◆ on_signal_callback()

void o2::framework::on_signal_callback	(	uv_signal_t *	handle,
		int	signum
	)

Definition at line 535 of file DataProcessingDevice.cxx.

◆ on_socket_polled()

void o2::framework::on_socket_polled	(	uv_poll_t *	poller,
		int	status,
		int	events
	)

Definition at line 321 of file DataProcessingDevice.cxx.

◆ on_transition_requested_expired()

void o2::framework::on_transition_requested_expired ( uv_timer_t * handle )

Definition at line 127 of file DataProcessingDevice.cxx.

◆ operator<<() [1/15]

template<typename T , ConfigParamKind K, typename IP >

std::ostream & o2::framework::operator<<	(	std::ostream &	os,
		Configurable< T, K, IP > const &	c
	)

Definition at line 122 of file Configurable.h.

◆ operator<<() [2/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	oss,
		CompletionPolicy::CompletionOp const &	val
	)

Definition at line 33 of file CompletionPolicy.cxx.

◆ operator<<() [3/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	oss,
		DispatchPolicy::DispatchOp const &	val
	)

Definition at line 34 of file DispatchPolicy.cxx.

◆ operator<<() [4/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	oss,
		Lifetime const &	val
	)

Definition at line 500 of file LifetimeHelpers.cxx.

◆ operator<<() [5/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	oss,
		MetricType const &	val
	)

Definition at line 27 of file DeviceMetricsInfo.cxx.

◆ operator<<() [6/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	oss,
		Variant const &	val
	)

Definition at line 19 of file Variant.cxx.

◆ operator<<() [7/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	out,
		const enum DriverMode &	mode
	)

Definition at line 32 of file ProcessingPoliciesHelpers.cxx.

◆ operator<<() [8/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	out,
		const enum EarlyForwardPolicy &	policy
	)

Definition at line 86 of file ProcessingPoliciesHelpers.cxx.

◆ operator<<() [9/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	out,
		const enum LogParsingHelpers::LogLevel &	level
	)

Definition at line 120 of file ProcessingPoliciesHelpers.cxx.

◆ operator<<() [10/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	out,
		const enum TerminationPolicy &	policy
	)

Definition at line 58 of file ProcessingPoliciesHelpers.cxx.

◆ operator<<() [11/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	out,
		TopoIndexInfo const &	info
	)

Definition at line 45 of file WorkflowHelpers.cxx.

◆ operator<<() [12/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	s,
		ChannelMethod const &	method
	)

Stream operators so that we can use ChannelString with Boost.Test.

Definition at line 199 of file ChannelSpecHelpers.cxx.

◆ operator<<() [13/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	s,
		ChannelType const &	type
	)

Stream operators so that we can use ChannelType with Boost.Test.

Definition at line 192 of file ChannelSpecHelpers.cxx.

◆ operator<<() [14/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	stream,
		o2::framework::InputSpec const &	arg
	)

Definition at line 24 of file StreamOperators.cxx.

◆ operator<<() [15/15]

std::ostream & o2::framework::operator<<	(	std::ostream &	stream,
		o2::framework::OutputSpec const &	arg
	)

Definition at line 31 of file StreamOperators.cxx.

◆ operator==()

template<typename Deleter , size_t Size>

bool o2::framework::operator==	(	const std::unique_ptr< const std::vector< TObject * >, Deleter > &	vectorOfHistos,
		std::vector< ExpectedType< Size > > &	expected
	)

Definition at line 51 of file vectorTopologyCommon.h.

◆ operator>>() [1/4]

std::istream & o2::framework::operator>>	(	std::istream &	in,
		enum DriverMode &	mode
	)

Definition at line 44 of file ProcessingPoliciesHelpers.cxx.

◆ operator>>() [2/4]

std::istream & o2::framework::operator>>	(	std::istream &	in,
		enum EarlyForwardPolicy &	policy
	)

Definition at line 70 of file ProcessingPoliciesHelpers.cxx.

◆ operator>>() [3/4]

std::istream & o2::framework::operator>>	(	std::istream &	in,
		enum LogParsingHelpers::LogLevel &	level
	)

Definition at line 100 of file ProcessingPoliciesHelpers.cxx.

◆ operator>>() [4/4]

std::istream & o2::framework::operator>>	(	std::istream &	in,
		enum TerminationPolicy &	policy
	)

Definition at line 18 of file ProcessingPoliciesHelpers.cxx.

◆ overloaded()

template<class... Ts>

o2::framework::overloaded ( Ts... ) -> overloaded< Ts... >

◆ pack_size()

template<typename... Ts>

constexpr std::size_t o2::framework::pack_size ( pack< Ts... > const & )

constexpr

template function to determine number of types in a pack

Definition at line 28 of file Pack.h.

◆ pack_tail()

template<typename Head , typename... Tail>

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

constexpr

Definition at line 62 of file Pack.h.

◆ pack_to_tuple()

template<typename... Ts>

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

inlineconstexpr

Definition at line 337 of file Pack.h.

◆ parallel() [1/4]

WorkflowSpec o2::framework::parallel	(	DataProcessorSpec	original,
		size_t	maxIndex,
		std::function< void(DataProcessorSpec &, size_t id)>	amendCallback
	)

The purpose of this helper is to duplicate a DataProcessorSpec original as many times as specified in maxIndex and to amend each instance by invoking amendCallback on them with their own id.

◆ parallel() [2/4]

WorkflowSpec o2::framework::parallel	(	DataProcessorSpec	original,
		size_t	maxIndex,
		std::function< void(DataProcessorSpec &, size_t)>	amendCallback
	)

Definition at line 23 of file WorkflowSpec.cxx.

◆ parallel() [3/4]

WorkflowSpec o2::framework::parallel	(	WorkflowSpec	specs,
		size_t	maxIndex,
		std::function< void(DataProcessorSpec &, size_t id)>	amendCallback
	)

The purpose of this helper is to duplicate a sequence of DataProcessorSpec as many times as specified in maxIndex and to amend each instance by invoking amendCallback on them with their own id.

◆ parallel() [4/4]

WorkflowSpec o2::framework::parallel	(	WorkflowSpec	specs,
		size_t	maxIndex,
		std::function< void(DataProcessorSpec &, size_t)>	amendCallback
	)

Definition at line 39 of file WorkflowSpec.cxx.

◆ parallelPipeline()

WorkflowSpec o2::framework::parallelPipeline	(	const WorkflowSpec &	specs,
		size_t	nPipelines,
		std::function< size_t()>	getNumberOfSubspecs,
		std::function< size_t(size_t)>	getSubSpec
	)

create parallel pipelines of processors from a template sequence for a number of parallel sub specification IDs. The sub specifications are distributed among the pipelines. serves the case where each input id (subspec) corresponds to outputs amended with the same subspec. Two callback functions allow two configure the list of subspecs for the call.

Schematic workflow illustration: template pipeline parallel pipelines

| A0|-—>|A0 B0|-—>|B0 | | | | C0|-—>|C0 | | A1|-—>|A1 B1|-—>|B1 | | | | C1|-—>|C1 |

-— -— -— | A2|-—>|A2 B2|-—>|B2 | | A|-—>|A B|-—>|B | becomes | | | C2|-—>|C2 | | | | C|-—>|C | ======> | A3|-—>|A3 B3|-—>|B3 | -— -— -— | | | C3|-—>|C3 |

| An|-—>|An Bn|-—>|Bn | | | | Cn|-—>|Cn |

Parameters

specs	the template to be multiplied
nPipelines	number of pipelines
getNumberOfSubspecs	callback function to return the number of subspecs
getSubSpec	callback function to return the subspecs at index

Definition at line 53 of file WorkflowSpec.cxx.

◆ parse_http_request()

void o2::framework::parse_http_request	(	char *	start,
		size_t	size,
		HTTPParser *	parser
	)

Definition at line 228 of file HTTPParser.cxx.

◆ parse_websocket_url()

std::pair< std::string, unsigned short > o2::framework::parse_websocket_url ( char const * url )

Definition at line 447 of file HTTPParser.cxx.

◆ populateCacheWith()

auto o2::framework::populateCacheWith	(	std::shared_ptr< CCDBFetcherHelper > const &	helper,
		int64_t	timestamp,
		TimingInfo &	timingInfo,
		DataTakingContext &	dtc,
		DataAllocator &	allocator
	)		-> void

Definition at line 186 of file CCDBHelpers.cxx.

◆ populateHeader()

void o2::framework::populateHeader	(	std::map< std::string, std::string > &	headers,
		std::string_view const &	k,
		std::string_view const &	v
	)

Definition at line 201 of file DPLWebSocket.cxx.

◆ print_pack()

template<typename T >

void o2::framework::print_pack ( )

Definition at line 201 of file Pack.h.

◆ PropertyTreeHelpers::traverse< boost::property_tree::ptree >()

template<>

void o2::framework::PropertyTreeHelpers::traverse< boost::property_tree::ptree >	(	const boost::property_tree::ptree &	parent,
		PropertyTreeHelpers::WalkerFunction< boost::property_tree::ptree > &	method
	)

Definition at line 401 of file PropertyTreeHelpers.cxx.

◆ prune_voids_pack() [1/6]

template<typename... Rs, nonvoid_pack_element T, typename... Ts>

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

Definition at line 125 of file Pack.h.

◆ prune_voids_pack() [2/6]

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... >
	)

Definition at line 154 of file Pack.h.

◆ prune_voids_pack() [3/6]

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... >
	)

Definition at line 146 of file Pack.h.

◆ prune_voids_pack() [4/6]

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... >
	)

Definition at line 139 of file Pack.h.

◆ prune_voids_pack() [5/6]

template<typename... Rs, void_pack_element V, typename... Ts>

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

Definition at line 132 of file Pack.h.

◆ prune_voids_pack() [6/6]

template<typename Result >

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

Definition at line 112 of file Pack.h.

◆ readToBuffer()

size_t o2::framework::readToBuffer	(	void *	p,
		size_t	size,
		size_t	nmemb,
		void *	userdata
	)

Definition at line 331 of file LifetimeHelpers.cxx.

◆ readToMessage()

size_t o2::framework::readToMessage	(	void *	p,
		size_t	size,
		size_t	nmemb,
		void *	userdata
	)

Definition at line 347 of file LifetimeHelpers.cxx.

◆ remoteGuiCallback()

void o2::framework::remoteGuiCallback ( uv_timer_s * ctx )

Definition at line 214 of file DPLWebSocket.cxx.

◆ replaceLabels()

template<typename T >

auto o2::framework::replaceLabels	(	LabeledArray< T > &	input,
		LabeledArray< T > &&	spec
	)

Definition at line 256 of file PropertyTreeHelpers.cxx.

◆ retryMetricCallback()

void o2::framework::retryMetricCallback ( uv_async_t * async )

Definition at line 146 of file CommonDataProcessors.cxx.

◆ rootBuffer()

TBufferFile & o2::framework::rootBuffer ( )

Definition at line 237 of file TTreePlugin.cxx.

◆ rootFieldFromArrow()

std::unique_ptr< ROOT::Experimental::RFieldBase > o2::framework::rootFieldFromArrow	(	std::shared_ptr< arrow::Field >	field,
		std::string	name
	)

Definition at line 258 of file RNTuplePlugin.cxx.

◆ rootSuffixFromArrow()

char const * o2::framework::rootSuffixFromArrow ( arrow::Type::type id )

Definition at line 786 of file TTreePlugin.cxx.

◆ run_callback()

void o2::framework::run_callback ( uv_work_t * handle )

Definition at line 251 of file DataProcessingDevice.cxx.

◆ run_completion()

void o2::framework::run_completion	(	uv_work_t *	handle,
		int	status
	)

Definition at line 265 of file DataProcessingDevice.cxx.

◆ runtime_error()

RuntimeErrorRef o2::framework::runtime_error ( const char * s )

Definition at line 78 of file RuntimeError.cxx.

◆ runtime_error_f()

RuntimeErrorRef o2::framework::runtime_error_f	(	const char *	format,
			...
	)

Definition at line 60 of file RuntimeError.cxx.

◆ search()

bool o2::framework::search	(	DeviceExecution const &	execution,
		std::string const &	option,
		std::string const &	argument
	)

Definition at line 34 of file test_DeviceSpecHelpers.cxx.

◆ select()

std::vector< InputSpec > o2::framework::select ( char const * matcher = "" )

The purpose of this helper is to create a query on the data via a properly formatted matcher string which describes data in terms of the O2 Data Model descriptor.

The syntax of the string is the following:

binding:origin/description/subSpecificationtimemodule;...

Each ; delimits an InputSpec.

Really a wrapper around DataDescriptorQueryBuilder::parse FIXME: should really use an rvalue..

Definition at line 152 of file WorkflowSpec.cxx.

◆ select_pack() [1/2]

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
	)

Definition at line 169 of file Pack.h.

◆ select_pack() [2/2]

template<template< typename... > typename Condition, typename Result , typename... Cs>

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

Selects from the pack types that satisfy the Condition Multicondition takes the type to check as first template parameter and any helper types as the following parameters

Definition at line 163 of file Pack.h.

◆ sendMessageToDriver()

void o2::framework::sendMessageToDriver	(	std::unique_ptr< o2::framework::WSDPLClient > &	client,
		char const *	message,
		size_t	s
	)

Definition at line 248 of file WSDriverClient.cxx.

◆ sendOnChannel() [1/4]

void o2::framework::sendOnChannel	(	fair::mq::Device &	device,
		fair::mq::MessagePtr &&	headerMessage,
		fair::mq::MessagePtr &&	payloadMessage,
		OutputSpec const &	spec,
		ChannelRetriever &	channelRetriever
	)

Definition at line 165 of file ExternalFairMQDeviceProxy.cxx.

◆ sendOnChannel() [2/4]

void o2::framework::sendOnChannel	(	fair::mq::Device &	device,
		fair::mq::Parts &	messages,
		OutputSpec const &	spec,
		DataProcessingHeader::StartTime	tslice,
		ChannelRetriever &	channelRetriever
	)

Definition at line 122 of file ExternalFairMQDeviceProxy.cxx.

◆ sendOnChannel() [3/4]

void o2::framework::sendOnChannel	(	fair::mq::Device &	device,
		fair::mq::Parts &	messages,
		std::string const &	channel,
		size_t	timeSlice
	)

Definition at line 70 of file ExternalFairMQDeviceProxy.cxx.

◆ sendOnChannel() [4/4]

void o2::framework::sendOnChannel	(	fair::mq::Device &	device,
		o2::header::Stack &&	headerStack,
		fair::mq::MessagePtr &&	payloadMessage,
		OutputSpec const &	spec,
		ChannelRetriever &	channelRetriever
	)

send header/payload O2 message for an OutputSpec, a channel retriever callback is required to get the associated fair::mq::Channel FIXME: can in principle drop the OutputSpec parameter and take the DataHeader

Definition at line 134 of file ExternalFairMQDeviceProxy.cxx.

◆ sendVariableContextMetrics()

void o2::framework::sendVariableContextMetrics	(	VariableContext &	context,
		TimesliceSlot	slot,
		DataProcessingStates &	states
	)

Send the contents of a context as metrics, so that we can examine them in the GUI.

Definition at line 257 of file DataRelayer.cxx.

◆ sequence_to_pack()

template<typename T , std::size_t... Is>

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

inline

Definition at line 346 of file Pack.h.

◆ spawner() [1/3]

template<typename... C>

auto o2::framework::spawner	(	framework::pack< C... >	columns,
		std::vector< std::shared_ptr< arrow::Table > > &&	tables,
		const char *	name
	)

Definition at line 912 of file TableBuilder.h.

◆ spawner() [2/3]

template<aod::is_aod_hash D>

auto o2::framework::spawner	(	std::shared_ptr< arrow::Table > const &	fullTable,
		const char *	name
	)

Definition at line 881 of file TableBuilder.h.

◆ spawner() [3/3]

template<aod::is_aod_hash D>

auto o2::framework::spawner	(	std::vector< std::shared_ptr< arrow::Table > > &&	tables,
		const char *	name
	)

Expression-based column generator to materialize columns.

Definition at line 862 of file TableBuilder.h.

◆ spawnerHelper()

std::shared_ptr< arrow::Table > o2::framework::spawnerHelper	(	std::shared_ptr< arrow::Table > const &	fullTable,
		std::shared_ptr< arrow::Schema >	newSchema,
		size_t	nColumns,
		expressions::Projector *	projectors,
		std::vector< std::shared_ptr< arrow::Field > > const &	fields,
		const char *	name
	)

Definition at line 87 of file TableBuilder.cxx.

◆ specCombiner()

o2::framework::DataProcessorSpec o2::framework::specCombiner	(	std::string const &	name,
		std::vector< DataProcessorSpec > const &	speccollection,
		std::vector< DataProcessorSpec > &	remaining
	)

Definition at line 114 of file DPLWorkflowUtils.h.

◆ specifyExternalFairMQDeviceProxy()

DataProcessorSpec o2::framework::specifyExternalFairMQDeviceProxy	(	char const *	label,
		std::vector< OutputSpec > const &	outputs,
		const char *	defaultChannelConfig,
		InjectorFunction	converter,
		uint64_t	minSHM = `0`,
		bool	sendTFcounter = `false`,
		bool	doInjectMissingData = `false`,
		unsigned int	doPrintSizes = `0`
	)

Create a DataProcessorSpec which can be used to inject messages in the DPL.

Parameters

label	is the label of the DataProcessorSpec associated and name of the input channel.
outputs	is the type of messages which this source produces.
channelConfig	is string to be passed to fairmq to create the device. notice that the name of the device will be added as the name of the channel if the name tag is not yet in the configuration
converter	is a lambda to be invoked to convert inputs into messages of the DPL. By default incrementalConverter is used which attaches to each @input FairMQPart a DataProcessingHeader with an incremental number as start time.

Definition at line 642 of file ExternalFairMQDeviceProxy.cxx.

◆ specifyFairMQDeviceMultiOutputProxy()

DataProcessorSpec o2::framework::specifyFairMQDeviceMultiOutputProxy	(	char const *	label,
		Inputs const &	inputSpecs,
		const char *	defaultChannelConfig,
		ChannelSelector	channelSelector = `defaultOutputProxyChannelSelector`
	)

Create a DataProcessorSpec for a DPL processor with an out-of-band channel to relay DPL workflow data to an external fair::mq::Device channel.

The output configuration is determined by one or multiple entries of the fair::mq::Device command line option '–channel-config' in the format –channel-config "name=channel-name;..." A default string is build from the provided parameter.

The target of each input data matcher is specified as the binding identifier and matched to the configured output channels

Parameters

label	is the label of the DataProcessorSpec associated.
inputSpecs	the list of inputs to read from, the binding of the spec must correspond to an output channel
defaultChannelConfig	is the default configuration of the out-of-band channel the string is passed to fairmq to create the device channel and can be adjusted by command line option '–channel-config' notice that the name of the device will be added as the name of the channel if the name tag is not yet in the configuration

Definition at line 1014 of file ExternalFairMQDeviceProxy.cxx.

◆ specifyFairMQDeviceOutputProxy()

DataProcessorSpec o2::framework::specifyFairMQDeviceOutputProxy	(	char const *	label,
		Inputs const &	inputSpecs,
		const char *	defaultChannelConfig
	)

Definition at line 911 of file ExternalFairMQDeviceProxy.cxx.

◆ SpectoString()

std::string o2::framework::SpectoString ( InputSpec input )

Definition at line 197 of file DataOutputDirector.cxx.

◆ startTimeParamSpec()

ConfigParamSpec o2::framework::startTimeParamSpec ( int64_t t )

Definition at line 64 of file CCDBParamSpec.cxx.

◆ strToUpper()

std::string o2::framework::strToUpper ( std::string && str )

Definition at line 189 of file ASoA.cxx.

◆ TEMPLATE_TEST_CASE()

o2::framework::TEMPLATE_TEST_CASE	(	"test_RawParser"	,
		""	[RDH][template],
		V5	,
		V6	,
		V7
	)

Definition at line 44 of file test_RawParser.cxx.

◆ TEST_CASE() [1/5]

o2::framework::TEST_CASE ( "Check validity of the workflow" )

Definition at line 291 of file test_DeviceSpecHelpers.cxx.

◆ TEST_CASE() [2/5]

o2::framework::TEST_CASE ( "CheckIntegerReworking" )

Definition at line 225 of file test_DeviceSpecHelpers.cxx.

◆ TEST_CASE() [3/5]

o2::framework::TEST_CASE ( "CheckOptionReworking" )

Definition at line 183 of file test_DeviceSpecHelpers.cxx.

◆ TEST_CASE() [4/5]

o2::framework::TEST_CASE ( "CheckReworkingEnv" )

Definition at line 355 of file test_DeviceSpecHelpers.cxx.

◆ TEST_CASE() [5/5]

o2::framework::TEST_CASE ( "test_prepareArguments" )

Definition at line 103 of file test_DeviceSpecHelpers.cxx.

◆ throw_error()

void o2::framework::throw_error ( RuntimeErrorRef ref )

Definition at line 90 of file RuntimeError.cxx.

◆ timePipeline()

DataProcessorSpec o2::framework::timePipeline	(	DataProcessorSpec	original,
		size_t	count
	)

The purpose of this helper is to duplicate a DataProcessorSpec original as many times as count and make sure that each one of those is picking up a different subchannel. All the inputs of this DataProcessorSpec will have to be adapted to produce one set of inputs per subchannel, in a round robin fashion. All the consumers of this DataProcessorSpec will have to connect to each one of the parallel workers or a "TimeMerger" device will have to do that for you.

Definition at line 140 of file WorkflowSpec.cxx.

◆ timerSpecs()

std::vector< ConfigParamSpec > o2::framework::timerSpecs ( std::vector< TimerSpec > intervals )

Definition at line 17 of file TimerParamSpec.cxx.

◆ to_tuple()

template<class T >

auto constexpr o2::framework::to_tuple ( T && object )

constexprnoexcept

Helper function to convert a brace-initialisable struct to a tuple.

Definition at line 587 of file TableBuilder.h.

◆ transformBase()

template<is_spawnable T>

constexpr auto o2::framework::transformBase ( )

constexpr

This helper struct allows you to declare index tables to be created in a task.

Definition at line 251 of file AnalysisHelpers.h.

◆ tuple_to_pack()

template<typename... ARGS>

constexpr auto o2::framework::tuple_to_pack ( std::tuple< ARGS... > && )

constexpr

Definition at line 567 of file TableBuilder.h.

◆ typeWithRef()

template<soa::is_table T>

consteval auto o2::framework::typeWithRef ( ) -> T

Helper to define output for a Table.

Definition at line 159 of file AnalysisHelpers.h.

◆ unique_pack() [1/2]

template<typename PT , typename T , typename... Ts>

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

constexpr

Definition at line 328 of file Pack.h.

◆ unique_pack() [2/2]

template<typename PT >

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

constexpr

Definition at line 322 of file Pack.h.

◆ updatePairList()

void o2::framework::updatePairList	(	std::vector< StringPair > &	list,
		std::string const &	binding,
		std::string const &	key
	)

Definition at line 22 of file ArrowTableSlicingCache.cxx.

◆ validateExpendable()

bool o2::framework::validateExpendable	(	std::ostream &	errors,
		DataProcessorSpec const &	producer,
		OutputSpec const &	output,
		DataProcessorPoliciesInfo const &	producerPolicies,
		DataProcessorSpec const &	consumer,
		InputSpec const &	input,
		DataProcessorPoliciesInfo const &	consumerPolicies
	)

Definition at line 1088 of file WorkflowHelpers.cxx.

◆ validateLifetime()

bool o2::framework::validateLifetime	(	std::ostream &	errors,
		DataProcessorSpec const &	producer,
		OutputSpec const &	output,
		DataProcessorPoliciesInfo const &	producerPolicies,
		DataProcessorSpec const &	consumer,
		InputSpec const &	input,
		DataProcessorPoliciesInfo const &	consumerPolicies
	)

Definition at line 1071 of file WorkflowHelpers.cxx.

◆ vectorFromBranch()

template<typename T >

std::vector< T > o2::framework::vectorFromBranch ( boost::property_tree::ptree const & branch )

Definition at line 88 of file VariantPropertyTreeHelpers.h.

◆ vectorToBranch() [1/2]

template<typename T >

boost::property_tree::ptree o2::framework::vectorToBranch ( std::vector< T > && values )

Definition at line 47 of file VariantPropertyTreeHelpers.h.

◆ vectorToBranch() [2/2]

template<typename T >

boost::property_tree::ptree o2::framework::vectorToBranch	(	T *	values,
		size_t	size
	)

Definition at line 39 of file VariantPropertyTreeHelpers.h.

◆ websocket_client_callback()

void o2::framework::websocket_client_callback	(	uv_stream_t *	stream,
		ssize_t	nread,
		const uv_buf_t *	buf
	)

Definition at line 392 of file DPLWebSocket.cxx.

◆ websocket_server_callback()

void o2::framework::websocket_server_callback	(	uv_stream_t *	stream,
		ssize_t	nread,
		const uv_buf_t *	buf
	)

Actually replies to any incoming websocket stuff.

Definition at line 58 of file DPLWebSocket.cxx.

◆ websocket_server_close_callback()

void o2::framework::websocket_server_close_callback ( uv_handle_t * handle )

Free any resource associated with the device - driver channel.

Definition at line 40 of file DPLWebSocket.cxx.

◆ whoAmI()

std::string o2::framework::whoAmI ( ConfigContext const & configcontext )

Definition at line 92 of file DPLWorkflowUtils.h.

◆ ws_client_bulk_write_callback()

void o2::framework::ws_client_bulk_write_callback	(	uv_write_t *	h,
		int	status
	)

Definition at line 530 of file DPLWebSocket.cxx.

◆ ws_client_write_callback()

void o2::framework::ws_client_write_callback	(	uv_write_t *	h,
		int	status
	)

Definition at line 513 of file DPLWebSocket.cxx.

◆ ws_error_write_callback()

void o2::framework::ws_error_write_callback	(	uv_write_t *	h,
		int	status
	)

Definition at line 47 of file DPLWebSocket.cxx.

◆ ws_handshake_done_callback()

void o2::framework::ws_handshake_done_callback	(	uv_write_t *	h,
		int	status
	)

Whenever we have handshaken correctly, we can wait for the actual frames until we get an error.

Definition at line 86 of file DPLWebSocket.cxx.

◆ ws_server_bulk_write_callback()

void o2::framework::ws_server_bulk_write_callback	(	uv_write_t *	h,
		int	status
	)

Definition at line 338 of file DPLWebSocket.cxx.

◆ ws_server_write_callback()

void o2::framework::ws_server_write_callback	(	uv_write_t *	h,
		int	status
	)

Definition at line 325 of file DPLWebSocket.cxx.

◆ xmlEncode()

std::string o2::framework::xmlEncode ( std::string const & source )

Definition at line 87 of file DDSConfigHelpers.cxx.

Variable Documentation

◆ always_static_assert_v

template<typename... T>

constexpr bool o2::framework::always_static_assert_v = always_static_assert<T...>::value

inlineconstexpr

Definition at line 50 of file Traits.h.

◆ createMetricInfo

auto o2::framework::createMetricInfo

Definition at line 297 of file DeviceMetricsHelper.cxx.

◆ decongestionCallback

auto o2::framework::decongestionCallback

Definition at line 533 of file CommonServices.cxx.

◆ decongestionCallbackLate

auto o2::framework::decongestionCallbackLate

Initial value:

= [](AsyncTask& task, size_t aid) -> void {
  auto& oldestTimeslice = task.user<DecongestionContext>().oldestTimeslice;
  auto& ref = task.user<DecongestionContext>().ref;
 
  auto& decongestion = ref.get<DecongestionService>();
  auto& proxy = ref.get<FairMQDeviceProxy>();
  if (oldestTimeslice.timeslice.value <= decongestion.lastTimeslice) {
    LOG(debug) << "Not sending already sent oldest possible timeslice " << oldestTimeslice.timeslice.value;
    return;
  }
  for (int fi = 0; fi < proxy.getNumForwardChannels(); fi++) {
    auto& info = proxy.getForwardChannelInfo(ChannelIndex{fi});
    auto& state = proxy.getForwardChannelState(ChannelIndex{fi});
    O2_SIGNPOST_ID_GENERATE(aid, async_queue);
    
    if (info.channelType != ChannelAccountingType::DPL) {
      O2_SIGNPOST_EVENT_EMIT(async_queue, aid, "forwardInputsCallback", "Skipping channel %{public}s because it's not a DPL channel",
                             info.name.c_str());
 
      continue;
    }
    if (DataProcessingHelpers::sendOldestPossibleTimeframe(ref, info, state, oldestTimeslice.timeslice.value)) {
      O2_SIGNPOST_EVENT_EMIT(async_queue, aid, "forwardInputsCallback", "Forwarding to channel %{public}s oldest possible timeslice %zu, prio 20",
                             info.name.c_str(), oldestTimeslice.timeslice.value);
    }
  }
}

Definition at line 654 of file DataProcessingDevice.cxx.

◆ decongestionCallbackOrdered

auto o2::framework::decongestionCallbackOrdered

Initial value:

= [](AsyncTask& task, size_t id) -> void {
  auto& oldestPossibleOutput = task.user<DecongestionContext>().oldestPossibleOutput;
  auto& ref = task.user<DecongestionContext>().ref;
 
  auto& decongestion = ref.get<DecongestionService>();
  auto& state = ref.get<DeviceState>();
  auto& timesliceIndex = ref.get<TimesliceIndex>();
  O2_SIGNPOST_ID_GENERATE(cid, async_queue);
  int64_t oldNextTimeslice = decongestion.nextTimeslice;
  decongestion.nextTimeslice = std::max(decongestion.nextTimeslice, (int64_t)oldestPossibleOutput.timeslice.value);
  if (oldNextTimeslice != decongestion.nextTimeslice) {
    if (state.transitionHandling != TransitionHandlingState::NoTransition && DefaultsHelpers::onlineDeploymentMode()) {
      O2_SIGNPOST_EVENT_EMIT_WARN(async_queue, cid, "oldest_possible_timeslice", "Stop transition requested. Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
    } else {
      O2_SIGNPOST_EVENT_EMIT_ERROR(async_queue, cid, "oldest_possible_timeslice", "Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
    }
    timesliceIndex.rescan();
  }
}

Definition at line 568 of file CommonServices.cxx.

◆ findOverrideByName

auto o2::framework::findOverrideByName

Initial value:

= [](std::string_view name) {
  return [name](const OverrideServiceSpec& spec) { return spec.name == name; };
}

Definition at line 23 of file ServiceSpec.cxx.

◆ has_type_conditional_v

template<template< typename, typename > typename Condition, typename T , typename P >

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

inlineconstexpr

Definition at line 225 of file Pack.h.

◆ has_type_v

template<typename T , typename P >

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

inlineconstexpr

Definition at line 216 of file Pack.h.

◆ INVALID_INPUT

constexpr int o2::framework::INVALID_INPUT = -1

constexpr

Definition at line 62 of file DataRelayer.cxx.

◆ is_base_of_template_v

template<template< typename... > typename B, typename D >

constexpr bool o2::framework::is_base_of_template_v = base_of_template<B, D>

constexpr

Definition at line 58 of file Traits.h.

◆ is_specialization_v

template<typename T , template< typename... > class Ref>

constexpr bool o2::framework::is_specialization_v = is_specialization<T, Ref>::value

inlineconstexpr

Definition at line 32 of file Traits.h.

◆ is_type_complete_v

template<typename , typename = void>

constexpr bool o2::framework::is_type_complete_v = false

constexpr

Helper to understand if a given type is complete (declared fully) or not (forward declared). See also: https://devblogs.microsoft.com/oldnewthing/20190710-00/?p=102678

Definition at line 24 of file CheckTypes.h.

◆ MAX_USER_FILTER_SIZE

constexpr int o2::framework::MAX_USER_FILTER_SIZE = 256

constexpr

Definition at line 24 of file DeviceControl.h.

◆ PageSize

constexpr size_t o2::framework::PageSize = 8192

constexpr

Definition at line 18 of file test_RawParser.cxx.

◆ readBoolValues

auto o2::framework::readBoolValues

Initial value:

= [](uint8_t* target, ReadOps& op, TBufferFile& rootBuffer) {
  int readEntries = 0;
  rootBuffer.Reset();
  
  memset(target, 0, op.targetBuffer->size());
  int readLast = 0;
  while (readEntries < op.rootBranchEntries) {
    auto beginValue = readLast;
    auto readLast = op.branch->GetBulkRead().GetBulkEntries(readEntries, rootBuffer);
    int size = readLast * op.listSize;
    readEntries += readLast;
    for (int i = beginValue; i < beginValue + size; ++i) {
      auto value = static_cast<uint8_t>(rootBuffer.GetCurrent()[i - beginValue] << (i % 8));
      target[i / 8] |= value;
    }
  }
}

Definition at line 204 of file TTreePlugin.cxx.

◆ readOffsets

auto o2::framework::readOffsets

Initial value:

= [](ReadOps& op, TBufferFile& rootBuffer) {
  uint32_t offset = 0;
  std::span<int> offsets;
  int readEntries = 0;
  int count = 0;
  auto* tPtrOffset = reinterpret_cast<int*>(op.targetBuffer->mutable_data());
  offsets = std::span<int>{tPtrOffset, tPtrOffset + op.rootBranchEntries + 1};
 
  
  rootBuffer.Reset();
  while (readEntries < op.rootBranchEntries) {
    auto readLast = op.branch->GetBulkRead().GetEntriesSerialized(readEntries, rootBuffer);
    if (readLast == -1) {
      throw runtime_error_f("Unable to read from branch %s.", op.branch->GetName());
    }
    readEntries += readLast;
    for (auto i = 0; i < readLast; ++i) {
      offsets[count++] = (int)offset;
      offset += swap32_(reinterpret_cast<uint32_t*>(rootBuffer.GetCurrent())[i]);
    }
  }
  offsets[count] = (int)offset;
  op.offsetCount = offset;
}

Definition at line 565 of file TTreePlugin.cxx.

◆ readValues

auto o2::framework::readValues

Initial value:

= [](uint8_t* target, ReadOps& op, TBufferFile& rootBuffer) {
  int readEntries = 0;
  rootBuffer.Reset();
  while (readEntries < op.rootBranchEntries) {
    auto readLast = op.branch->GetBulkRead().GetEntriesSerialized(readEntries, rootBuffer);
    if (readLast < 0) {
      throw runtime_error_f("Error while reading branch %s starting from %zu.", op.branch->GetName(), readEntries);
    }
    int size = readLast * op.listSize;
    readEntries += readLast;
    swapCopy(target, rootBuffer.GetCurrent(), size, op.typeSize);
    target += (ptrdiff_t)(size * op.typeSize);
  }
}

Definition at line 189 of file TTreePlugin.cxx.

◆ readVLAValues

auto o2::framework::readVLAValues

Initial value:

= [](uint8_t* target, ReadOps& op, ReadOps const& offsetOp, TBufferFile& rootBuffer) {
  int readEntries = 0;
  auto* tPtrOffset = reinterpret_cast<const int*>(offsetOp.targetBuffer->data());
  std::span<int const> const offsets{tPtrOffset, tPtrOffset + offsetOp.rootBranchEntries + 1};
 
  rootBuffer.Reset();
  while (readEntries < op.rootBranchEntries) {
    auto readLast = op.branch->GetBulkRead().GetEntriesSerialized(readEntries, rootBuffer);
    int size = offsets[readEntries + readLast] - offsets[readEntries];
    readEntries += readLast;
    swapCopy(target, rootBuffer.GetCurrent(), size, op.typeSize);
    target += (ptrdiff_t)(size * op.typeSize);
  }
}

Definition at line 222 of file TTreePlugin.cxx.

◆ region_read_global_dummy_variable

volatile int o2::framework::region_read_global_dummy_variable

Definition at line 775 of file DataProcessingDevice.cxx.

◆ service_kind_v

template<typename T >

constexpr ServiceKind o2::framework::service_kind_v = ServiceKindExtractor<T>::kind

inlineconstexpr

Definition at line 76 of file ServiceRegistry.h.

◆ storeIdx

auto o2::framework::storeIdx

Initial value:

= [](DeviceMetricsInfo& info, MetricType type) -> size_t {
  switch (type) {
    case MetricType::Int:
      return info.intMetrics.size();
    case MetricType::String:
      return info.stringMetrics.size();
    case MetricType::Float:
      return info.floatMetrics.size();
    case MetricType::Uint64:
      return info.uint64Metrics.size();
    case MetricType::Enum:
      return info.enumMetrics.size();
    default:
      return -1;
  }
}

Definition at line 280 of file DeviceMetricsHelper.cxx.

◆ unique_type_id_v

template<typename T >

constexpr auto o2::framework::unique_type_id_v = unique_type_id<T>::value

inlineconstexpr

Definition at line 37 of file TypeIdHelpers.h.

◆ VARIABLE_WIDTH

constexpr double o2::framework::VARIABLE_WIDTH = 0.

constexpr

Specification of an Axis.

Definition at line 81 of file HistogramSpec.h.

◆ variant_trait_v

template<typename T >

constexpr VariantType o2::framework::variant_trait_v = variant_trait<T>::value

inlineconstexpr

Definition at line 190 of file Variant.h.

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ ChannelRetriever

◆ ChannelSelector

◆ CheckMatrix

◆ ComputingQuotaConsumer

◆ ComputingQuotaRequest

◆ concatenated_pack_t

◆ concatenated_pack_unique_t

◆ ConfigurableAxis

◆ DataDescription

◆ DataHeader

◆ DataProcessingHeader

◆ DataProcessorMatcher

◆ DeviceMatcher

◆ EdgeMatcher

◆ ExpectedType

◆ filtered_pack

◆ full_intersected_pack_t

◆ GID

◆ HistPtr

◆ IndexedHoldersTuple

◆ InjectorFunction

◆ Inputs

◆ interleaved_pack_t

◆ intersected_pack_t

◆ is_index_to_g_t

◆ iterator_tuple_t

◆ labelmap_t

◆ ListVector

◆ LogicalChannelsMap

◆ LogLevel

◆ MetricsStorage

◆ MutableConfigurable

◆ OnWorkflowTerminationHook

◆ Options

◆ options_description

◆ Outputs

◆ OverrideServiceSpecs

◆ pack_element_t

◆ pack_head_t

◆ pack_to_tuple_t

◆ Pair

◆ Preslice

◆ PresliceOptional

◆ PresliceUnsorted

◆ PresliceUnsortedOptional

◆ Remap64Bit_t

◆ repeated_type_pack_t

◆ RootTreeReader

◆ SameKindPair

◆ SameKindTriple

◆ selected_pack

◆ selected_pack_multicondition

◆ ServiceConfigureCallback

◆ ServiceDanglingCallback

◆ ServiceDomainInfoUpdated

◆ ServiceDriverInit

◆ ServiceDriverStartup

◆ ServiceEOSCallback

◆ ServiceExitCallback

◆ ServiceId

◆ ServiceInit

◆ ServiceMetricHandling

◆ ServicePostDispatching

◆ ServicePostForkChild

◆ ServicePostForkParent

◆ ServicePostForwarding

◆ ServicePostRenderGUI

◆ ServicePostSchedule

◆ ServicePreFork

◆ ServicePreLoop

◆ ServicePreSchedule

◆ attribute()