tim::bundle< Tag, BundleT, TupleT > Class Template Reference

Example: bundle<Tag, component_bundle<Foo>, mixed_wrapper_types<concat<Bar, Baz>>> will use Tag + trait::is_available<Tag> or trait::runtime_available<Tag> to disable this bundle at compile-time or run-time, respectively. It will covert component_bundle<Foo> to component_bundle<Foo, Bar, Baz> for purposes of function signatures and it will instantiate std::tuple<...> depending on the compile-time availability of Bar and Baz. mixed_wrapper_types is a dummy type with the appropriate aliases to perform these conversions. Here is a theoretical implementation of mixed_wrapper_types (which supports allocating components on the stack and the heap): More...

#include "timemory/variadic/bundle.hpp"

Collaboration diagram for tim::bundle< Tag, BundleT, TupleT >:

Public Types
using	captured_location_t = source_location::captured
using	this_type = typename TupleT::template this_type< BundleT >
using	type = typename TupleT::template type< BundleT >
using	component_type = typename TupleT::template component_type< BundleT >
using	data_type = typename TupleT::template data_type< Tag >
using	type_list_type = typename TupleT::type_list_type
using	value_type = data_type
using	size_type = typename bundle_type::size_type
using	initializer_type = std::function< void(this_type &)>
using	transient_func_t = utility::transient_function< void(this_type &)>
template<typename T , typename... U>
using	quirk_config = tim::variadic::impl::quirk_config< T, reference_type, U... >
using	base_bundle_type = conditional_t< trait::is_available< Tag >::value, impl::base_bundle< Tag, remove_pointer_t< Types >... >, impl::base_bundle< Tag, std::tuple<> > >
using	tuple_type = data_type
using	impl_type = data_type

Public Member Functions
	bundle ()
template<typename... T>
	bundle (const string_t &_key, quirk::config< T... >, transient_func_t=get_initializer())
template<typename... T>
	bundle (hash_value_t _hash, quirk::config< T... >, transient_func_t=get_initializer())
template<typename... T>
	bundle (const captured_location_t &_loc, quirk::config< T... >, transient_func_t=get_initializer())
template<typename... T>
	bundle (const string_t &_key, bool _store, quirk::config< T... >, transient_func_t=get_initializer())
template<typename... T>
	bundle (const captured_location_t &_loc, bool _store, quirk::config< T... >, transient_func_t=get_initializer())
	bundle (hash_value_t _hash, bool _store=true, scope::config _scope=scope::get_default(), transient_func_t=get_initializer())
	bundle (const string_t &_key, bool _store=true, scope::config _scope=scope::get_default(), transient_func_t=get_initializer())
	bundle (const captured_location_t &_loc, bool _store=true, scope::config _scope=scope::get_default(), transient_func_t=get_initializer())
	bundle (hash_value_t _hash, scope::config _scope, transient_func_t=get_initializer())
	bundle (const string_t &_key, scope::config _scope, transient_func_t=get_initializer())
	bundle (const captured_location_t &_loc, scope::config _scope, transient_func_t=get_initializer())
	~bundle ()
	bundle (const bundle &rhs)
	bundle (bundle &&)=default
bundle &	operator= (const bundle &rhs)
bundle &	operator= (bundle &&)=default
this_type &	operator-= (const this_type &rhs)
this_type &	operator+= (const this_type &rhs)
template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>
this_type &	operator-= (Op &&rhs)
template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>
this_type &	operator+= (Op &&rhs)
template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>
this_type &	operator*= (Op &&rhs)
template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>
this_type &	operator/= (Op &&rhs)
bundle	clone (bool store, scope::config _scope=scope::get_default())
this_type &	push ()
	tells each component to push itself into the call-stack hierarchy More...
this_type &	pop ()
	tells each component to pop itself off of the call-stack hierarchy More...
template<typename... Tp>
this_type &	push (mpl::piecewise_select< Tp... >)
	selective push More...
template<typename... Tp>
this_type &	push (mpl::piecewise_ignore< Tp... >)
	selective push More...
template<typename... Tp>
this_type &	push (mpl::piecewise_select< Tp... >, scope::config)
	selective push with scope configuration More...
template<typename... Tp>
this_type &	push (mpl::piecewise_ignore< Tp... >, scope::config)
	selective push with scope configuration More...
template<typename... Tp>
this_type &	pop (mpl::piecewise_select< Tp... >)
	selective pop More...
template<typename... Tp>
this_type &	pop (mpl::piecewise_ignore< Tp... >)
	selective pop More...
template<typename... Args>
this_type &	measure (Args &&...)
	requests each component record a measurment More...
template<typename... Args>
this_type &	sample (Args &&...)
	requests each component take a sample (if supported) More...
template<typename... Args>
this_type &	start (Args &&...)
	invokes start on all the components More...
template<typename... Args>
this_type &	stop (Args &&...)
	invokes stop on all the components More...
template<typename... Args>
this_type &	record (Args &&...)
	requests each component perform a measurement More...
template<typename... Args>
this_type &	reset (Args &&...)
	invokes reset member function on all the components More...
template<typename... Args>
this_type &	start (mpl::lightweight, Args &&...)
	variant of start() which excludes push() More...
template<typename... Args>
this_type &	stop (mpl::lightweight, Args &&...)
	variant of stop() which excludes pop() More...
template<typename... Tp, typename... Args>
this_type &	start (mpl::piecewise_select< Tp... >, Args &&...)
	variant of start() which only gets applied to Tp types More...
template<typename... Tp, typename... Args>
this_type &	start (mpl::piecewise_ignore< Tp... >, Args &&...)
	variant of start() which gets applied to non-Tp types More...
template<typename... Tp, typename... Args>
this_type &	stop (mpl::piecewise_select< Tp... >, Args &&...)
	variant of stop() which only gets applied to Tp types More...
template<typename... Tp, typename... Args>
this_type &	stop (mpl::piecewise_ignore< Tp... >, Args &&...)
	variant of stop() which gets applied to non-Tp types More...
uint64_t	count ()
	number of objects that will be performing measurements More...
template<typename FuncT , typename... Args>
decltype(auto)	execute (FuncT &&func, Args &&... args)
	when chaining together operations, this function enables executing a function inside the chain More...
template<typename... Args>
this_type &	construct (Args &&... _args)
	construct the objects that have constructors with matching arguments More...
template<typename... Args>
this_type &	assemble (Args &&... _args)
	provide preliminary info to the objects with matching arguments. This is typically used to notify a component that it has been bundled alongside another component that it can extract data from. More...
template<typename... Args>
this_type &	derive (Args &&... _args)
	provide conclusive info to the objects with matching arguments. This is typically used by components to extract data from another component it has been bundled alongside, e.g. the cpu_util component can extract data from tim::component::wall_clock and tim::component::cpu_clock More...
template<typename... Args>
this_type &	mark (Args &&... _args)
	mark an atomic event More...
template<typename... Args>
this_type &	mark_begin (Args &&... _args)
	mark a beginning position in the execution (typically used by asynchronous structures) More...
template<typename... Args>
this_type &	mark_end (Args &&... _args)
	mark a beginning position in the execution (typically used by asynchronous structures) More...
template<typename... Args>
this_type &	store (Args &&... _args)
	store a value More...
template<typename... Args>
this_type &	audit (Args &&... _args)
	allow the components to inspect the incoming arguments before start or out-going return value before returning (typically using in GOTCHA components) More...
template<typename... Args>
this_type &	add_secondary (Args &&... _args)
	perform an add_secondary operation. This operation allows components to add additional entries to storage which are their direct descendant More...
template<typename... Args>
this_type &	update_statistics (Args &&... _args)
	perform an add_secondary operation. This operation allows components to add additional entries to storage which are their direct descendant More...
template<template< typename > class OpT, typename... Args>
this_type &	invoke (Args &&... _args)
	generic member function for invoking user-provided operations More...
template<template< typename > class OpT, typename... Tp, typename... Args>
this_type &	invoke (mpl::piecewise_select< Tp... >, Args &&... _args)
	generic member function for invoking user-provided operations on a specific set of component types More...
template<template< typename > class OpT, typename... Tp, typename... Args>
this_type &	invoke (mpl::piecewise_ignore< Tp... >, Args &&... _args)
	generic member function for invoking user-provided operations on all types that are not listed More...
template<bool PrintPrefix = true, bool PrintLaps = true>
this_type &	print (std::ostream &os, bool _endl=false) const
template<typename... Args>
auto	get (Args &&...) const
	returns a tuple of invoking get() on all the components More...
template<typename... Args>
auto	get_labeled (Args &&...) const
	returns a tuple of the component label + invoking get() on all the components More...
data_type &	data ()
	returns a reference to the underlying tuple of components More...
const data_type &	data () const
	returns a const reference to the underlying tuple of components More...
template<typename U >
decltype(auto)	get ()
	get a component from the bundle More...
template<typename U >
decltype(auto)	get () const
	get a component from the bundle More...
template<typename U , typename FuncT >
decltype(auto)	get (FuncT &&)
	get a component from the bundle and apply function if the pointer is valid More...
template<typename U , typename FuncT >
decltype(auto)	get (FuncT &&) const
	get a component from the bundle More...
this_type &	get (void *&ptr, hash_value_t _hash) const
	performs an opaque search. Opaque searches are generally provided by user_bundles with a functor such as this: More...
template<typename U >
auto	get_component (enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U >, data_type >::value, int >=0)
	this is a simple alternative to get<T>() when used from SFINAE in operation namespace which has a struct get also templated. Usage there can cause error with older compilers More...
template<typename U >
auto	get_component (enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U > *, data_type >::value, int >=0)
template<typename U >
auto &	get_reference (enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U >, data_type >::value, int >=0)
	returns a reference from a stack component instead of a pointer More...
template<typename U >
auto &	get_reference (enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U > *, data_type >::value, int >=0)
	returns a reference from a heap component instead of a pointer More...
template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>
enable_if_t< will_heap_init< T >() &&!will_opaque_init< T >(), bool >	init (Args &&... _args, enable_if_t< is_constructible< T, Args... >(), int >=0)
	create an optional type that is in variadic list AND is available AND accepts arguments More...
template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>
enable_if_t< will_heap_init< T >() &&!will_opaque_init< T >(), bool >	init (Args &&..., enable_if_t<!is_constructible< T, Args... >() &&is_default_constructible< T >(), long >=0)
	create an optional type that is in variadic list AND is available but is not constructible with provided arguments More...
template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>
bool	init (Args &&... _args, enable_if_t< can_stack_init< T >(), int >=0)
	try to re-create a stack object with provided arguments More...
template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>
bool	init (Args &&..., enable_if_t< will_opaque_init< T >(), long >=0)
	if a type is not in variadic list but a tim::component::user_bundle is available, add it in there More...
template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>
enable_if_t<!trait::is_available< T >::value||!(is_one_of< T *, data_type >::value||is_one_of< T, data_type >::value||bundle_type::has_user_bundle_v), bool >	init (Args &&...)
	do nothing if type not available, not one of the variadic types, and there is no user bundle available More...
template<typename... T, typename... Args>
std::array< bool, sizeof...(T)>	initialize (Args &&... args)
	variadic initialization More...
template<typename... Tail>
this_type &	disable ()
	delete any optional types currently allocated More...
template<typename T , typename Func , typename... Args, enable_if_t< is_one_of< T, data_type >::value, int > = 0>
this_type &	type_apply (Func &&_func, Args &&... _args)
	apply a member function to a stack type that is in variadic list AND is available More...
template<typename T , typename Func , typename... Args, enable_if_t< trait::is_available< T >::value, int > = 0>
this_type &	type_apply (Func &&_func, Args &&... _args)
	apply a member function to either a heap type or a type that is in a user_bundle More...
template<typename T , typename Func , typename... Args, enable_if_t<!trait::is_available< T >::value, int > = 0>
this_type &	type_apply (Func &&, Args &&...)
	ignore applying a member function because the type is not present More...
void	set_prefix (const string_t &) const
this_type &	set_prefix (hash_value_t) const
this_type &	set_prefix (captured_location_t) const
this_type &	set_scope (scope::config)
void	rekey (const string_t &_key)
void	rekey (captured_location_t _loc)
void	rekey (uint64_t _hash)
scope::transient_destructor	get_scope_destructor ()
	returns a stack-object for calling stop More...
scope::transient_destructor	get_scope_destructor (utility::transient_function< void(this_type &)>)
	returns a stack-object for calling some member functions when the scope is exited. More...
const data_type &	get_data () const
template<typename Archive >
void	serialize (Archive &ar, const unsigned int)
template<typename... Tp>
bundle< Tag, BundleT, TupleT >::this_type &	push (mpl::piecewise_select< Tp... >)
template<typename... Tp>
bundle< Tag, BundleT, TupleT >::this_type &	push (mpl::piecewise_ignore< Tp... >)
template<typename... Tp>
bundle< Tag, BundleT, TupleT >::this_type &	push (mpl::piecewise_select< Tp... >, scope::config _scope)
template<typename... Tp>
bundle< Tag, BundleT, TupleT >::this_type &	push (mpl::piecewise_ignore< Tp... >, scope::config _scope)
template<typename... Tp>
bundle< Tag, BundleT, TupleT >::this_type &	pop (mpl::piecewise_select< Tp... >)
template<typename... Tp>
bundle< Tag, BundleT, TupleT >::this_type &	pop (mpl::piecewise_ignore< Tp... >)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	measure (Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	sample (Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	start (mpl::lightweight, Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	stop (mpl::lightweight, Args &&... args)
template<typename... Tp, typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	start (mpl::piecewise_select< Tp... >, Args &&... args)
template<typename... Tp, typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	start (mpl::piecewise_ignore< Tp... >, Args &&... args)
template<typename... Tp, typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	stop (mpl::piecewise_select< Tp... >, Args &&... args)
template<typename... Tp, typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	stop (mpl::piecewise_ignore< Tp... >, Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	start (Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	stop (Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	record (Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	reset (Args &&... args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	construct (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	assemble (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	derive (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	mark (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	mark_begin (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	mark_end (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	store (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	audit (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	add_secondary (Args &&... _args)
template<typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	update_statistics (Args &&... _args)
template<template< typename > class OpT, typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	invoke (Args &&... _args)
template<template< typename > class OpT, typename... Tp, typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	invoke (mpl::piecewise_select< Tp... >, Args &&... _args)
template<template< typename > class OpT, typename... Tp, typename... Args>
bundle< Tag, BundleT, TupleT >::this_type &	invoke (mpl::piecewise_ignore< Tp... >, Args &&... _args)
template<typename... Args>
auto	get (Args &&... args) const
template<typename... Args>
auto	get_labeled (Args &&... args) const
template<typename... Tail>
bundle< Tag, BundleT, TupleT >::this_type &	disable ()
template<typename T , typename Func , typename... Args, enable_if_t< trait::is_available< T >::value, int > >
bundle< Tag, BundleT, TupleT >::this_type &	type_apply (Func &&_func, Args &&... _args)
template<typename T , typename Func , typename... Args, enable_if_t<!trait::is_available< T >::value, int > >
bundle< Tag, BundleT, TupleT >::this_type &	type_apply (Func &&, Args &&...)
template<bool PrintPrefix, bool PrintLaps>
bundle< Tag, BundleT, TupleT >::this_type &	print (std::ostream &os, bool _endl) const

Static Public Member Functions
static initializer_type &	get_initializer ()
template<typename U >
static constexpr bool	is_this_type ()
	Query whether type matches this_type. More...
static constexpr bool	has_user_bundle ()
	Query at compile-time whether a user_bundle exists in the set of components. user_bundle are more restricted versions of component bundlers but allow runtime insertion of components. More...
template<typename U >
static constexpr bool	can_stack_init ()
	Query at compile-time whether initialization can occur on the stack. More...
template<typename U >
static constexpr bool	can_heap_init ()
	Query at compile-time whether initialization can occur on the heap. More...
template<typename U >
static constexpr bool	can_placement_init ()
	Query at compile-time whether initialization can occur via a placement new. Placement new init allows for the combination of optional initialization without a heap allocation. Not currently available. More...
template<typename U >
static constexpr bool	can_init ()
	Query at compile-time whether the specified type can be initialized. More...
template<typename U >
static constexpr bool	will_heap_init ()
	Query at compile-time whether initialization will occur on the heap. can_heap_init<T>() && !will_heap_init<T>() will indicate that a stack-allocated instance of the same type exists. More...
template<typename U >
static constexpr bool	will_opaque_init ()
	Query at compile-time whether initialization will happen with an opaque wrapper (i.e. via user bundle). In this situation, initialization arguments are ignored and the component will only be initialized with the tim::scope::config of the bundle. More...
template<typename U , typename... Args, typename T = remove_pointer_decay_t<U>, enable_if_t< trait::is_available< T >::value > = 0>
static constexpr bool	is_constructible ()
	Query at compile-time whether type can be constructed with the given argument types. if type is not available, then it probably won't be defined, so this places the trait::is_available<T> check in the template parameters and the std::is_constructible<T, ...> in the body to avoid undefined behavior. More...
template<typename U , typename... Args, typename T = remove_pointer_decay_t<U>, enable_if_t<!trait::is_available< T >::value > = 0>
static constexpr bool	is_constructible ()
	Return false if the type is not available. More...
template<typename U , typename T = remove_pointer_decay_t<U>, enable_if_t< trait::is_available< T >::value > = 0>
static constexpr bool	is_default_constructible ()
	Query at compile-time whether type supports default construction. If type is not available, then it probably won't be defined, so this places the trait::is_available<T> check in the template parameters and the std::is_constructible<T, ...> in the body to avoid undefined behavior. More...
template<typename U , typename T = remove_pointer_decay_t<U>, enable_if_t<!trait::is_available< T >::value > = 0>
static constexpr bool	is_default_constructible ()
	Return false if the type is not available. More...
static void	init_storage ()
	requests the component initialize their storage More...
static constexpr uint64_t	fixed_count ()
	query the number of (compile-time) fixed components More...
static constexpr uint64_t	optional_count ()
	query the number of (run-time) optional components More...

Protected Types
using	apply_v = mpl::apply< void >
using	bundle_type = api_bundle< Tag, typename TupleT::available_type >
using	string_t = typename bundle_type::string_t
using	reference_type = typename TupleT::reference_type

Protected Member Functions
template<typename T >
void	set_scope (T *obj, internal_tag) const
template<typename T >
void	set_prefix (T *obj, internal_tag) const

Protected Attributes
data_type	m_data {}

Friends
template<typename... Tp>
class	impl::base_bundle
template<typename... Tp>
class	auto_base_bundle
template<typename... Tp>
class	auto_bundle
template<typename... Tp>
class	auto_tuple
template<typename... Tp>
class	auto_list
this_type	operator+ (this_type lhs, const this_type &rhs)
this_type	operator- (this_type lhs, const this_type &rhs)
template<typename Op >
enable_if_t<!std::is_arithmetic< Op >::value, this_type >	operator* (this_type lhs, const Op &rhs)
template<typename Op >
enable_if_t<!std::is_arithmetic< Op >::value, this_type >	operator/ (this_type lhs, const Op &rhs)
std::ostream &	operator<< (std::ostream &os, const bundle &obj)

Detailed Description

template<typename Tag, typename BundleT, typename TupleT>
class tim::bundle< Tag, BundleT, TupleT >

Example: bundle<Tag, component_bundle<Foo>, mixed_wrapper_types<concat<Bar, Baz>>> will use Tag + trait::is_available<Tag> or trait::runtime_available<Tag> to disable this bundle at compile-time or run-time, respectively. It will covert component_bundle<Foo> to component_bundle<Foo, Bar, Baz> for purposes of function signatures and it will instantiate std::tuple<...> depending on the compile-time availability of Bar and Baz. mixed_wrapper_types is a dummy type with the appropriate aliases to perform these conversions. Here is a theoretical implementation of mixed_wrapper_types (which supports allocating components on the stack and the heap):

Template Parameters

Tag	API tag type, e.g. TIMEMORY_API
BundleT	The empty or empty + tag derived type.
TupleT	The set of components wrapped in a type which provides the appropriate aliases.

template <typename... T>
struct heap_wrapper_types
{
    TIMEMORY_DELETED_OBJECT(heap_wrapper_types)
 
    /// the set of types, unaltered, in a type_list
    using type_list_type = type_list<T...>;
 
    /// the set of types without any pointers
    using reference_type = type_list<std::remove_pointer_t<T>...>;
 
    /// type list of the available types
    using available_type = type_list_t<reference_type>;
 
    /// the original bundle type
    template <typename BundleT>
    using this_type = convert_t<type_list<T...>, BundleT>;
 
    /// the type after available_t<concat<...>>
    template <typename BundleT>
    using type = convert_t<available_type, BundleT>;
 
    /// conversion to equivalent wrapper requiring explicit start/stop
    template <typename BundleT>
    using component_type = convert_t<type_list<T...>, BundleT>;
 
    /// conversion to equivalent wrapper which automatically starts/stops
    template <typename BundleT>
    using auto_type = concepts::auto_type_t<convert_t<type_list_type, BundleT>>;
 
    /// the valid types to instantiate in a tuple
    template <typename ApiT = TIMEMORY_API>
    using data_type = conditional_t<
        trait::is_available<ApiT>::value,
        convert_t<add_pointer_if_not_t<non_placeholder_t<non_quirk_t<type_list_t<T...>>>>,
                  std::tuple<>>,
        std::tuple<>>;
};

Definition at line 111 of file bundle.hpp.

Member Typedef Documentation

apply_v

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::apply_v = mpl::apply<void>

protected

Definition at line 143 of file bundle.hpp.

base_bundle_type

using tim::api_bundle< Tag , Types >::base_bundle_type = conditional_t<trait::is_available<Tag >::value, impl::base_bundle<Tag , remove_pointer_t<Types>...>, impl::base_bundle<Tag , std::tuple<> >>

inherited

Definition at line 643 of file base_bundle.hpp.

bundle_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::bundle_type = api_bundle<Tag, typename TupleT::available_type>

protected

Definition at line 144 of file bundle.hpp.

captured_location_t

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::captured_location_t = source_location::captured

Definition at line 149 of file bundle.hpp.

component_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::component_type = typename TupleT::template component_type<BundleT>

Definition at line 152 of file bundle.hpp.

data_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::data_type = typename TupleT::template data_type<Tag>

Definition at line 153 of file bundle.hpp.

impl_type

using tim::api_bundle< Tag , Types >::impl_type = data_type

inherited

Definition at line 652 of file base_bundle.hpp.

initializer_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::initializer_type = std::function<void(this_type&)>

Definition at line 157 of file bundle.hpp.

quirk_config

template<typename Tag , typename BundleT , typename TupleT >

template<typename T , typename... U>

using tim::bundle< Tag, BundleT, TupleT >::quirk_config = tim::variadic::impl::quirk_config<T, reference_type, U...>

Definition at line 164 of file bundle.hpp.

reference_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::reference_type = typename TupleT::reference_type

protected

Definition at line 146 of file bundle.hpp.

size_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::size_type = typename bundle_type::size_type

Definition at line 156 of file bundle.hpp.

string_t

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::string_t = typename bundle_type::string_t

protected

Definition at line 145 of file bundle.hpp.

this_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::this_type = typename TupleT::template this_type<BundleT>

Definition at line 150 of file bundle.hpp.

transient_func_t

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::transient_func_t = utility::transient_function<void(this_type&)>

Definition at line 158 of file bundle.hpp.

tuple_type

using tim::api_bundle< Tag , Types >::tuple_type = data_type

inherited

Definition at line 651 of file base_bundle.hpp.

type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::type = typename TupleT::template type<BundleT>

Definition at line 151 of file bundle.hpp.

type_list_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::type_list_type = typename TupleT::type_list_type

Definition at line 154 of file bundle.hpp.

value_type

template<typename Tag , typename BundleT , typename TupleT >

using tim::bundle< Tag, BundleT, TupleT >::value_type = data_type

Definition at line 155 of file bundle.hpp.

Constructor & Destructor Documentation

bundle() [1/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle

Definition at line 55 of file bundle.cpp.

{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, get_initializer());
}

References IF_CONSTEXPR, and tim::init().

bundle() [2/14]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... T>

tim::bundle< Tag, BundleT, TupleT >::bundle ( const string_t &  _key, quirk::config< T... >  _config, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 67 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _key, true_type{}, _config))
, m_data(invoke::construct<data_type, Tag>(_key, _config))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle, T...>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func),
                      _config);
}

bundle() [3/14]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... T>

tim::bundle< Tag, BundleT, TupleT >::bundle ( hash_value_t  _hash, quirk::config< T... >  _config, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 83 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _hash, true_type{}, _config))
, m_data(invoke::construct<data_type, Tag>(_hash, _config))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle, T...>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func),
                      _config);
}

bundle() [4/14]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... T>

tim::bundle< Tag, BundleT, TupleT >::bundle ( const captured_location_t &  _loc, quirk::config< T... >  _config, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 99 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _loc, true_type{}, _config))
, m_data(invoke::construct<data_type, Tag>(_loc, _config))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle, T...>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func),
                      _config);
}

bundle() [5/14]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... T>

tim::bundle< Tag, BundleT, TupleT >::bundle ( const string_t &  _key, bool  _store, quirk::config< T... >  _config, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 116 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _key, _store, _config))
, m_data(invoke::construct<data_type, Tag>(_key, _config))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle, T...>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func),
                      _config);
}

bundle() [6/14]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... T>

tim::bundle< Tag, BundleT, TupleT >::bundle ( const captured_location_t &  _loc, bool  _store, quirk::config< T... >  _config, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 133 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _loc, _store, _config))
, m_data(invoke::construct<data_type, Tag>(_loc, _config))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle, T...>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func),
                      _config);
}

bundle() [7/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle ( hash_value_t  _hash, bool  _store = true, scope::config  _scope = scope::get_default(), transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 149 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _hash, _store, _scope))
, m_data(invoke::construct<data_type, Tag>(_hash, m_scope))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func));
}

bundle() [8/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle ( const string_t &  _key, bool  _store = true, scope::config  _scope = scope::get_default(), transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 163 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _key, _store, _scope))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func));
}

References IF_CONSTEXPR, and tim::init().

bundle() [9/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle ( const captured_location_t &  _loc, bool  _store = true, scope::config  _scope = scope::get_default(), transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 176 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _loc, _store, _scope))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func));
}

References IF_CONSTEXPR, and tim::init().

bundle() [10/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle ( hash_value_t  _hash, scope::config  _scope, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 189 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _hash, true_type{}, _scope))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func));
}

References IF_CONSTEXPR, and tim::init().

bundle() [11/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle ( const string_t &  _key, scope::config  _scope, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 202 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _key, true_type{}, _scope))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func));
}

References IF_CONSTEXPR, and tim::init().

bundle() [12/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle ( const captured_location_t &  _loc, scope::config  _scope, transient_func_t  _init_func = get_initializer()  )

explicit

Definition at line 215 of file bundle.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _loc, true_type{}, _scope))
{
    update_last_instance(&get_this_type(), get_last_instance(),
                         quirk_config<quirk::stop_last_bundle>::value);
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    bundle_type::init(type_list_type{}, get_this_type(), m_data, std::move(_init_func));
}

References IF_CONSTEXPR, and tim::init().

~bundle()

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::~bundle

Definition at line 228 of file bundle.cpp.

{
    if(get_last_instance() == &get_this_type())
        update_last_instance(nullptr, get_last_instance(), false);
 
    IF_CONSTEXPR(!quirk_config<quirk::explicit_stop>::value)
    {
        if(m_is_active())
            stop();
    }
 
    IF_CONSTEXPR(optional_count() > 0)
    {
#if defined(DEBUG) && !defined(NDEBUG)
        if(tim::settings::debug() && tim::settings::verbose() > 4)
        {
            PRINT_HERE("%s", "deleting components");
        }
#endif
        invoke::destroy<Tag>(m_data);
    }
}

References tim::debug, IF_CONSTEXPR, PRINT_HERE, tim::invoke::stop(), and tim::verbose.

bundle() [13/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle

(

const bundle< Tag, BundleT, TupleT > &

rhs

)

Definition at line 254 of file bundle.cpp.

: bundle_type(rhs)
{
    using copy_oper_t = convert_each_t<operation::copy, remove_pointers_t<data_type>>;
    IF_CONSTEXPR(optional_count() > 0) { apply_v::set_value(m_data, nullptr); }
    apply_v::access2<copy_oper_t>(m_data, rhs.m_data);
}

References IF_CONSTEXPR.

bundle() [14/14]

template<typename Tag , typename BundleT , typename TupleT >

tim::bundle< Tag, BundleT, TupleT >::bundle ( bundle< Tag, BundleT, TupleT > &&  )

default

Member Function Documentation

add_secondary() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::add_secondary

(

Args &&...

_args

)

Definition at line 806 of file bundle.cpp.

{
    return invoke<operation::add_secondary>(std::forward<Args>(_args)...);
}

References tim::_args.

add_secondary() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::add_secondary

(

Args &&...

_args

)

perform an add_secondary operation. This operation allows components to add additional entries to storage which are their direct descendant

assemble() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::assemble

(

Args &&...

_args

)

Definition at line 723 of file bundle.cpp.

{
    return invoke<operation::assemble>(std::forward<Args>(_args)...);
}

References tim::_args.

assemble() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::assemble

(

Args &&...

_args

)

provide preliminary info to the objects with matching arguments. This is typically used to notify a component that it has been bundled alongside another component that it can extract data from.

audit() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::audit

(

Args &&...

_args

)

Definition at line 795 of file bundle.cpp.

{
    return invoke<operation::audit>(std::forward<Args>(_args)...);
}

References tim::_args.

audit() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::audit

(

Args &&...

_args

)

allow the components to inspect the incoming arguments before start or out-going return value before returning (typically using in GOTCHA components)

can_heap_init()

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::can_heap_init ( )

inlinestaticconstexpr

Query at compile-time whether initialization can occur on the heap.

Definition at line 299 of file bundle.hpp.

    {
        using T = remove_pointer_decay_t<U>;
        return trait::is_available<T>::value && is_one_of<T*, data_type>::value;
    }

can_init()

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::can_init ( )

inlinestaticconstexpr

Query at compile-time whether the specified type can be initialized.

Definition at line 316 of file bundle.hpp.

    {
        using T = remove_pointer_decay_t<U>;
        return can_stack_init<T>() || can_heap_init<T>() || can_placement_init<T>() ||
               (trait::is_available<T>::value && has_user_bundle());
    }

can_placement_init()

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::can_placement_init ( )

inlinestaticconstexpr

Query at compile-time whether initialization can occur via a placement new. Placement new init allows for the combination of optional initialization without a heap allocation. Not currently available.

Definition at line 309 of file bundle.hpp.

    {
        return false;
    }

can_stack_init()

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::can_stack_init ( )

inlinestaticconstexpr

Query at compile-time whether initialization can occur on the stack.

Definition at line 291 of file bundle.hpp.

    {
        using T = remove_pointer_decay_t<U>;
        return trait::is_available<T>::value && is_one_of<T, data_type>::value;
    }

clone()

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT > tim::bundle< Tag, BundleT, TupleT >::clone	(	bool	store,
		scope::config	_scope = scope::get_default()
	)

Definition at line 305 of file bundle.cpp.

{
    bundle tmp(*this);
    tmp.m_store(_store);
    tmp.m_scope = _scope;
    return tmp;
}

construct() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::construct

(

Args &&...

_args

)

Definition at line 710 of file bundle.cpp.

{
    // using construct_t = operation_t<operation::construct>;
    // apply_v::access<construct_t>(m_data, std::forward<Args>(_args)...);
    return invoke<operation::construct>(std::forward<Args>(_args)...);
}

construct() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::construct

(

Args &&...

_args

)

construct the objects that have constructors with matching arguments

count()

template<typename Tag , typename BundleT , typename TupleT >

uint64_t tim::bundle< Tag, BundleT, TupleT >::count

number of objects that will be performing measurements

Definition at line 697 of file bundle.cpp.

{
    uint64_t _count = 0;
    invoke::invoke<operation::generic_counter>(m_data, std::ref(_count));
    return _count;
}

data() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::data_type & tim::bundle< Tag, BundleT, TupleT >::data

returns a reference to the underlying tuple of components

Definition at line 906 of file bundle.cpp.

{
    return m_data;
}

data() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

const bundle< Tag, BundleT, TupleT >::data_type & tim::bundle< Tag, BundleT, TupleT >::data

returns a const reference to the underlying tuple of components

Definition at line 915 of file bundle.cpp.

{
    return m_data;
}

derive() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::derive

(

Args &&...

_args

)

Definition at line 734 of file bundle.cpp.

{
    return invoke<operation::derive>(std::forward<Args>(_args)...);
}

References tim::_args.

derive() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::derive

(

Args &&...

_args

)

provide conclusive info to the objects with matching arguments. This is typically used by components to extract data from another component it has been bundled alongside, e.g. the cpu_util component can extract data from tim::component::wall_clock and tim::component::cpu_clock

disable() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tail>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::disable

(

)

Definition at line 940 of file bundle.cpp.

{
    TIMEMORY_FOLD_EXPRESSION(operation::generic_deleter<remove_pointer_t<Tail>>{
        this->get_reference<Tail>() });
    return get_this_type();
}

References TIMEMORY_FOLD_EXPRESSION.

disable() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tail>

this_type & tim::bundle< Tag, BundleT, TupleT >::disable

(

)

delete any optional types currently allocated

execute()

template<typename Tag , typename BundleT , typename TupleT >

template<typename FuncT , typename... Args>

decltype(auto) tim::bundle< Tag, BundleT, TupleT >::execute	(	FuncT &&	func,
		Args &&...	args
	)

when chaining together operations, this function enables executing a function inside the chain

fixed_count()

template<typename Tag , typename BundleT , typename TupleT >

constexpr uint64_t tim::bundle< Tag, BundleT, TupleT >::fixed_count

staticconstexpr

query the number of (compile-time) fixed components

Definition at line 886 of file bundle.hpp.

{
    return (size() -
            mpl::get_tuple_size<
                typename mpl::get_true_types<std::is_pointer, data_type>::type>::value);
}

get() [1/7]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

decltype(auto) tim::bundle< Tag, BundleT, TupleT >::get

(

)

get a component from the bundle

get() [2/7]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

decltype(auto) tim::bundle< Tag, BundleT, TupleT >::get

(

)

const

get a component from the bundle

get() [3/7]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

auto tim::bundle< Tag, BundleT, TupleT >::get

(

Args &&...

args

)

const

Definition at line 886 of file bundle.cpp.

{
    return invoke::get<Tag>(m_data, std::forward<Args>(args)...);
}

get() [4/7]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

auto tim::bundle< Tag, BundleT, TupleT >::get

(

Args &&

...

)

const

returns a tuple of invoking get() on all the components

get() [5/7]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename FuncT >

decltype(auto) tim::bundle< Tag, BundleT, TupleT >::get

(

FuncT &&

)

get a component from the bundle and apply function if the pointer is valid

get() [6/7]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename FuncT >

decltype(auto) tim::bundle< Tag, BundleT, TupleT >::get

(

FuncT &&

)

const

get a component from the bundle

get() [7/7]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::get	(	void *&	ptr,
		hash_value_t	_hash
	)		const

performs an opaque search. Opaque searches are generally provided by user_bundles with a functor such as this:

auto _get = [](void* v_this, void*& ptr, size_t _hash) {
{
    if(!ptr && v_this && _hash == typeid_hash<Tp>())
    {
        Tp* _this = static_cast<Tp*>(v_this);
        _this->get(ptr, _hash);
    }
    return ptr;
};

And the component provides this function:

template <typename Tp, typename Value>
void
base<Tp, Value>::get(void*& ptr, size_t _hash) const
{
    if(!ptr && _hash == typeid_hash<Tp>())
        ptr = reinterpret_cast<void*>(const_cast<base_type*>(this));
}

Definition at line 925 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    tim::variadic::impl::get<Tag>(m_data, ptr, _hash);
    return get_this_type();
}

get_component() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

auto tim::bundle< Tag, BundleT, TupleT >::get_component

(

enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U > *, data_type >::value, int >

= 0

)

Definition at line 996 of file bundle.hpp.

{
    return get<remove_pointer_decay_t<U>>();
}

get_component() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

auto tim::bundle< Tag, BundleT, TupleT >::get_component

(

enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U >, data_type >::value, int >

= 0

)

this is a simple alternative to get<T>() when used from SFINAE in operation namespace which has a struct get also templated. Usage there can cause error with older compilers

Definition at line 984 of file bundle.hpp.

{
    return get<remove_pointer_decay_t<U>>();
}

get_data()

template<typename Tag , typename BundleT , typename TupleT >

const data_type & tim::bundle< Tag, BundleT, TupleT >::get_data ( ) const

inline

Definition at line 829 of file bundle.hpp.

{ return m_data; }

get_initializer()

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::initializer_type & tim::bundle< Tag, BundleT, TupleT >::get_initializer

static

Definition at line 46 of file bundle.cpp.

{
    static initializer_type _instance = [](this_type&) {};
    return _instance;
}

get_labeled() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

auto tim::bundle< Tag, BundleT, TupleT >::get_labeled

(

Args &&...

args

)

const

Definition at line 897 of file bundle.cpp.

{
    return invoke::get_labeled<Tag>(m_data, std::forward<Args>(args)...);
}

get_labeled() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

auto tim::bundle< Tag, BundleT, TupleT >::get_labeled

(

Args &&

...

)

const

returns a tuple of the component label + invoking get() on all the components

get_reference() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

auto & tim::bundle< Tag, BundleT, TupleT >::get_reference

(

enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U > *, data_type >::value, int >

= 0

)

returns a reference from a heap component instead of a pointer

Definition at line 1020 of file bundle.hpp.

{
    return std::get<index_of<remove_pointer_decay_t<U>*, data_type>::value>(m_data);
}

get_reference() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

auto & tim::bundle< Tag, BundleT, TupleT >::get_reference

(

enable_if_t< trait::is_available< remove_pointer_decay_t< U > >::value &&is_one_of< remove_pointer_decay_t< U >, data_type >::value, int >

= 0

)

returns a reference from a stack component instead of a pointer

Definition at line 1008 of file bundle.hpp.

{
    return std::get<index_of<remove_pointer_decay_t<U>, data_type>::value>(m_data);
}

get_scope_destructor() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

scope::transient_destructor tim::bundle< Tag, BundleT, TupleT >::get_scope_destructor

returns a stack-object for calling stop

Definition at line 1053 of file bundle.cpp.

{
    return scope::transient_destructor{ [&]() { this->stop(); } };
}

References tim::invoke::stop().

get_scope_destructor() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

scope::transient_destructor tim::bundle< Tag, BundleT, TupleT >::get_scope_destructor

(

utility::transient_function< void(this_type &)>

_func

)

returns a stack-object for calling some member functions when the scope is exited.

Definition at line 1062 of file bundle.cpp.

{
    return scope::transient_destructor{ [&, _func]() { _func(get_this_type()); } };
}

has_user_bundle()

template<typename Tag , typename BundleT , typename TupleT >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::has_user_bundle ( )

inlinestaticconstexpr

Query at compile-time whether a user_bundle exists in the set of components. user_bundle are more restricted versions of component bundlers but allow runtime insertion of components.

Definition at line 287 of file bundle.hpp.

{ return bundle_type::has_user_bundle_v; }

init() [1/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>

bool tim::bundle< Tag, BundleT, TupleT >::init ( Args &&...  _args, enable_if_t< can_stack_init< T >(), int >  = 0  )

inline

try to re-create a stack object with provided arguments

Definition at line 732 of file bundle.hpp.

    {
        IF_CONSTEXPR(can_heap_init<T>())
        {
            static std::atomic<int> _count(0);
            if((settings::verbose() > 1 || settings::debug()) && _count++ == 0)
            {
                fprintf(stderr,
                        "[bundle::init]> type exists as a heap-allocated instance "
                        "and stack-allocated instance: \"%s\"...\n",
                        demangle<T>().c_str());
            }
        }
        T& _obj = std::get<index_of<T, data_type>::value>(m_data);
        operation::construct<T>{ _obj, std::forward<Args>(_args)... };
        set_prefix(&_obj, internal_tag{});
        set_scope(&_obj, internal_tag{});
        return true;
    }

References tim::_args, tim::debug, IF_CONSTEXPR, tim::invoke::set_prefix(), tim::invoke::set_scope(), and tim::verbose.

init() [2/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>

enable_if_t< will_heap_init< T >() &&!will_opaque_init< T >(), bool > tim::bundle< Tag, BundleT, TupleT >::init ( Args &&...  _args, enable_if_t< is_constructible< T, Args... >(), int >  = 0  )

inline

create an optional type that is in variadic list AND is available AND accepts arguments

Definition at line 650 of file bundle.hpp.

    {
        T*& _obj = std::get<index_of<T*, data_type>::value>(m_data);
        if(!_obj)
        {
            if(settings::debug() && settings::verbose() > 1)
            {
                printf("[bundle::init]> initializing type '%s'...\n",
                       demangle<T>().c_str());
            }
            if(!bundle_type::init_buffer())
            {
                _obj = new T(std::forward<Args>(_args)...);
            }
            else
            {
                T in(std::forward<Args>(_args)...);
                _obj = m_buffer->write(&in).second;
            }
            set_prefix(_obj, internal_tag{});
            set_scope(_obj, internal_tag{});
            return true;
        }
 
        static std::atomic<int> _count(0);
        if((settings::verbose() > 1 || settings::debug()) && _count++ == 0)
        {
            std::string _id = demangle<T>();
            fprintf(stderr,
                    "[bundle::init]> skipping re-initialization of type"
                    " \"%s\"...\n",
                    _id.c_str());
        }
 
        return false;
    }

References tim::_args, tim::debug, tim::invoke::set_prefix(), tim::invoke::set_scope(), and tim::verbose.

init() [3/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>

enable_if_t<!trait::is_available< T >::value|| !(is_one_of< T *, data_type >::value||is_one_of< T, data_type >::value|| bundle_type::has_user_bundle_v), bool > tim::bundle< Tag, BundleT, TupleT >::init ( Args &&  ... )

inline

do nothing if type not available, not one of the variadic types, and there is no user bundle available

Definition at line 778 of file bundle.hpp.

    {
        return false;
    }

init() [4/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>

bool tim::bundle< Tag, BundleT, TupleT >::init ( Args &&  ..., enable_if_t< will_opaque_init< T >(), long >  = 0  )

inline

if a type is not in variadic list but a tim::component::user_bundle is available, add it in there

Definition at line 755 of file bundle.hpp.

    {
        using bundle_t = decay_t<decltype(
            std::get<0>(std::declval<typename bundle_type::user_bundle_types>()))>;
        static_assert(trait::is_user_bundle<bundle_t>::value, "Error! Not a user_bundle");
        this->init<bundle_t>();
        auto* _bundle = this->get<bundle_t>();
        if(_bundle)
        {
            _bundle->insert(component::factory::get_opaque<T>(m_scope),
                            component::factory::get_typeids<T>());
            return true;
        }
        return false;
    }

init() [5/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename T = remove_pointer_decay_t<U>, typename... Args>

enable_if_t< will_heap_init< T >() &&!will_opaque_init< T >(), bool > tim::bundle< Tag, BundleT, TupleT >::init ( Args &&  ..., enable_if_t<!is_constructible< T, Args... >() &&is_default_constructible< T >(), long >  = 0  )

inline

create an optional type that is in variadic list AND is available but is not constructible with provided arguments

Definition at line 691 of file bundle.hpp.

    {
        T*& _obj = std::get<index_of<T*, data_type>::value>(m_data);
        if(!_obj)
        {
            if(settings::debug() && settings::verbose() > 1)
            {
                fprintf(stderr, "[bundle::init]> initializing type '%s'...\n",
                        demangle<T>().c_str());
            }
            if(!bundle_type::init_buffer())
            {
                _obj = new T{};
            }
            else
            {
                T in{};
                _obj = m_buffer->write(&in).second;
            }
            set_prefix(_obj, internal_tag{});
            set_scope(_obj, internal_tag{});
            return true;
        }
 
        static std::atomic<int> _count(0);
        if((settings::verbose() > 1 || settings::debug()) && _count++ == 0)
        {
            fprintf(stderr,
                    "[bundle::init]> skipping re-initialization of type "
                    "\"%s\"...\n",
                    demangle<T>().c_str());
        }
 
        return false;
    }

References tim::debug, tim::invoke::set_prefix(), tim::invoke::set_scope(), and tim::verbose.

init_storage()

template<typename Tag , typename BundleT , typename TupleT >

void tim::bundle< Tag, BundleT, TupleT >::init_storage

static

requests the component initialize their storage

Definition at line 317 of file bundle.cpp.

{
    static thread_local bool _once = []() {
        apply_v::type_access<operation::init_storage, mpl::non_quirk_t<reference_type>>();
        return true;
    }();
    consume_parameters(_once);
}

References tim::consume_parameters().

initialize()

template<typename Tag , typename BundleT , typename TupleT >

template<typename... T, typename... Args>

std::array< bool, sizeof...(T)> tim::bundle< Tag, BundleT, TupleT >::initialize

(

Args &&...

args

)

variadic initialization

Template Parameters

T	components to initialize
Args	arguments to pass to the construction of the component

Definition at line 953 of file bundle.cpp.

{
    if(!m_enabled())
        return std::array<bool, sizeof...(T)>{};
 
    constexpr auto N = sizeof...(T);
    return TIMEMORY_FOLD_EXPANSION(bool, N, init<T>(std::forward<Args>(args)...));
}

References TIMEMORY_FOLD_EXPANSION.

invoke() [1/6]

template<typename Tag , typename BundleT , typename TupleT >

template<template< typename > class OpT, typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::invoke

(

Args &&...

_args

)

Definition at line 828 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    invoke::invoke<OpT, Tag>(m_data, std::forward<Args>(_args)...);
    return get_this_type();
}

References tim::_args.

invoke() [2/6]

template<typename Tag , typename BundleT , typename TupleT >

template<template< typename > class OpT, typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::invoke

(

Args &&...

_args

)

generic member function for invoking user-provided operations

Template Parameters

OpT	Operation struct

invoke() [3/6]

template<typename Tag , typename BundleT , typename TupleT >

template<template< typename > class OpT, typename... Tp, typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::invoke	(	mpl::piecewise_ignore< Tp... >	,
		Args &&...	_args
	)

Definition at line 858 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
    invoke_piecewise<OpT>(
        mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>{},
        std::forward<Args>(_args)...);
    return get_this_type();
}

References tim::_args.

invoke() [4/6]

template<typename Tag , typename BundleT , typename TupleT >

template<template< typename > class OpT, typename... Tp, typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::invoke	(	mpl::piecewise_ignore< Tp... >	,
		Args &&...	_args
	)

generic member function for invoking user-provided operations on all types that are not listed

Template Parameters

OpT	Operation struct

invoke() [5/6]

template<typename Tag , typename BundleT , typename TupleT >

template<template< typename > class OpT, typename... Tp, typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::invoke	(	mpl::piecewise_select< Tp... >	,
		Args &&...	_args
	)

Definition at line 843 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
    invoke_piecewise<OpT>(mpl::available_t<type_list<Tp...>>{},
                          std::forward<Args>(_args)...);
    return get_this_type();
}

References tim::_args.

invoke() [6/6]

template<typename Tag , typename BundleT , typename TupleT >

template<template< typename > class OpT, typename... Tp, typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::invoke	(	mpl::piecewise_select< Tp... >	,
		Args &&...	_args
	)

generic member function for invoking user-provided operations on a specific set of component types

Template Parameters

OpT	Operation struct

is_constructible() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename... Args, typename T = remove_pointer_decay_t<U>, enable_if_t< trait::is_available< T >::value > = 0>

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::is_constructible ( )

inlinestaticconstexpr

Query at compile-time whether type can be constructed with the given argument types. if type is not available, then it probably won't be defined, so this places the trait::is_available<T> check in the template parameters and the std::is_constructible<T, ...> in the body to avoid undefined behavior.

Definition at line 351 of file bundle.hpp.

    {
        return std::is_constructible<T, Args...>::value;
    }

is_constructible() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename... Args, typename T = remove_pointer_decay_t<U>, enable_if_t<!trait::is_available< T >::value > = 0>

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::is_constructible ( )

inlinestaticconstexpr

Return false if the type is not available.

Definition at line 359 of file bundle.hpp.

    {
        return false;
    }

is_default_constructible() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename T = remove_pointer_decay_t<U>, enable_if_t< trait::is_available< T >::value > = 0>

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::is_default_constructible ( )

inlinestaticconstexpr

Query at compile-time whether type supports default construction. If type is not available, then it probably won't be defined, so this places the trait::is_available<T> check in the template parameters and the std::is_constructible<T, ...> in the body to avoid undefined behavior.

Definition at line 370 of file bundle.hpp.

    {
        return std::is_default_constructible<T>::value;
    }

is_default_constructible() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename U , typename T = remove_pointer_decay_t<U>, enable_if_t<!trait::is_available< T >::value > = 0>

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::is_default_constructible ( )

inlinestaticconstexpr

Return false if the type is not available.

Definition at line 378 of file bundle.hpp.

    {
        return false;
    }

is_this_type()

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::is_this_type ( )

inlinestaticconstexpr

Query whether type matches this_type.

Definition at line 168 of file bundle.hpp.

    {
        return std::is_same<decay_t<U>, this_type>::value;
    }

mark() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::mark

(

Args &&...

_args

)

Definition at line 745 of file bundle.cpp.

{
    return invoke<operation::mark>(std::forward<Args>(_args)...);
}

References tim::_args.

mark() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::mark

(

Args &&...

_args

)

mark an atomic event

mark_begin() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::mark_begin

(

Args &&...

_args

)

Definition at line 756 of file bundle.cpp.

{
    return invoke<operation::mark_begin>(std::forward<Args>(_args)...);
}

References tim::_args.

mark_begin() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::mark_begin

(

Args &&...

_args

)

mark a beginning position in the execution (typically used by asynchronous structures)

mark_end() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::mark_end

(

Args &&...

_args

)

Definition at line 767 of file bundle.cpp.

{
    return invoke<operation::mark_end>(std::forward<Args>(_args)...);
}

References tim::_args.

mark_end() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::mark_end

(

Args &&...

_args

)

mark a beginning position in the execution (typically used by asynchronous structures)

measure() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::measure

(

Args &&...

args

)

Definition at line 484 of file bundle.cpp.

{
    return invoke<operation::measure>(std::forward<Args>(args)...);
}

measure() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::measure

(

Args &&

...

)

requests each component record a measurment

operator*=()

template<typename Tag , typename BundleT , typename TupleT >

template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>

this_type & tim::bundle< Tag, BundleT, TupleT >::operator*= ( Op &&  rhs )

inline

Definition at line 244 of file bundle.hpp.

    {
        invoke::invoke<operation::multiply, Tag>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

operator+=() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::operator+=

(

const this_type &

rhs

)

Definition at line 294 of file bundle.cpp.

{
    bundle_type::operator+=(static_cast<const bundle_type&>(rhs));
    invoke::invoke_impl::invoke_data<operation::plus, Tag>(m_data, rhs.m_data);
    return get_this_type();
}

References std::operator+=().

operator+=() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>

this_type & tim::bundle< Tag, BundleT, TupleT >::operator+= ( Op &&  rhs )

inline

Definition at line 237 of file bundle.hpp.

    {
        invoke::invoke<operation::plus, Tag>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

operator-=() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::operator-=

(

const this_type &

rhs

)

Definition at line 283 of file bundle.cpp.

{
    bundle_type::operator-=(static_cast<const bundle_type&>(rhs));
    invoke::invoke_impl::invoke_data<operation::minus, Tag>(m_data, rhs.m_data);
    return get_this_type();
}

operator-=() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>

this_type & tim::bundle< Tag, BundleT, TupleT >::operator-= ( Op &&  rhs )

inline

Definition at line 230 of file bundle.hpp.

    {
        invoke::invoke<operation::minus, Tag>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

operator/=()

template<typename Tag , typename BundleT , typename TupleT >

template<typename Op , enable_if_t<!is_this_type< Op >()> = 0>

this_type & tim::bundle< Tag, BundleT, TupleT >::operator/= ( Op &&  rhs )

inline

Definition at line 251 of file bundle.hpp.

    {
        invoke::invoke<operation::divide, Tag>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

operator=() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

bundle & tim::bundle< Tag, BundleT, TupleT >::operator= ( bundle< Tag, BundleT, TupleT > &&  )

default

operator=() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT > & tim::bundle< Tag, BundleT, TupleT >::operator=

(

const bundle< Tag, BundleT, TupleT > &

rhs

)

Definition at line 266 of file bundle.cpp.

{
    if(this != &rhs)
    {
        bundle_type::operator=(rhs);
        invoke::destroy<Tag>(m_data);
        invoke::invoke_impl::invoke_data<operation::copy, Tag>(m_data, rhs.m_data);
        // apply_v::access<operation_t<operation::copy>>(m_data);
    }
    return get_this_type();
}

optional_count()

template<typename Tag , typename BundleT , typename TupleT >

constexpr uint64_t tim::bundle< Tag, BundleT, TupleT >::optional_count

staticconstexpr

query the number of (run-time) optional components

Definition at line 897 of file bundle.hpp.

{
    return mpl::get_tuple_size<
        typename mpl::get_true_types<std::is_pointer, data_type>::type>::value;
}

pop() [1/5]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::pop

tells each component to pop itself off of the call-stack hierarchy

Definition at line 429 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    if(m_is_pushed())
    {
        // set the current node to the parent node
        invoke::pop<Tag>(m_data);
        // avoid pushing/popping when already pushed/popped
        m_is_pushed(false);
    }
    return get_this_type();
}

pop() [2/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::pop

(

mpl::piecewise_ignore< Tp... >

)

Definition at line 466 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using pw_type = mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>;
    // set the current node to the parent node
    invoke_piecewise<operation::pop_node>(pw_type{});
    return get_this_type();
}

pop() [3/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

this_type & tim::bundle< Tag, BundleT, TupleT >::pop

(

mpl::piecewise_ignore< Tp... >

)

selective pop

pop() [4/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::pop

(

mpl::piecewise_select< Tp... >

)

Definition at line 449 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using pw_type = convert_t<mpl::implemented_t<Tp...>, mpl::piecewise_select<>>;
    // set the current node to the parent node
    invoke::invoke<operation::pop_node, Tag>(pw_type{}, m_data);
    return get_this_type();
}

pop() [5/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

this_type & tim::bundle< Tag, BundleT, TupleT >::pop

(

mpl::piecewise_select< Tp... >

)

selective pop

print() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<bool PrintPrefix, bool PrintLaps>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::print	(	std::ostream &	os,
		bool	_endl
	)		const

Definition at line 1103 of file bundle.cpp.

{
    using printer_t = typename bundle_type::print_type;
    if(size() == 0 || m_hash == 0)
        return get_this_type();
    std::stringstream ss_data;
    apply_v::access_with_indices<printer_t>(m_data, std::ref(ss_data), false);
    if(PrintPrefix)
    {
        bundle_type::update_width();
        std::stringstream ss_prefix;
        std::stringstream ss_id;
        ss_id << get_prefix() << " " << std::left << key();
        ss_prefix << std::setw(bundle_type::output_width()) << std::left << ss_id.str()
                  << " : ";
        os << ss_prefix.str();
    }
    std::string _s = ss_data.str();
    if(_s.empty())
        return get_this_type();
    while(_s.find_last_of(", ") == _s.length() - 1)
        _s = _s.substr(0, _s.length() - 1);
    if(_s.empty())
        return get_this_type();
    os << _s;
    if(m_laps > 0 && PrintLaps)
        os << " [laps: " << m_laps << "]";
    if(_endl)
        os << '\n';
    return get_this_type();
}

References tim::os.

print() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<bool PrintPrefix = true, bool PrintLaps = true>

this_type & tim::bundle< Tag, BundleT, TupleT >::print	(	std::ostream &	os,
		bool	_endl = false
	)		const

push() [1/9]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::push

tells each component to push itself into the call-stack hierarchy

Definition at line 331 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    if(!m_is_pushed())
    {
        // reset the data
        invoke::reset<Tag>(m_data);
        // avoid pushing/popping when already pushed/popped
        m_is_pushed(true);
        // insert node or find existing node
        invoke::push<Tag>(m_data, m_scope, m_hash);
    }
    return get_this_type();
}

push() [2/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::push

(

mpl::piecewise_ignore< Tp... >

)

Definition at line 372 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using pw_type = mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>;
    // reset the data
    invoke_piecewise<operation::reset>(pw_type{});
    // insert node or find existing node
    invoke_piecewise<operation::push_node>(pw_type{}, m_scope, m_hash);
    return get_this_type();
}

push() [3/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

this_type & tim::bundle< Tag, BundleT, TupleT >::push

(

mpl::piecewise_ignore< Tp... >

)

selective push

push() [4/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::push	(	mpl::piecewise_ignore< Tp... >	,
		scope::config	_scope
	)

Definition at line 411 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using pw_type = mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>;
    // reset the data
    invoke_piecewise<operation::reset>(pw_type{});
    // insert node or find existing node
    invoke_piecewise<operation::push_node>(pw_type{}, _scope, m_hash);
    return get_this_type();
}

push() [5/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

this_type & tim::bundle< Tag, BundleT, TupleT >::push	(	mpl::piecewise_ignore< Tp... >	,
		scope::config
	)

selective push with scope configuration

push() [6/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::push

(

mpl::piecewise_select< Tp... >

)

Definition at line 353 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using pw_type = convert_t<mpl::implemented_t<Tp...>, mpl::piecewise_select<>>;
    // reset the data
    invoke::invoke<operation::reset, Tag>(pw_type{}, m_data);
    // insert node or find existing node
    invoke::invoke<operation::push_node, Tag>(pw_type{}, m_data, m_scope, m_hash);
    return get_this_type();
}

push() [7/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

this_type & tim::bundle< Tag, BundleT, TupleT >::push

(

mpl::piecewise_select< Tp... >

)

selective push

push() [8/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::push	(	mpl::piecewise_select< Tp... >	,
		scope::config	_scope
	)

Definition at line 392 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using pw_type = convert_t<mpl::implemented_t<Tp...>, mpl::piecewise_select<>>;
    // reset the data
    invoke::invoke<operation::reset, Tag>(pw_type{}, m_data);
    // insert node or find existing node
    invoke::invoke<operation::push_node, Tag>(pw_type{}, m_data, _scope, m_hash);
    return get_this_type();
}

push() [9/9]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

this_type & tim::bundle< Tag, BundleT, TupleT >::push	(	mpl::piecewise_select< Tp... >	,
		scope::config
	)

selective push with scope configuration

record() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::record

(

Args &&...

args

)

Definition at line 671 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    ++m_laps;
    return invoke<operation::record>(std::forward<Args>(args)...);
}

record() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::record

(

Args &&

...

)

requests each component perform a measurement

rekey() [1/3]

template<typename Tag , typename BundleT , typename TupleT >

void tim::bundle< Tag, BundleT, TupleT >::rekey

(

captured_location_t

_loc

)

Definition at line 1042 of file bundle.hpp.

{
    m_hash = _loc.get_hash();
    set_prefix(_loc);
}

References tim::source_location::captured::get_hash(), and tim::invoke::set_prefix().

rekey() [2/3]

template<typename Tag , typename BundleT , typename TupleT >

void tim::bundle< Tag, BundleT, TupleT >::rekey

(

const string_t &

_key

)

Definition at line 1032 of file bundle.hpp.

{
    m_hash = add_hash_id(_key);
    set_prefix(_key);
}

References tim::invoke::set_prefix().

rekey() [3/3]

template<typename Tag , typename BundleT , typename TupleT >

void tim::bundle< Tag, BundleT, TupleT >::rekey

(

uint64_t

_hash

)

Definition at line 1052 of file bundle.hpp.

{
    m_hash = _hash;
    set_prefix(_hash);
}

References tim::invoke::set_prefix().

reset() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::reset

(

Args &&...

args

)

Definition at line 686 of file bundle.cpp.

{
    m_laps = 0;
    return invoke<operation::reset>(std::forward<Args>(args)...);
}

reset() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::reset

(

Args &&

...

)

invokes reset member function on all the components

sample() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::sample

(

Args &&...

args

)

Definition at line 495 of file bundle.cpp.

{
    return invoke<operation::sample>(std::forward<Args>(args)...);
}

sample() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::sample

(

Args &&

...

)

requests each component take a sample (if supported)

serialize()

template<typename Tag , typename BundleT , typename TupleT >

template<typename Archive >

void tim::bundle< Tag, BundleT, TupleT >::serialize	(	Archive &	ar,
		const unsigned int
	)

Definition at line 1140 of file bundle.cpp.

{
    std::string _key   = {};
    auto        keyitr = get_hash_ids()->find(m_hash);
    if(keyitr != get_hash_ids()->end())
        _key = keyitr->second;
 
    ar(cereal::make_nvp("hash", m_hash), cereal::make_nvp("key", _key),
       cereal::make_nvp("laps", m_laps));
 
    if(keyitr == get_hash_ids()->end())
    {
        auto _hash = add_hash_id(_key);
        if(_hash != m_hash)
        {
            PRINT_HERE("Warning! Hash for '%s' (%llu) != %llu", _key.c_str(),
                       (unsigned long long) _hash, (unsigned long long) m_hash);
        }
    }
 
    ar.setNextName("data");
    ar.startNode();
    invoke::serialize(ar, m_data);
    ar.finishNode();
    // ar(cereal::make_nvp("data", m_data));
}

References PRINT_HERE, and tim::invoke::serialize().

set_prefix() [1/4]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::set_prefix

(

captured_location_t

_loc

)

const

Definition at line 1030 of file bundle.cpp.

{
    return set_prefix(_loc.get_hash());
}

References tim::source_location::captured::get_hash(), and tim::invoke::set_prefix().

set_prefix() [2/4]

template<typename Tag , typename BundleT , typename TupleT >

void tim::bundle< Tag, BundleT, TupleT >::set_prefix

(

const string_t &

_key

)

const

Definition at line 994 of file bundle.cpp.

{
    if(!m_enabled())
        return;
 
    invoke::set_prefix<Tag>(m_data, m_hash, _key);
}

set_prefix() [3/4]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::set_prefix

(

hash_value_t

_hash

)

const

Definition at line 1006 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    const auto& _hash_ids = hash::get_hash_ids();
    auto itr = hash::find_hash_identifier(_hash_ids, hash::get_hash_aliases(), _hash);
    if(itr != _hash_ids->end())
    {
        invoke::set_prefix<Tag>(m_data, _hash, itr->second);
    }
    else
    {
        const char* _prefix = nullptr;
        if(hash::get_hash_identifier(_hash, _prefix))
            invoke::set_prefix<Tag>(m_data, _hash, _prefix);
    }
    return get_this_type();
}

References tim::_prefix, tim::hash::find_hash_identifier(), tim::hash::get_hash_aliases(), tim::hash::get_hash_identifier(), and tim::hash::get_hash_ids().

set_prefix() [4/4]

template<typename Tag , typename BundleT , typename TupleT >

template<typename T >

void tim::bundle< Tag, BundleT, TupleT >::set_prefix ( T *  obj, internal_tag    ) const

protected

Definition at line 1073 of file bundle.cpp.

{
    if(!m_enabled())
        return;
 
    using PrefixOpT   = operation::generic_operator<T, operation::set_prefix<T>, Tag>;
    std::string* _key = nullptr;
    if(get_hash_identifier_fast(m_hash, _key))
        PrefixOpT{ obj, m_hash, *_key };
}

set_scope() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::set_scope

(

scope::config

val

)

Definition at line 1039 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    m_scope = val;
    invoke::set_scope<Tag>(m_data, m_scope);
    return get_this_type();
}

set_scope() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename T >

void tim::bundle< Tag, BundleT, TupleT >::set_scope ( T *  obj, internal_tag    ) const

protected

Definition at line 1089 of file bundle.cpp.

{
    if(!m_enabled())
        return;
 
    using PrefixOpT = operation::generic_operator<T, operation::set_scope<T>, Tag>;
    PrefixOpT(obj, m_scope);
}

start() [1/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::start

(

Args &&...

args

)

Definition at line 624 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    // push components into the call-stack
    IF_CONSTEXPR(!quirk_config<quirk::explicit_push>::value &&
                 !quirk_config<quirk::no_store>::value)
    {
        if(m_store() && !bundle_type::m_explicit_push())
            push();
    }
 
    // start components
    start(mpl::lightweight{}, std::forward<Args>(args)...);
    return get_this_type();
}

References IF_CONSTEXPR, tim::invoke::push(), and tim::invoke::start().

start() [2/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::start

(

Args &&

...

)

invokes start on all the components

start() [3/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::start	(	mpl::lightweight	,
		Args &&...	args
	)

Definition at line 506 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    assemble(*this);
    invoke::start<Tag>(m_data, std::forward<Args>(args)...);
    m_is_active(true);
    return get_this_type();
}

References tim::invoke::assemble().

start() [4/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::start	(	mpl::lightweight	,
		Args &&	...
	)

variant of start() which excludes push()

start() [5/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::start	(	mpl::piecewise_ignore< Tp... >	,
		Args &&...	args
	)

Definition at line 570 of file bundle.cpp.

{
    using selected_t =
        mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>;
    return start(convert_t<selected_t, mpl::piecewise_select<>>{},
                 std::forward<Args>(args)...);
}

References tim::invoke::start().

start() [6/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::start	(	mpl::piecewise_ignore< Tp... >	,
		Args &&	...
	)

variant of start() which gets applied to non-Tp types

start() [7/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::start	(	mpl::piecewise_select< Tp... >	,
		Args &&...	args
	)

Definition at line 541 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using select_tuple_t = mpl::sort<trait::start_priority, std::tuple<Tp...>>;
 
    invoke_piecewise<operation::reset>(type_list<Tp...>{});
    IF_CONSTEXPR(!quirk_config<quirk::explicit_push>::value &&
                 !quirk_config<quirk::no_store>::value)
    {
        if(m_store() && !bundle_type::m_explicit_push())
        {
            invoke_piecewise<operation::push_node>(type_list<Tp...>{}, m_scope, m_hash);
        }
    }
 
    // start components
    auto&& _data = mpl::get_reference_tuple<select_tuple_t>(m_data);
    invoke::invoke<operation::standard_start, Tag>(_data, std::forward<Args>(args)...);
    return get_this_type();
}

References IF_CONSTEXPR.

start() [8/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::start	(	mpl::piecewise_select< Tp... >	,
		Args &&	...
	)

variant of start() which only gets applied to Tp types

stop() [1/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::stop

(

Args &&...

args

)

Definition at line 647 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    // stop components
    stop(mpl::lightweight{}, std::forward<Args>(args)...);
 
    // pop components off of the call-stack stack
    IF_CONSTEXPR(!quirk_config<quirk::explicit_pop>::value &&
                 !quirk_config<quirk::no_store>::value)
    {
        if(m_store() && !bundle_type::m_explicit_pop())
            pop();
    }
    return get_this_type();
}

References IF_CONSTEXPR, tim::invoke::pop(), and tim::invoke::stop().

stop() [2/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::stop

(

Args &&

...

)

invokes stop on all the components

stop() [3/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::stop	(	mpl::lightweight	,
		Args &&...	args
	)

Definition at line 522 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    invoke::stop<Tag>(m_data, std::forward<Args>(args)...);
    if(m_is_active())
        ++m_laps;
    derive(*this);
    m_is_active(false);
    return get_this_type();
}

References tim::invoke::derive().

stop() [4/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::stop	(	mpl::lightweight	,
		Args &&	...
	)

variant of stop() which excludes pop()

stop() [5/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::stop	(	mpl::piecewise_ignore< Tp... >	,
		Args &&...	args
	)

Definition at line 610 of file bundle.cpp.

{
    using selected_t =
        mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>;
    return stop(convert_t<selected_t, mpl::piecewise_select<>>{},
                std::forward<Args>(args)...);
}

References tim::invoke::stop().

stop() [6/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::stop	(	mpl::piecewise_ignore< Tp... >	,
		Args &&	...
	)

variant of stop() which gets applied to non-Tp types

stop() [7/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::stop	(	mpl::piecewise_select< Tp... >	,
		Args &&...	args
	)

Definition at line 583 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    using select_tuple_t = mpl::sort<trait::stop_priority, std::tuple<Tp...>>;
 
    // stop components
    auto&& _data = mpl::get_reference_tuple<select_tuple_t>(m_data);
    invoke::invoke<operation::standard_stop, Tag>(_data, std::forward<Args>(args)...);
 
    IF_CONSTEXPR(!quirk_config<quirk::explicit_pop>::value &&
                 !quirk_config<quirk::no_store>::value)
    {
        if(m_store() && !bundle_type::m_explicit_pop())
        {
            invoke_piecewise<operation::pop_node>(type_list<Tp...>{});
        }
    }
    return get_this_type();
}

References IF_CONSTEXPR.

stop() [8/8]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp, typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::stop	(	mpl::piecewise_select< Tp... >	,
		Args &&	...
	)

variant of stop() which only gets applied to Tp types

store() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::store

(

Args &&...

_args

)

Definition at line 778 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    m_is_active(true);
    invoke<operation::store>(std::forward<Args>(_args)...);
    m_is_active(false);
    return get_this_type();
}

References tim::_args.

store() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::store

(

Args &&...

_args

)

store a value

type_apply() [1/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename T , typename Func , typename... Args, enable_if_t<!trait::is_available< T >::value, int > >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::type_apply	(	Func &&	,
		Args &&	...
	)

Definition at line 985 of file bundle.cpp.

{
    return get_this_type();
}

type_apply() [2/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename T , typename Func , typename... Args, enable_if_t<!trait::is_available< T >::value, int > = 0>

this_type & tim::bundle< Tag, BundleT, TupleT >::type_apply	(	Func &&	,
		Args &&	...
	)

ignore applying a member function because the type is not present

type_apply() [3/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename T , typename Func , typename... Args, enable_if_t< trait::is_available< T >::value, int > >

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::type_apply	(	Func &&	_func,
		Args &&...	_args
	)

Definition at line 968 of file bundle.cpp.

{
    if(!m_enabled())
        return get_this_type();
 
    auto* _obj = get<T>();
    if(_obj)
        ((*_obj).*(_func))(std::forward<Args>(_args)...);
    return get_this_type();
}

References tim::_args.

type_apply() [4/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename T , typename Func , typename... Args, enable_if_t< is_one_of< T, data_type >::value, int > = 0>

this_type & tim::bundle< Tag, BundleT, TupleT >::type_apply ( Func &&  _func, Args &&...  _args  )

inline

apply a member function to a stack type that is in variadic list AND is available

Definition at line 796 of file bundle.hpp.

    {
        auto* _obj = get<T>();
        ((*_obj).*(_func))(std::forward<Args>(_args)...);
        return get_this_type();
    }

References tim::_args.

type_apply() [5/5]

template<typename Tag , typename BundleT , typename TupleT >

template<typename T , typename Func , typename... Args, enable_if_t< trait::is_available< T >::value, int > = 0>

this_type & tim::bundle< Tag, BundleT, TupleT >::type_apply	(	Func &&	_func,
		Args &&...	_args
	)

apply a member function to either a heap type or a type that is in a user_bundle

update_statistics() [1/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

bundle< Tag, BundleT, TupleT >::this_type & tim::bundle< Tag, BundleT, TupleT >::update_statistics

(

Args &&...

_args

)

Definition at line 817 of file bundle.cpp.

{
    return invoke<operation::add_statistics>(std::forward<Args>(_args)...);
}

References tim::_args.

update_statistics() [2/2]

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Args>

this_type & tim::bundle< Tag, BundleT, TupleT >::update_statistics

(

Args &&...

_args

)

perform an add_secondary operation. This operation allows components to add additional entries to storage which are their direct descendant

will_heap_init()

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::will_heap_init ( )

inlinestaticconstexpr

Query at compile-time whether initialization will occur on the heap. can_heap_init<T>() && !will_heap_init<T>() will indicate that a stack-allocated instance of the same type exists.

Definition at line 327 of file bundle.hpp.

    {
        using T = remove_pointer_decay_t<U>;
        return can_init<T>() && !can_stack_init<T>();
    }

will_opaque_init()

template<typename Tag , typename BundleT , typename TupleT >

template<typename U >

static constexpr bool tim::bundle< Tag, BundleT, TupleT >::will_opaque_init ( )

inlinestaticconstexpr

Query at compile-time whether initialization will happen with an opaque wrapper (i.e. via user bundle). In this situation, initialization arguments are ignored and the component will only be initialized with the tim::scope::config of the bundle.

Definition at line 338 of file bundle.hpp.

    {
        using T = remove_pointer_decay_t<U>;
        return !can_stack_init<T>() && !can_heap_init<T>() &&
               (trait::is_available<T>::value && has_user_bundle());
    }

Friends And Related Function Documentation

auto_base_bundle

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

friend class auto_base_bundle

friend

Definition at line 121 of file bundle.hpp.

auto_bundle

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

friend class auto_bundle

friend

Definition at line 124 of file bundle.hpp.

auto_list

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

friend class auto_list

friend

Definition at line 130 of file bundle.hpp.

auto_tuple

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

friend class auto_tuple

friend

Definition at line 127 of file bundle.hpp.

impl::base_bundle

template<typename Tag , typename BundleT , typename TupleT >

template<typename... Tp>

friend class impl::base_bundle

friend

Definition at line 118 of file bundle.hpp.

operator*

template<typename Tag , typename BundleT , typename TupleT >

template<typename Op >

enable_if_t<!std::is_arithmetic< Op >::value, this_type > operator* ( this_type  lhs, const Op &  rhs  )

friend

Definition at line 262 of file bundle.hpp.

    {
        return lhs *= rhs;
    }

operator+

template<typename Tag , typename BundleT , typename TupleT >

this_type operator+ ( this_type  lhs, const this_type &  rhs  )

friend

Definition at line 258 of file bundle.hpp.

{ return lhs += rhs; }

operator-

template<typename Tag , typename BundleT , typename TupleT >

this_type operator- ( this_type  lhs, const this_type &  rhs  )

friend

Definition at line 259 of file bundle.hpp.

{ return lhs -= rhs; }

operator/

template<typename Tag , typename BundleT , typename TupleT >

template<typename Op >

enable_if_t<!std::is_arithmetic< Op >::value, this_type > operator/ ( this_type  lhs, const Op &  rhs  )

friend

Definition at line 269 of file bundle.hpp.

    {
        return lhs /= rhs;
    }

operator<<

template<typename Tag , typename BundleT , typename TupleT >

std::ostream & operator<< ( std::ostream &  os, const bundle< Tag, BundleT, TupleT > &  obj  )

friend

Definition at line 275 of file bundle.hpp.

    {
        obj.print<true, true>(os);
        return os;
    }

Member Data Documentation

m_data

template<typename Tag , typename BundleT , typename TupleT >

data_type tim::bundle< Tag, BundleT, TupleT >::m_data {}

mutableprotected

Definition at line 849 of file bundle.hpp.

---

The documentation for this class was generated from the following files:

• timemory/variadic/bundle.hpp
• timemory/variadic/bundle.cpp