tcspc Namespace Reference

Description

libtcspc namespace.

Namespaces
namespace	arg
	Argument wrappers.
namespace	int_types
	Short names for fixed-width integer types.
namespace	literals
	User-defined literals for tcspc::npint.

Classes
class	access_tracker
	Tracker that mediates access to objects via a tcspc::context. More...
class	acquire_access
	Access for acquire processors. More...
class	acquisition_halted
	Exception thrown when acquisition was halted. More...
class	always_matcher
	Matcher that matches all events. More...
struct	basic_pqt2_event
	Implementation for binary record interpretation for HydraHarp, MultiHarp, TimeHarp 260, and PicoHarp 330 T2 format. More...
struct	basic_pqt3_event
	Implementation for binary record interpretation for HydraHarp, MultiHarp, TimeHarp 260, and PicoHarp 330 T3 format. More...
struct	begin_lost_interval_event
	Event indicating beginning of interval in which counts were lost. More...
struct	bh_spc600_256ch_event
	Binary record interpretation for raw events from SPC-600/630 in 256-channel mode. More...
struct	bh_spc600_4096ch_event
	Binary record interpretation for raw events from SPC-600/630 in 4096-channel mode. More...
struct	bh_spc_event
	Binary record interpretation for raw BH SPC event. More...
struct	bin_increment_cluster_event
	Event representing a cluster of data points binned for histogramming. More...
struct	bin_increment_event
	Event representing data binned for histogramming. More...
class	bucket
	Value-semantic container for array data allowing use of custom storage. More...
struct	bucket_source
	Abstract base class for polymorphic bucket sources. More...
class	buffer_access
	Access for tcspc::buffer() and tcspc::real_time_buffer() processors. More...
class	buffer_overflow_error
	Error thrown when buffer capacity has been exhausted. More...
struct	bulk_counts_event
	Event indicating number of detections from a non-time-tagging device. More...
class	capture_output_access
	Access for tcspc::capture_output() processors. More...
class	capture_output_checker
	Event-set-specific wrapper for tcspc::capture_output_access. More...
class	channel_data_mapper
	Data mapper mapping channel to the data value. More...
class	channel_matcher
	Matcher that matches a single channel. More...
class	channel_router
	Router that routes by channel number. More...
struct	concluding_histogram_array_event
	Event representing the final result of accumulation of a histogram array. More...
struct	concluding_histogram_event
	Event representing the final result of histogramming. More...
class	context
	Context for enabling access to objects after they have been incorporated into a processing graph. More...
class	count_access
	Access for tcspc::count() processor data. More...
class	count_data_mapper
	Data mapper mapping count to the data value. More...
struct	data_lost_event
	Event indicating loss of data due to buffer overflow. More...
class	data_validation_error
	Error thrown when the data being processed does not meet expectations. More...
struct	datapoint_event
	Event representing a datapoint for histogramming. More...
struct	default_data_types
	The default data type set. More...
struct	detection_event
	Event indicating a detected count. More...
class	difftime_data_mapper
	Data mapper mapping difference time to the data value. More...
class	dithered_linear_timing_generator
	Timing generator that generates a periodic series of timings, with temporal dithering. More...
class	dithered_one_shot_timing_generator
	Timing generator that generates a single, delayed timing whose abstime is dithered. More...
class	dynamic_dithered_linear_timing_generator
	Timing generator that generates a periodic series of timings, configured by the trigger event, with temporal dithering. More...
class	dynamic_dithered_one_shot_timing_generator
	Timing generator that generates a single, delayed timing, configured by the trigger event, whose abstime is dithered. More...
class	dynamic_linear_timing_generator
	Timing generator that generates an equally spaced series of timings, configured by the trigger event. More...
class	dynamic_one_shot_timing_generator
	Timing generator that generates a single, delayed timing, configured by the trigger event. More...
struct	empty_test_event
	Empty event for testing. More...
struct	end_lost_interval_event
	Event indicating end of interval in which counts were lost. More...
class	end_of_processing
	Exception type used to indicate processor-initiated non-error end of processing. More...
struct	histogram_array_event
	Event representing an array of histograms. More...
struct	histogram_array_progress_event
	Event representing a progress update of a histogram array. More...
struct	histogram_event
	Event representing a single histogram. More...
class	histogram_overflow_error
	Error thrown when a histogram bin overflows. More...
class	input_output_error
	Error thrown when a file or stream could not be accessed. More...
class	linear_bin_mapper
	Bin mapper for linear histograms of arbitrary size. More...
class	linear_timing_generator
	Timing generator that generates an equally spaced series of timings. More...
struct	lost_counts_event
	Event indicating number of counts that could not be time-tagged. More...
struct	marker_event
	Event indicating a timing marker. More...
class	model_fit_error
	Error thrown when a fit to a model did not meet the desired criteria. More...
struct	never_event
	An event type whose instances never occur. More...
class	never_matcher
	Matcher that matches no event. More...
class	new_delete_bucket_source
	Bucket source using regular memory allocation. More...
class	npint
	Non-promoted integers. More...
struct	null_reader
	Acquisition reader that reads an empty stream. More...
class	null_router
	Router that does not route. More...
class	null_sink
	Processor that sinks any event and the end-of-stream and does nothing. More...
class	null_timing_generator
	Timing generator that generates no timings. More...
class	one_shot_timing_generator
	Timing generator that generates a single, delayed timing. More...
struct	parameterized_data_types
	Utility for naming a data type set without additional definitions. More...
struct	periodic_sequence_model_event
	Event representing a summarized model of a periodic sequence of events. More...
struct	power_of_2_bin_mapper
	Bin mapper that discards the least significant bits. More...
struct	pqt2_picoharp300_event
	Binary record interpretation for PicoHarp 300 T2 Format. More...
struct	pqt3_picoharp300_event
	Binary record interpretation for PicoHarp 300 T3 Format. More...
class	processor_graph
	Value type representing a directed acyclic graph of processors. More...
class	processor_info
	Value type representing metadata of a processor. More...
class	processor_node_id
	Value type representing processor identity within a graph. More...
struct	real_linear_timing_event
	Event representing a prescription for linear timing generation with real (fractional) delay and interval. More...
struct	real_one_shot_timing_event
	Event representing a prescription for one-shot timing generation with real (fractional) delay. More...
class	recycling_bucket_source
	Bucket source that reuses storage. More...
class	sharable_new_delete_bucket_source
	Sharable bucket source using regular memory allocation. More...
class	sharable_recycling_bucket_source
	Sharable bucket source that reuses storage. More...
class	source_halted
	Exception type thrown to pumping thread when buffer source was discontinued without reaching the point of flushing. More...
struct	stuck_reader
	Acquisition reader that waits indefinitely without producing data. More...
struct	swabian_tag_event
	Binary record interpretation for 16-byte Swabian time tag. More...
class	test_bucket_source
	Bucket source wrapper for unit testing. More...
class	test_error
	Error thrown when requested to do so for testing purposes. More...
struct	time_correlated_detection_event
	Event indicating a detected count (typically photon) with difference time. More...
struct	time_reached_event
	Event indicating latest abstime reached. More...
struct	time_tagged_test_event
	Timestamped event for testing. More...
class	type_erased_processor
	Processor that type-erases the downstream processor. More...
struct	type_list
	Compile-time representation of a list of types. More...
struct	type_list_intersection
	Metafunction to obtain the intersection of two sets of types. More...
struct	type_list_is_equal_set
	Metafunction to determine if a type list is set-equivalent to another. More...
struct	type_list_is_subset
	Metafunction to determine if a type list is a subset of another. More...
struct	type_list_set_difference
	Metafunction to obtain the set difference of two sets of types. More...
struct	type_list_singleton_element
	Metafunction to obtain the contained type of a singleton type list. More...
struct	type_list_size
	Metafunction to obtain the size (length) of a type list. More...
struct	type_list_union
	Metafunction to obtain the union of two sets of types. More...
class	unique_bin_mapper
	Bin mapper that maps unique datapoints to consecutive bin indices. More...
class	unique_bin_mapper_access
	Access for tcspc::unique_bin_mapper data. More...
struct	unique_type_list
	Metafunction to remove duplicate types from a type list. More...
class	variant_event
	Variant event. More...
struct	warning_event
	An event type indicating a warning. More...

Concepts
concept	const_handler_for
	Concept that is satisfied when a processor handles an event type by const lvalue reference.
concept	convertible_to_type_list_member
	Concept that is satisfied when a type is convertible to at least one of the members of a type list.
concept	flushable
	Concept that is satisfied when a processor handles flushing.
concept	handler_for
	Concept that is satisfied when a processor handles the given event types.
concept	processor
	Concept that is satisfied when a processor handles the given event types and flush.
concept	rvalue_handler_for
	Concept that is satisfied when a processor handles an event type by rvalue reference.
concept	type_list_like
	Concept that is satisfied when a type is a tcspc::type_list specialization.
concept	type_list_member
	Concept that is satisfied when a type is contained in a type list.

Typedefs
using	i16np = npint<i16>
	Non-promoted signed 16-bit integer.
using	i32np = npint<i32>
	Non-promoted signed 32-bit integer.
using	i64np = npint<i64>
	Non-promoted signed 64-bit integer.
using	i8np = npint<i8>
	Non-promoted signed 8-bit integer.
using	pqt2_generic_event = basic_pqt2_event<33554432, false>
	Binary record interpretation for HydraHarp V2, MultiHarp, TimeHarp 260, and PicoHarp 330 "Generic" T2 format.
using	pqt2_hydraharpv1_event = basic_pqt2_event<33552000, true>
	Binary record interpretation for HydraHarp V1 T2 format.
using	pqt3_generic_event = basic_pqt3_event<false>
	Binary record interpretation for HydraHarp V2, MultiHarp, TimeHarp 260, and PicoHarp 330 "Generic" T3 format.
using	pqt3_hydraharpv1_event = basic_pqt3_event<true>
	Binary record interpretation for HydraHarp V1 T3 format.
template<typename TL0, typename TL1>
using	type_list_intersection_t
	Helper type for tcspc::type_list_intersection.
template<typename TL0, typename TL1>
using	type_list_set_difference_t
	Helper type for tcspc::type_list_set_difference.
template<typename TypeList>
using	type_list_singleton_element_t
	Helper type for tcspc::type_list_singleton_element.
template<typename TL0, typename TL1>
using	type_list_union_t = typename type_list_union<TL0, TL1>::type
	Helper type for tcspc::type_list_union.
using	u16np = npint<u16>
	Non-promoted unsigned 16-bit integer.
using	u32np = npint<u32>
	Non-promoted unsigned 32-bit integer.
using	u64np = npint<u64>
	Non-promoted unsigned 64-bit integer.
using	u8np = npint<u8>
	Non-promoted unsigned 8-bit integer.
template<typename TypeList>
using	unique_type_list_t = typename unique_type_list<TypeList>::type
	Helper type for tcspc::unique_type_list.
template<typename EventList>
using	variant_or_single_event
	Select the plain event if single, otherwise tcspc::variant_event.

Enumerations
enum class	emitted_as { emitted_as::any_allowed , emitted_as::same_as_fed , emitted_as::always_lvalue , emitted_as::always_rvalue }
	Value category to check emitted events against. More...
enum class	feed_as { feed_as::const_lvalue , feed_as::rvalue }
	Value category used to feed an event via tcspc::feed_input. More...
enum class	histogram_policy : unsigned {   histogram_policy::default_policy = 0 , histogram_policy::error_on_overflow = 0b00 , histogram_policy::stop_on_overflow = 0b01 , histogram_policy::saturate_on_overflow = 0b10 ,   histogram_policy::reset_on_overflow = 0b11 , histogram_policy::overflow_mask = 0b11 , histogram_policy::emit_concluding_events = 1 << 2 , histogram_policy::reset_after_scan = 1 << 3 ,   histogram_policy::clear_every_scan = 1 << 4 , histogram_policy::no_clear_new_bucket = 1 << 5 }
	Histogramming policy specifying behavior. More...

Functions
template<typename T, typename Reader, typename Downstream>
auto	acquire (Reader reader, std::shared_ptr< bucket_source< T > > buffer_provider, arg::batch_size< std::size_t > batch_size, access_tracker< acquire_access > tracker, Downstream downstream)
	Create a processor that acquires data into buckets.
template<typename T, typename Reader, typename LiveDownstream, typename BatchDownstream>
auto	acquire_full_buckets (Reader reader, std::shared_ptr< bucket_source< T > > buffer_provider, arg::batch_size< std::size_t > batch_size, access_tracker< acquire_access > tracker, LiveDownstream live_downstream, BatchDownstream batch_downstream)
	Create a processor that acquires data into buckets, ensuring that each bucket is filled to a fixed size but also providing views of partial buckets in real time.
template<typename T>
auto	ad_hoc_bucket (std::span< T > s) -> bucket< T >
	Create a tcspc::bucket referencing a span.
template<typename DataTypes = default_data_types, typename Downstream>
auto	add_count_to_periodic_sequences (arg::count< std::size_t > count, Downstream downstream)
	Create a processor that emits a linear timing event based on tcspc::periodic_sequence_model_event by adding a fixed sequence length.
template<typename Event, typename Downstream>
auto	append (Event event, Downstream downstream)
	Create a processor that inserts an event at the end of the stream.
template<typename Event, typename Downstream>
auto	batch (std::shared_ptr< bucket_source< Event > > buffer_provider, arg::batch_size< std::size_t > batch_size, Downstream downstream)
	Create a processor that batches events into buckets for buffering.
template<typename DataTypes = default_data_types, typename Downstream>
auto	batch_bin_increment_clusters (std::shared_ptr< bucket_source< typename DataTypes::bin_index_type > > buffer_provider, arg::bucket_size< std::size_t > bucket_size, arg::batch_size< std::size_t > batch_size, Downstream downstream)
	Create a processor that collects bin increment clusters into encoded batches.
template<typename Event, typename Downstream>
auto	batch_from_bytes (std::shared_ptr< bucket_source< Event > > buffer_provider, Downstream downstream)
	Create a processor that converts batches of bytes into batches of events.
auto	binary_file_input_stream (std::string const &filename, arg::start_offset< u64 > start_offset=arg::start_offset{u64(0)})
	Create a binary input stream for the given file.
auto	binary_file_output_stream (std::string const &filename, arg::truncate< bool > truncate=arg::truncate{false}, arg::append< bool > append=arg::append{false})
	Create a binary output stream for the given file.
auto	borrowed_cfile_input_stream (std::FILE *fp)
	Create an input stream from a non-owned C file pointer.
auto	borrowed_cfile_output_stream (std::FILE *fp)
	Create an output stream from a non-owned C file pointer.
template<typename BroadcastEventList, typename... Downstreams>
auto	broadcast (Downstreams... downstreams)
	Create a processor that broadcasts events to multiple downstream processors.
template<typename... Downstreams>
auto	broadcast_homogeneous (Downstreams... downstreams)
	Create a processor that broadcasts events to multiple downstream processors of the same type.
template<std::size_t N, typename Downstream>
auto	broadcast_homogeneous (std::array< Downstream, N > downstreams)
	Create a processor that broadcasts events to multiple downstream processors of the same type.
template<typename Event, typename Downstream>
auto	buffer (arg::threshold< std::size_t > threshold, access_tracker< buffer_access > &&tracker, Downstream downstream)
	Create a processor that buffers events and emits them on a different thread.
template<typename EventList>
auto	capture_output (access_tracker< capture_output_access > &&tracker)
	Create a sink that records the output of a processor under test.
template<typename Event0, typename Event1, typename Downstream>
auto	check_alternating (Downstream downstream)
	Create a processor that checks that events of two types appear in alternation.
template<typename DataTypes = default_data_types, bool RequireStrictlyIncreasing = false, typename Downstream>
auto	check_monotonic (Downstream downstream)
	Create a processor that checks that abstime is monotonically increasing or nondecreasing.
template<typename StartEvent, typename StopEvent, typename DataTypes = default_data_types, typename Downstream>
auto	cluster_bin_increments (Downstream downstream)
	Create a processor collecting binned data into clusters.
template<typename TickEvent, typename StartEvent, typename StopEvent, typename Downstream>
auto	convert_sequences_to_start_stop (arg::count< std::size_t > count, Downstream downstream)
	Create a processor that converts sequences of ticks to sequences of start-stop event pairs with no gaps.
template<typename T, typename Downstream>
auto	copy_to_buckets (std::shared_ptr< bucket_source< T > > buffer_provider, Downstream downstream)
	Create a processor that copies batches of data into buckets.
template<typename T, typename LiveDownstream, typename BatchDownstream>
auto	copy_to_full_buckets (std::shared_ptr< bucket_source< T > > buffer_provider, arg::batch_size< std::size_t > batch_size, LiveDownstream live_downstream, BatchDownstream batch_downstream)
	Create a processor that copies data into buckets, ensuring that each bucket is filled to a fixed size but also providing views of partial buckets in real time.
template<typename Event, typename Downstream>
auto	count (access_tracker< count_access > &&tracker, Downstream downstream)
	Create a processor that counts events of a given type.
template<typename TickEvent, typename FireEvent, typename ResetEvent, bool FireAfterTick, typename Downstream>
auto	count_down_to (arg::threshold< u64 > threshold, arg::limit< u64 > limit, arg::initial_count< u64 > initial_count, Downstream downstream)
	Like tcspc::count_up_to(), but decrement the count on each tick event.
template<typename TickEvent, typename FireEvent, typename ResetEvent, bool FireAfterTick, typename Downstream>
auto	count_up_to (arg::threshold< u64 > threshold, arg::limit< u64 > limit, arg::initial_count< u64 > initial_count, Downstream downstream)
	Create a processor that counts a specific event and emits an event when the count reaches a threshold.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_bh_spc (Downstream downstream)
	Create a processor that decodes FIFO records from most Becker & Hickl SPC models.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_bh_spc600_256ch (Downstream downstream)
	Create a processor that decodes 32-bit FIFO records from Becker & Hickl SPC-600/630 in 256-channel mode.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_bh_spc600_4096ch (Downstream downstream)
	Create a processor that decodes 48-bit FIFO records from Becker & Hickl SPC-600/630 in 4096-channel mode.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_bh_spc_with_intensity_counter (Downstream downstream)
	Create a processor that decodes FIFO records from Becker & Hickl SPC-160 and SPC-180N with fast intensity counter.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_pqt2_generic (Downstream downstream)
	Create a processor that decodes PicoQuant HydraHarp V2, MultiHarp, TimeHarp 260, and PicoHarp 330 "Generic" T2 events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_pqt2_hydraharpv1 (Downstream downstream)
	Create a processor that decodes PicoQuant HydraHarp V1 T2 events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_pqt2_picoharp300 (Downstream downstream)
	Create a processor that decodes PicoQuant PicoHarp 300 T2 events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_pqt3_generic (Downstream downstream)
	Create a processor that decodes PicoQuant HydraHarp V2, MultiHarp, TimeHarp 260, and PicoHarp 330 "Generic" T3 events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_pqt3_hydraharpv1 (Downstream downstream)
	Create a processor that decodes PicoQuant HydraHarp V1 T3 events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_pqt3_picoharp300 (Downstream downstream)
	Create a processor that decodes PicoQuant PicoHarp 300 T3 events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	decode_swabian_tags (Downstream downstream)
	Create a processor that decodes Swabian Tag events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	delay (arg::delta< typename DataTypes::abstime_type > delta, Downstream downstream)
	Create a processor that applies an abstime offset to all events.
template<typename Downstream>
auto	demultiplex (Downstream downstream)
	Create a processor that transforms an event variant type back to individual event types.
template<typename Event, typename Downstream>
auto	extract_bucket (Downstream downstream)
	Create a processor that extracts the bucket carried by an event.
template<typename DataTypes = default_data_types, typename Downstream>
auto	extrapolate_periodic_sequences (arg::tick_index< std::size_t > tick_index, Downstream downstream)
	Create a processor that emits an extrapolated one-shot timing event based on tcspc::periodic_sequence_model_event.
template<typename Downstream>
auto	feed_input (feed_as value_category, Downstream downstream)
	Create a source for feeding test input to a processor under test.
template<typename Event, typename DataTypes = default_data_types, typename Downstream>
auto	fit_periodic_sequences (arg::length< std::size_t > length, arg::min_interval< double > min_interval, arg::max_interval< double > max_interval, arg::max_mse< double > max_mse, Downstream downstream)
	Create a processor that fits fixed-length periodic sequences of events and estimates the start time and interval.
template<typename Event>
auto	from_reversed_bytes (std::array< std::uint8_t, sizeof(Event)> bytes) noexcept
	Bit-cast an array of bytes to an event after reversing the order.
template<typename GatedEventList, typename OpenEvent, typename CloseEvent, typename Downstream>
auto	gate (arg::initially_open< bool > initially_open, Downstream downstream)
	Create a processor that gates events depending on current state.
template<typename TriggerEvent, typename OutputEvent, typename TimingGenerator, typename Downstream>
auto	generate (TimingGenerator generator, Downstream downstream)
	Create a processor that generates a pattern of timing events in response to a trigger.
auto	graphviz_from_processor_graph (processor_graph const &graph) -> std::string
	Return a Graphviz dot representation of a processor graph.
template<histogram_policy Policy = histogram_policy::default_policy, typename ResetEvent = never_event, typename DataTypes = default_data_types, typename Downstream>
auto	histogram (arg::num_bins< std::size_t > num_bins, arg::max_per_bin< typename DataTypes::bin_type > max_per_bin, std::shared_ptr< bucket_source< typename DataTypes::bin_type > > buffer_provider, Downstream downstream)
	Create a processor that collects a histogram.
template<typename IStream>
auto	istream_input_stream (IStream stream)
	Create an input stream from an std::istream instance.
template<typename DataTypes = default_data_types, typename BinMapper, typename Downstream>
auto	map_to_bins (BinMapper bin_mapper, Downstream downstream)
	Create a processor that maps datapoints to histogram bin indices.
template<typename Event, typename DataTypes = default_data_types, typename DataMapper, typename Downstream>
auto	map_to_datapoints (DataMapper mapper, Downstream downstream)
	Create a processor that maps arbitrary time-tagged events to datapoint events.
template<typename Event, typename OutEvent, typename Matcher, typename Downstream>
auto	match (Matcher matcher, Downstream downstream)
	Create a processor that detects events matching a criterion.
template<typename Event, typename OutEvent, typename Matcher, typename Downstream>
auto	match_replace (Matcher matcher, Downstream downstream)
	Like tcspc::match(), but do not pass through matched events.
template<typename EventList, typename DataTypes = default_data_types, typename Downstream>
auto	merge (arg::max_buffered< std::size_t > max_buffered, Downstream downstream)
	Create a pair of processors that merge two event streams.
template<std::size_t N, typename EventList, typename DataTypes = default_data_types, typename Downstream>
auto	merge_n (arg::max_buffered< std::size_t > max_buffered, Downstream downstream)
	Create a processor that merges a given number of event streams.
template<std::size_t N = 2, typename Downstream>
auto	merge_n_unsorted (Downstream downstream)
	Create a processor that merges a given number of event streams without sorting by abstime.
auto	merge_processor_graphs (processor_graph const &a, processor_graph const &b) -> processor_graph
	Create a new processor graph by merging two existing ones.
template<typename EventList, typename Downstream>
auto	multiplex (Downstream downstream)
	Create a processor that passes events as a single variant type.
template<typename DataTypes = default_data_types, typename Downstream>
auto	negate_difftime (Downstream downstream)
	Create a processor that changes the sign of difftime in time-correlated detection events.
auto	null_input_stream ()
	Create an input stream that contains no bytes.
auto	null_output_stream ()
	Create an output stream that discards all written bytes.
template<typename Downstream>
auto	null_source (Downstream downstream)
	Create a processor that sources an empty stream.
template<typename DataTypes>
auto	operator<< (std::ostream &s, std::array< detection_event< DataTypes >, 2 > const &e) -> std::ostream &
	Stream insertion operator for tcspc::detection_event pairs.
template<typename OStream>
auto	ostream_output_stream (OStream stream)
	Create an output stream from an std::ostream instance.
auto	owning_cfile_input_stream (std::FILE *fp)
	Create an input stream from a C file pointer, taking ownership.
auto	owning_cfile_output_stream (std::FILE *fp)
	Create an output stream from a C file pointer, taking ownership.
template<std::size_t NStopChannels, typename DataTypes = default_data_types, typename Downstream>
auto	pair_all (arg::start_channel< typename DataTypes::channel_type > start_channel, std::array< typename DataTypes::channel_type, NStopChannels > stop_channels, arg::time_window< typename DataTypes::abstime_type > time_window, Downstream downstream)
	Create a processor that generates all ordered pairs of detection events within a time window.
template<std::size_t NStopChannels, typename DataTypes = default_data_types, typename Downstream>
auto	pair_all_between (arg::start_channel< typename DataTypes::channel_type > start_channel, std::array< typename DataTypes::channel_type, NStopChannels > stop_channels, arg::time_window< typename DataTypes::abstime_type > time_window, Downstream downstream)
	Create a processor that generates ordered pairs of detection events within a time window, pairing only the last eligible start event with each stop event.
template<std::size_t NStopChannels, typename DataTypes = default_data_types, typename Downstream>
auto	pair_one (arg::start_channel< typename DataTypes::channel_type > start_channel, std::array< typename DataTypes::channel_type, NStopChannels > stop_channels, arg::time_window< typename DataTypes::abstime_type > time_window, Downstream downstream)
	Create a processor that generates ordered pairs of detection events within a time window, pairing only the first eligible stop event with each start event.
template<std::size_t NStopChannels, typename DataTypes = default_data_types, typename Downstream>
auto	pair_one_between (arg::start_channel< typename DataTypes::channel_type > start_channel, std::array< typename DataTypes::channel_type, NStopChannels > stop_channels, arg::time_window< typename DataTypes::abstime_type > time_window, Downstream downstream)
	Create a processor that generates ordered pairs of detection events within a time window, pairing only a start event with a stop event such that no start events, or stop events on the same channel, occur in between.
template<typename Event, typename Downstream>
auto	prepend (Event event, Downstream downstream)
	Create a processor that inserts an event at the beginning of the stream.
template<typename Event, typename Downstream>
auto	process_in_batches (arg::batch_size< std::size_t > batch_size, Downstream downstream)
	Create a processor that buffers events up to equally sized batches and passes them downstream in a tight loop.
template<typename Event, typename InputStream, typename Downstream>
auto	read_binary_stream (InputStream stream, arg::max_length< std::uint64_t > max_length, std::shared_ptr< bucket_source< Event > > buffer_provider, arg::granularity< std::size_t > granularity, Downstream downstream)
	Create a source that reads batches of events from a binary stream, such as a file.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_i16le_at (std::span< T, N > bytes) noexcept -> i16np
	Read a little-endian 16-bit signed integer from bytes at offset.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_i32le_at (std::span< T, N > bytes) noexcept -> i32np
	Read a little-endian 32-bit signed integer from bytes at offset.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_i64le_at (std::span< T, N > bytes) noexcept -> i64np
	Read a little-endian 64-bit signed integer from bytes at offset.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_i8_at (std::span< T, N > bytes) noexcept -> i8np
	Read an 8-bit signed integer from bytes at offset.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_u16le_at (std::span< T, N > bytes) noexcept -> u16np
	Read a little-endian 16-bit unsigned integer from bytes at offset.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_u32le_at (std::span< T, N > bytes) noexcept -> u32np
	Read a little-endian 32-bit unsigned integer from bytes at offset.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_u64le_at (std::span< T, N > bytes) noexcept -> u64np
	Read a little-endian 64-bit unsigned integer from bytes at offset.
template<std::size_t Offset, std::convertible_to< std::byte > T, std::size_t N>
constexpr auto	read_u8_at (std::span< T, N > bytes) noexcept -> u8np
	Read an 8-bit unsigned integer from bytes at offset.
template<typename Event, typename Rep, typename Period, typename Downstream>
auto	real_time_buffer (arg::threshold< std::size_t > threshold, std::chrono::duration< Rep, Period > latency_limit, access_tracker< buffer_access > &&tracker, Downstream downstream)
	Create a processor that buffers events and emits them on a different thread, with limited latency.
template<typename EventList, typename DataTypes = default_data_types, typename Downstream>
auto	recover_order (arg::time_window< typename DataTypes::abstime_type > time_window, Downstream downstream)
	Create a processor that sorts events by abstime, provided that they are out of order only within a bounded time window.
template<typename DataTypes = default_data_types, typename Downstream>
auto	regulate_time_reached (arg::interval_threshold< typename DataTypes::abstime_type > interval_threshold, arg::count_threshold< std::size_t > count_threshold, Downstream downstream)
	Create a processor that regulates the frequency of time-reached events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	remove_time_correlation (Downstream downstream)
	Create a processor that removes the difftime from detection events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	retime_periodic_sequences (arg::max_time_shift< typename DataTypes::abstime_type > max_time_shift, Downstream downstream)
	Create a processor that adjusts the abstime of tcspc::periodic_sequence_model_event to be earlier than the modeled sequence.
template<typename RoutedEventList, typename BroadcastEventList = type_list<>, typename Router, typename... Downstreams>
auto	route (Router router, Downstreams... downstreams)
	Create a processor that routes events to different downstreams.
template<typename RoutedEventList, typename Router, typename... Downstreams>
auto	route_homogeneous (Router router, Downstreams... downstreams)
	Create a processor that routes events to multiple downstreams of the same type.
template<typename RoutedEventList, typename Router, std::size_t N, typename Downstream>
auto	route_homogeneous (Router router, std::array< Downstream, N > downstreams)
	Create a processor that routes events to multiple downstreams of the same type.
template<histogram_policy Policy = histogram_policy::default_policy, typename ResetEvent = never_event, typename DataTypes = default_data_types, typename Downstream>
auto	scan_histograms (arg::num_elements< std::size_t > num_elements, arg::num_bins< std::size_t > num_bins, arg::max_per_bin< typename DataTypes::bin_type > max_per_bin, std::shared_ptr< bucket_source< typename DataTypes::bin_type > > buffer_provider, Downstream downstream)
	Create a processor that scans over an array of histograms, updating each with the received bin increment clusters.
template<typename EventList, typename Downstream>
auto	select (Downstream downstream)
	Create a processor that passes a given set of events and discards others.
template<typename Downstream>
auto	select_all (Downstream downstream)
	Create a processor that passes all events.
template<typename Downstream>
auto	select_none (Downstream downstream)
	Create a processor that passes no events.
template<typename EventList, typename Downstream>
auto	select_not (Downstream downstream)
	Create a processor that discards a given set of events and passes others.
template<typename EventList>
auto	sink_event_list ()
	Create a processor that ignores only specific event types.
template<typename... Event>
auto	sink_events ()
	Create a processor that ignores only specific event types.
template<typename EventList, typename Downstream>
auto	stop (std::string message_prefix, Downstream downstream)
	Create a processor that ends the stream when a given event type is received.
template<typename EventList, typename Exception = std::runtime_error, typename Downstream>
auto	stop_with_error (std::string message_prefix, Downstream downstream)
	Create a processor that ends the stream with an error when a given event type is received.
template<typename T>
auto	test_bucket (std::initializer_list< T > il) -> bucket< T >
	Create an ad-hoc tcspc::bucket<T> for testing, from a list of values.
template<typename T>
auto	test_bucket (std::span< T > s) -> bucket< T >
	Create an ad-hoc tcspc::bucket<T> for testing, from a span.
template<typename DataTypes = default_data_types, bool UseStartChannel = false, typename Downstream>
auto	time_correlate_at_fraction (arg::fraction< double > fraction, Downstream downstream)
	Create a processor that collapses detection pairs into time-correlated detection events at a fractional dividing point between the start and stop times of the pair.
template<typename DataTypes = default_data_types, bool UseStartChannel = false, typename Downstream>
auto	time_correlate_at_midpoint (Downstream downstream)
	Create a processor that collapses detection pairs into time-correlated detection events at the midpoint between the start and stop times of the pair.
template<typename DataTypes = default_data_types, typename Downstream>
auto	time_correlate_at_start (Downstream downstream)
	Create a processor that collapses detection pairs into time-correlated detection events at the start time of the pair.
template<typename DataTypes = default_data_types, typename Downstream>
auto	time_correlate_at_stop (Downstream downstream)
	Create a processor that collapses detection pairs into time-correlated detection events at the stop time of the pair.
template<typename ContainerEvent, typename Downstream>
auto	unbatch (Downstream downstream)
	Create a processor transforming batches of events to individual events.
template<typename DataTypes = default_data_types, typename Downstream>
auto	unbatch_bin_increment_clusters (Downstream downstream)
	Create a processor that splits encoded batches of bin increment clusters into individual clusters.
template<typename Event, typename Downstream>
auto	unbatch_from_bytes (Downstream downstream)
	Create a processor that converts batches of bytes into individual events.
template<typename Downstream>
auto	view_as_bytes (Downstream downstream)
	Create a processor that views events as byte spans.
template<typename Visitor, typename EventList>
constexpr auto	visit_variant_or_single_event (Visitor &&visitor, variant_event< EventList > &&event)
	Apply a visitor to a tcspc::variant_event (rvalue).
template<typename Visitor, typename EventList>
constexpr auto	visit_variant_or_single_event (Visitor &&visitor, variant_event< EventList > &event)
	Apply a visitor to a tcspc::variant_event (lvalue).
template<typename Visitor, typename EventList>
constexpr auto	visit_variant_or_single_event (Visitor &&visitor, variant_event< EventList > const &event)
	Apply a visitor to a tcspc::variant_event (const lvalue).
template<typename Visitor, typename Event>
constexpr auto	visit_variant_or_single_event (Visitor visitor, Event &&event)
	Apply a visitor to an event that is not a tcspc::variant_event.
template<typename OutputStream>
auto	write_binary_stream (OutputStream stream, std::shared_ptr< bucket_source< std::byte > > buffer_provider, arg::granularity< std::size_t > granularity)
	Create a sink that writes bytes to a binary stream, such as a file.
template<typename DataTypes = default_data_types, typename Downstream>
auto	zero_base_abstime (Downstream downstream)
	Create a processor that offsets abstime so that the first event is at time zero.

Variables
template<typename Proc, typename EventList>
constexpr bool	handles_event_list_v
	Trait variable to check whether a processor handles a list of event types.
template<typename Proc, typename EventList>
constexpr bool	is_processor_of_list_v
	Trait variable to check whether a processor handles a list of event types and flush.
template<typename TL0, typename TL1>
constexpr bool	type_list_is_equal_set_v
	Helper variable template for tcspc::type_list_is_equal_set.
template<typename TL0, typename TL1>
constexpr bool	type_list_is_subset_v
	Helper variable template for tcspc::type_list_is_subset.
template<typename TypeList>
constexpr std::size_t	type_list_size_v
	Helper variable template for tcspc::type_list_size.