This is a variadic component wrapper which provides the least amount of runtime and compilation overhead. More...

#include "timemory/variadic/lightweight_tuple.hpp"

Collaboration diagram for tim::lightweight_tuple< Types >:

Public Types
using	captured_location_t = source_location::captured

using	this_type = lightweight_tuple< Types... >

using	type_list_type = type_list< Types... >

using	data_type = typename bundle_type::data_type

using	tuple_type = typename bundle_type::tuple_type

using	sample_type = typename bundle_type::sample_type

using	reference_type = typename bundle_type::reference_type

using	user_bundle_types = typename bundle_type::user_bundle_types

using	size_type = typename bundle_type::size_type

using	string_t = typename bundle_type::string_t

template<template< typename > class Op, typename Tuple = impl_type>
using	operation_t = typename bundle_type::template generic_operation< Op, Tuple >::type

template<template< typename > class Op, typename Tuple = impl_type>
using	custom_operation_t = typename bundle_type::template custom_operation< Op, Tuple >::type

using	auto_type = mpl::append_type_t< quirk::auto_start, this_type >

using	component_type = mpl::remove_type_t< quirk::auto_start, this_type >

using	type = convert_t< tuple_type, lightweight_tuple<> >

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, type_list< Types... >, U... >

Public Member Functions
	lightweight_tuple ()=default

template<typename... T>
	lightweight_tuple (const string_t &key, quirk::config< T... >={}, transient_func_t=get_initializer())

template<typename... T>
	lightweight_tuple (const captured_location_t &loc, quirk::config< T... >={}, transient_func_t=get_initializer())

template<typename... T>
	lightweight_tuple (size_t _hash, quirk::config< T... >={}, transient_func_t=get_initializer())

	lightweight_tuple (size_t _hash, scope::config _scope, transient_func_t=get_initializer())

	lightweight_tuple (const string_t &key, scope::config _scope, transient_func_t=get_initializer())

	lightweight_tuple (const captured_location_t &loc, scope::config _scope, transient_func_t=get_initializer())

	~lightweight_tuple ()

	lightweight_tuple (const lightweight_tuple &)=default

	lightweight_tuple (lightweight_tuple &&)=default

lightweight_tuple &	operator= (const lightweight_tuple &rhs)=default

lightweight_tuple &	operator= (lightweight_tuple &&)=default

lightweight_tuple	clone (bool store, scope::config _scope=scope::get_default())

this_type &	push ()
	generic push into storage More...

this_type &	pop ()
	generic pop out of storage 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 &	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 &	start (Args &&...)
	start all applicable components More...

template<typename... Tp, typename... Args>
this_type &	start (mpl::piecewise_select< Tp... >, Args &&...)
	selective start More...

template<typename... Tp, typename... Args>
this_type &	start (mpl::piecewise_ignore< Tp... >, Args &&...)
	selective start More...

template<typename... Args>
this_type &	stop (Args &&...)
	stop all applicable components More...

template<typename... Tp, typename... Args>
this_type &	stop (mpl::piecewise_select< Tp... >, Args &&...)
	selective stop More...

template<typename... Tp, typename... Args>
this_type &	stop (mpl::piecewise_ignore< Tp... >, Args &&...)
	selection stop More...

template<typename... Args>
this_type &	measure (Args &&...)
	generic More...

template<typename... Args>
this_type &	sample (Args &&...)
	generic More...

template<typename... Args>
this_type &	record (Args &&...)
	generic More...

template<typename... Args>
this_type &	reset (Args &&...)
	generic More...

template<typename... Args>
auto	get (Args &&...) const
	generic More...

template<typename... Args>
auto	get_labeled (Args &&...) const
	generic More...

data_type &	data ()
	get tuple More...

const data_type &	data () const
	get tuple More...

this_type &	set_scope (scope::config)
	set scope configuration 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...

this_type &	assemble ()
	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, size_t N = sizeof...(Args), enable_if_t< N !=0, int > = 0>
this_type &	assemble (Args &&... _args)

this_type &	derive ()
	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, size_t N = sizeof...(Args), enable_if_t< N !=0, int > = 0>
this_type &	derive (Args &&... _args)

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)
	apply a user-defined operation to all the components 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 a specific set of component types More...

template<typename T , enable_if_t< is_one_of< T, data_type >::value, int > = 0>
T *	get ()
	get member functions taking either a type More...

template<typename T , enable_if_t< is_one_of< T, data_type >::value, int > = 0>
const T *	get () const

template<typename T , enable_if_t<!is_one_of< T, data_type >::value, int > = 0>
T *	get () const

this_type &	get (void *&ptr, size_t _hash) const

template<typename T , typename FuncT >
decltype(auto)	get (FuncT &&_func)
	get member functions finding component and applying lambda More...

template<typename T , typename FuncT >
decltype(auto)	get (FuncT &&_func) const

template<typename U , typename T = std::remove_pointer_t<decay_t<U>>, enable_if_t< trait::is_available< T >::value &&is_one_of< T, data_type >::value, int > = 0>
auto	get_component ()
	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 T , typename... Args, enable_if_t<!is_one_of< T, reference_type >::value &&has_user_bundle_v, int > = 0>
bool	init (Args &&...)

template<typename T , typename... Args, enable_if_t<!is_one_of< T, reference_type >::value &&!has_user_bundle_v, int > = 0>
bool	init (Args &&...)

template<typename... T, typename... Args>
auto	initialize (Args &&... args)
	variadic initialization 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 type that is in variadic list AND is available 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 &&, Args &&...)

this_type &	operator-= (const this_type &rhs)

this_type &	operator-= (this_type &rhs)

this_type &	operator+= (const this_type &rhs)

this_type &	operator+= (this_type &rhs)

template<typename Op >
this_type &	operator-= (Op &&rhs)

template<typename Op >
this_type &	operator+= (Op &&rhs)

template<typename Op >
this_type &	operator*= (Op &&rhs)

template<typename Op >
this_type &	operator/= (Op &&rhs)

template<bool PrintPrefix = true, bool PrintLaps = true>
this_type &	print (std::ostream &os, bool skip_wo_hash=true) const

template<typename Archive >
void	serialize (Archive &ar, const unsigned int)

int64_t	laps () const

std::string	key () const

uint64_t	hash () const

bool &	store ()

const bool &	store () const

auto	prefix () const

auto	get_prefix () const

void	rekey (const string_t &_key)

void	rekey (const captured_location_t &_loc)

void	rekey (uint64_t _hash)

data_type &	get_data ()

const data_type &	get_data () const

template<typename... Tp>
lightweight_tuple< Types... > &	push (mpl::piecewise_select< Tp... >)

template<typename... Tp>
lightweight_tuple< Types... > &	push (mpl::piecewise_ignore< Tp... >)

template<typename... Tp>
lightweight_tuple< Types... > &	pop (mpl::piecewise_select< Tp... >)

template<typename... Tp>
lightweight_tuple< Types... > &	pop (mpl::piecewise_ignore< Tp... >)

template<typename... Args>
lightweight_tuple< Types... > &	measure (Args &&... args)

template<typename... Args>
lightweight_tuple< Types... > &	sample (Args &&... args)

template<typename... Args>
lightweight_tuple< Types... > &	start (Args &&... args)

template<typename... Tp, typename... Args>
lightweight_tuple< Types... > &	start (mpl::piecewise_select< Tp... >, Args &&... args)

template<typename... Tp, typename... Args>
lightweight_tuple< Types... > &	start (mpl::piecewise_ignore< Tp... >, Args &&... args)

template<typename... Args>
lightweight_tuple< Types... > &	stop (Args &&... args)

template<typename... Tp, typename... Args>
lightweight_tuple< Types... > &	stop (mpl::piecewise_select< Tp... >, Args &&... args)

template<typename... Tp, typename... Args>
lightweight_tuple< Types... > &	stop (mpl::piecewise_ignore< Tp... >, Args &&... args)

template<typename... Args>
lightweight_tuple< Types... > &	record (Args &&... args)

template<typename... Args>
lightweight_tuple< Types... > &	reset (Args &&... args)

template<typename... Args>
auto	get (Args &&... args) const

template<typename... Args>
auto	get_labeled (Args &&... args) const

Static Public Member Functions
static initializer_type &	get_initializer ()

static constexpr std::size_t	size ()

static void	init_storage ()
	requests the component initialize their storage More...

Static Public Attributes
static constexpr bool	has_gotcha_v = bundle_type::has_gotcha_v

static constexpr bool	has_user_bundle_v = bundle_type::has_user_bundle_v

Protected Types
using	apply_v = mpl::apply< void >

using	bundle_type = stack_bundle< mpl::available_t< type_list< Types... > > >

using	impl_type = typename bundle_type::impl_type

Protected Member Functions
void	set_prefix (const string_t &) const

void	set_prefix (size_t) const

Protected Attributes
data_type	m_data = data_type{}

Friends
template<typename... Tp>
class	impl::base_bundle

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

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

template<typename Op >
this_type	operator* (const this_type &lhs, Op &&rhs)

template<typename Op >
this_type	operator/ (const this_type &lhs, Op &&rhs)

std::ostream &	operator<< (std::ostream &os, const this_type &obj)

Detailed Description

template<typename... Types>
class tim::lightweight_tuple< Types >

This is a variadic component wrapper which provides the least amount of runtime and compilation overhead.

Template Parameters

Types Specification of the component types to bundle together

Definition at line 67 of file lightweight_tuple.hpp.

Member Typedef Documentation

◆ apply_v

template<typename... Types>

using tim::lightweight_tuple< Types >::apply_v = mpl::apply<void>

protected

Definition at line 72 of file lightweight_tuple.hpp.

◆ auto_type

template<typename... Types>

using tim::lightweight_tuple< Types >::auto_type = mpl::append_type_t<quirk::auto_start, this_type>

Definition at line 101 of file lightweight_tuple.hpp.

◆ bundle_type

template<typename... Types>

using tim::lightweight_tuple< Types >::bundle_type = stack_bundle<mpl::available_t<type_list<Types...> >>

protected

Definition at line 73 of file lightweight_tuple.hpp.

◆ captured_location_t

template<typename... Types>

using tim::lightweight_tuple< Types >::captured_location_t = source_location::captured

Definition at line 80 of file lightweight_tuple.hpp.

◆ component_type

template<typename... Types>

using tim::lightweight_tuple< Types >::component_type = mpl::remove_type_t<quirk::auto_start, this_type>

Definition at line 102 of file lightweight_tuple.hpp.

◆ custom_operation_t

template<typename... Types>

template<template< typename > class Op, typename Tuple = impl_type>

using tim::lightweight_tuple< Types >::custom_operation_t = typename bundle_type::template custom_operation<Op, Tuple>::type

Definition at line 98 of file lightweight_tuple.hpp.

◆ data_type

template<typename... Types>

using tim::lightweight_tuple< Types >::data_type = typename bundle_type::data_type

Definition at line 85 of file lightweight_tuple.hpp.

◆ impl_type

template<typename... Types>

using tim::lightweight_tuple< Types >::impl_type = typename bundle_type::impl_type

protected

Definition at line 74 of file lightweight_tuple.hpp.

◆ initializer_type

template<typename... Types>

using tim::lightweight_tuple< Types >::initializer_type = std::function<void(this_type&)>

Definition at line 104 of file lightweight_tuple.hpp.

◆ operation_t

template<typename... Types>

template<template< typename > class Op, typename Tuple = impl_type>

using tim::lightweight_tuple< Types >::operation_t = typename bundle_type::template generic_operation<Op, Tuple>::type

Definition at line 95 of file lightweight_tuple.hpp.

◆ quirk_config

template<typename... Types>

template<typename T , typename... U>

using tim::lightweight_tuple< Types >::quirk_config = tim::variadic::impl::quirk_config<T, type_list<Types...>, U...>

Definition at line 118 of file lightweight_tuple.hpp.

◆ reference_type

template<typename... Types>

using tim::lightweight_tuple< Types >::reference_type = typename bundle_type::reference_type

Definition at line 88 of file lightweight_tuple.hpp.

◆ sample_type

template<typename... Types>

using tim::lightweight_tuple< Types >::sample_type = typename bundle_type::sample_type

Definition at line 87 of file lightweight_tuple.hpp.

◆ size_type

template<typename... Types>

using tim::lightweight_tuple< Types >::size_type = typename bundle_type::size_type

Definition at line 91 of file lightweight_tuple.hpp.

◆ string_t

template<typename... Types>

using tim::lightweight_tuple< Types >::string_t = typename bundle_type::string_t

Definition at line 92 of file lightweight_tuple.hpp.

◆ this_type

template<typename... Types>

using tim::lightweight_tuple< Types >::this_type = lightweight_tuple<Types...>

Definition at line 82 of file lightweight_tuple.hpp.

◆ transient_func_t

template<typename... Types>

using tim::lightweight_tuple< Types >::transient_func_t = utility::transient_function<void(this_type&)>

Definition at line 105 of file lightweight_tuple.hpp.

◆ tuple_type

template<typename... Types>

using tim::lightweight_tuple< Types >::tuple_type = typename bundle_type::tuple_type

Definition at line 86 of file lightweight_tuple.hpp.

◆ type

template<typename... Types>

using tim::lightweight_tuple< Types >::type = convert_t<tuple_type, lightweight_tuple<> >

Definition at line 103 of file lightweight_tuple.hpp.

◆ type_list_type

template<typename... Types>

using tim::lightweight_tuple< Types >::type_list_type = type_list<Types...>

Definition at line 83 of file lightweight_tuple.hpp.

◆ user_bundle_types

template<typename... Types>

using tim::lightweight_tuple< Types >::user_bundle_types = typename bundle_type::user_bundle_types

Definition at line 89 of file lightweight_tuple.hpp.

Constructor & Destructor Documentation

◆ lightweight_tuple() [1/9]

template<typename... Types>

tim::lightweight_tuple< Types >::lightweight_tuple ( )

default

◆ lightweight_tuple() [2/9]

template<typename... Types>

template<typename... T>

tim::lightweight_tuple< Types >::lightweight_tuple	(	const string_t &	key,
		quirk::config< T... >	_config = `{}`,
		transient_func_t	_init_func = `get_initializer()`
	)

explicit

Definition at line 45 of file lightweight_tuple.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _key, false_type{}, _config))
, m_data(invoke::construct<data_type>(_key, _config))
{
    bundle_type::init(type_list_type{}, *this, m_data, std::move(_init_func), _config);
}

◆ lightweight_tuple() [3/9]

template<typename... Types>

template<typename... T>

tim::lightweight_tuple< Types >::lightweight_tuple	(	const captured_location_t &	loc,
		quirk::config< T... >	_config = `{}`,
		transient_func_t	_init_func = `get_initializer()`
	)

explicit

Definition at line 58 of file lightweight_tuple.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _loc, false_type{}, _config))
, m_data(invoke::construct<data_type>(_loc, _config))
{
    bundle_type::init(type_list_type{}, *this, m_data, std::move(_init_func), _config);
}

◆ lightweight_tuple() [4/9]

template<typename... Types>

template<typename... T>

tim::lightweight_tuple< Types >::lightweight_tuple	(	size_t	_hash,
		quirk::config< T... >	_config = `{}`,
		transient_func_t	_init_func = `get_initializer()`
	)

explicit

Definition at line 71 of file lightweight_tuple.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _hash, false_type{}, _config))
, m_data(invoke::construct<data_type>(_hash, _config))
{
    bundle_type::init(type_list_type{}, *this, m_data, std::move(_init_func), _config);
}

◆ lightweight_tuple() [5/9]

template<typename... Types>

tim::lightweight_tuple< Types >::lightweight_tuple	(	size_t	_hash,
		scope::config	_scope,
		transient_func_t	_init_func = `get_initializer()`
	)

explicit

Definition at line 82 of file lightweight_tuple.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _hash, false_type{}, _scope))
, m_data(invoke::construct<data_type>(_hash, m_scope))
{
    bundle_type::init(type_list_type{}, *this, m_data, std::move(_init_func));
}

◆ lightweight_tuple() [6/9]

template<typename... Types>

tim::lightweight_tuple< Types >::lightweight_tuple	(	const string_t &	key,
		scope::config	_scope,
		transient_func_t	_init_func = `get_initializer()`
	)

explicit

Definition at line 93 of file lightweight_tuple.cpp.

: bundle_type(bundle_type::handle(type_list_type{}, _key, false_type{}, _scope))
{
    bundle_type::init(type_list_type{}, *this, m_data, std::move(_init_func));
}

References tim::init(), and tim::lightweight_tuple< Types >::m_data.

◆ lightweight_tuple() [7/9]

template<typename... Types>

tim::lightweight_tuple< Types >::lightweight_tuple	(	const captured_location_t &	loc,
		scope::config	_scope,
		transient_func_t	_init_func = `get_initializer()`
	)

explicit

Definition at line 103 of file lightweight_tuple.cpp.

106: lightweight_tuple(loc.get_hash(), _scope, std::move(_init_func))

107{}

tim::lightweight_tuple::lightweight_tuple

lightweight_tuple()=default

◆ ~lightweight_tuple()

template<typename... Types>

tim::lightweight_tuple< Types >::~lightweight_tuple

Definition at line 112 of file lightweight_tuple.cpp.

{
    IF_CONSTEXPR(!quirk_config<quirk::explicit_stop>::value)
    {
        if(m_is_active())
            stop();
    }
}

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

◆ lightweight_tuple() [8/9]

template<typename... Types>

tim::lightweight_tuple< Types >::lightweight_tuple ( const lightweight_tuple< Types > & )

default

◆ lightweight_tuple() [9/9]

template<typename... Types>

tim::lightweight_tuple< Types >::lightweight_tuple ( lightweight_tuple< Types > && )

default

Member Function Documentation

◆ add_secondary()

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::add_secondary ( Args &&... _args )

inline

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

Definition at line 344 of file lightweight_tuple.hpp.

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

References tim::_args.

◆ assemble() [1/2]

template<typename... Types>

this_type & tim::lightweight_tuple< Types >::assemble ( )

inline

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.

Definition at line 280 of file lightweight_tuple.hpp.

280{ invoke::assemble(m_data, *this); }

tim::invoke::assemble

void assemble(TupleT< Tp... > &obj, Args &&... args)

Definition: functional.cpp:868

References tim::invoke::assemble(), and tim::lightweight_tuple< Types >::m_data.

◆ assemble() [2/2]

template<typename... Types>

template<typename... Args, size_t N = sizeof...(Args), enable_if_t< N !=0, int > = 0>

this_type & tim::lightweight_tuple< Types >::assemble ( Args &&... _args )

inline

Definition at line 283 of file lightweight_tuple.hpp.

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

References tim::_args, tim::invoke::assemble(), and tim::lightweight_tuple< Types >::m_data.

◆ audit()

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::audit ( Args &&... _args )

inline

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

Definition at line 335 of file lightweight_tuple.hpp.

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

References tim::_args, tim::invoke::audit(), and tim::lightweight_tuple< Types >::m_data.

◆ clone()

template<typename... Types>

lightweight_tuple< Types... > tim::lightweight_tuple< Types >::clone	(	bool	store,
		scope::config	_scope = `scope::get_default()`
	)

Definition at line 125 of file lightweight_tuple.cpp.

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

◆ construct()

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::construct ( Args &&... _args )

inline

construct the objects that have constructors with matching arguments

Definition at line 269 of file lightweight_tuple.hpp.

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

References tim::_args, and tim::lightweight_tuple< Types >::m_data.

◆ data() [1/2]

template<typename... Types>

lightweight_tuple< Types... >::data_type & tim::lightweight_tuple< Types >::data

get tuple

Definition at line 434 of file lightweight_tuple.cpp.

{
    return m_data;
}

Referenced by std::get().

◆ data() [2/2]

template<typename... Types>

const lightweight_tuple< Types... >::data_type & tim::lightweight_tuple< Types >::data

get tuple

Definition at line 443 of file lightweight_tuple.cpp.

{
    return m_data;
}

◆ derive() [1/2]

template<typename... Types>

this_type & tim::lightweight_tuple< Types >::derive ( )

inline

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

Definition at line 294 of file lightweight_tuple.hpp.

294{ invoke::derive(m_data, *this); }

tim::invoke::derive

void derive(TupleT< Tp... > &obj, Args &&... args)

Definition: functional.cpp:904

References tim::invoke::derive(), and tim::lightweight_tuple< Types >::m_data.

◆ derive() [2/2]

template<typename... Types>

template<typename... Args, size_t N = sizeof...(Args), enable_if_t< N !=0, int > = 0>

this_type & tim::lightweight_tuple< Types >::derive ( Args &&... _args )

inline

Definition at line 297 of file lightweight_tuple.hpp.

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

References tim::_args, tim::invoke::derive(), and tim::lightweight_tuple< Types >::m_data.

◆ execute()

template<typename... Types>

template<typename FuncT , typename... Args>

decltype(auto) tim::lightweight_tuple< Types >::execute	(	FuncT &&	func,
		Args &&...	args
	)

inline

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

Definition at line 260 of file lightweight_tuple.hpp.

    {
        return mpl::execute(*this,
                            std::forward<FuncT>(func)(std::forward<Args>(args)...));
    }

References tim::mpl::execute().

◆ get() [1/8]

template<typename... Types>

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

T * tim::lightweight_tuple< Types >::get ( )

inline

get member functions taking either a type

Definition at line 391 of file lightweight_tuple.hpp.

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

References tim::lightweight_tuple< Types >::m_data.

Referenced by tim::lightweight_tuple< Types >::get().

◆ get() [2/8]

template<typename... Types>

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

const T * tim::lightweight_tuple< Types >::get ( ) const

inline

Definition at line 397 of file lightweight_tuple.hpp.

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

References tim::lightweight_tuple< Types >::m_data.

◆ get() [3/8]

template<typename... Types>

template<typename T , enable_if_t<!is_one_of< T, data_type >::value, int > = 0>

T * tim::lightweight_tuple< Types >::get ( ) const

inline

Definition at line 403 of file lightweight_tuple.hpp.

    {
        void* ptr = nullptr;
        get(ptr, typeid_hash<T>());
        return static_cast<T*>(ptr);
    }

References tim::lightweight_tuple< Types >::get().

◆ get() [4/8]

template<typename... Types>

template<typename... Args>

auto tim::lightweight_tuple< Types >::get ( Args &&... args ) const

Definition at line 369 of file lightweight_tuple.cpp.

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

References tim::invoke::get().

◆ get() [5/8]

template<typename... Types>

template<typename... Args>

auto tim::lightweight_tuple< Types >::get ( Args && ... ) const

generic

◆ get() [6/8]

template<typename... Types>

template<typename T , typename FuncT >

decltype(auto) tim::lightweight_tuple< Types >::get ( FuncT && _func )

get member functions finding component and applying lambda

◆ get() [7/8]

template<typename... Types>

template<typename T , typename FuncT >

decltype(auto) tim::lightweight_tuple< Types >::get ( FuncT && _func ) const

◆ get() [8/8]

template<typename... Types>

this_type & tim::lightweight_tuple< Types >::get	(	void *&	ptr,
		size_t	_hash
	)		const

inline

Definition at line 410 of file lightweight_tuple.hpp.

    {
        using get_t = operation_t<operation::get>;
        apply_v::access<get_t>(m_data, ptr, _hash);
        return get_this_type();
    }

References tim::lightweight_tuple< Types >::m_data.

◆ get_component()

template<typename... Types>

template<typename U , typename T = std::remove_pointer_t<decay_t<U>>, enable_if_t< trait::is_available< T >::value &&is_one_of< T, data_type >::value, int > = 0>

auto tim::lightweight_tuple< Types >::get_component ( )

inline

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 431 of file lightweight_tuple.hpp.

    {
        return get<T>();
    }

◆ get_data() [1/2]

template<typename... Types>

data_type & tim::lightweight_tuple< Types >::get_data ( )

◆ get_data() [2/2]

template<typename... Types>

const data_type & tim::lightweight_tuple< Types >::get_data ( ) const

◆ get_initializer()

template<typename... Types>

static initializer_type & tim::lightweight_tuple< Types >::get_initializer ( )

inlinestatic

Definition at line 111 of file lightweight_tuple.hpp.

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

◆ get_labeled() [1/2]

template<typename... Types>

template<typename... Args>

auto tim::lightweight_tuple< Types >::get_labeled ( Args &&... args ) const

Definition at line 380 of file lightweight_tuple.cpp.

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

References tim::invoke::get_labeled().

◆ get_labeled() [2/2]

template<typename... Types>

template<typename... Args>

auto tim::lightweight_tuple< Types >::get_labeled ( Args && ... ) const

generic

◆ get_prefix()

template<typename... Types>

auto tim::lightweight_tuple< Types >::get_prefix ( ) const

inline

Definition at line 645 of file lightweight_tuple.hpp.

645{ return bundle_type::get_prefix(); }

Referenced by tim::lightweight_tuple< Types >::print().

◆ hash()

template<typename... Types>

uint64_t tim::lightweight_tuple< Types >::hash ( ) const

inline

Definition at line 641 of file lightweight_tuple.hpp.

641{ return bundle_type::hash(); }

◆ init() [1/2]

template<typename... Types>

template<typename T , typename... Args, enable_if_t<!is_one_of< T, reference_type >::value &&has_user_bundle_v, int > = 0>

bool tim::lightweight_tuple< Types >::init ( Args && ... )

inline

Definition at line 441 of file lightweight_tuple.hpp.

    {
        using bundle_t = decltype(std::get<0>(std::declval<user_bundle_types>()));
        this->init<bundle_t>();
        this->get<bundle_t>()->insert(component::factory::get_opaque<T>(m_scope),
                                      component::factory::get_typeids<T>());
        return true;
    }

◆ init() [2/2]

template<typename... Types>

template<typename T , typename... Args, enable_if_t<!is_one_of< T, reference_type >::value &&!has_user_bundle_v, int > = 0>

bool tim::lightweight_tuple< Types >::init ( Args && ... )

inline

Definition at line 455 of file lightweight_tuple.hpp.

    {
        return is_one_of<T, reference_type>::value;
    }

◆ init_storage()

template<typename... Types>

void tim::lightweight_tuple< Types >::init_storage

static

requests the component initialize their storage

Definition at line 483 of file lightweight_tuple.cpp.

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

References tim::consume_parameters().

◆ initialize()

template<typename... Types>

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

auto tim::lightweight_tuple< Types >::initialize ( Args &&... args )

inline

variadic initialization

Definition at line 464 of file lightweight_tuple.hpp.

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

References TIMEMORY_FOLD_EXPANSION.

◆ invoke() [1/3]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::invoke ( Args &&... _args )

inline

apply a user-defined operation to all the components

Template Parameters

OpT	Operation struct

Definition at line 360 of file lightweight_tuple.hpp.

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

References tim::_args, and tim::lightweight_tuple< Types >::m_data.

◆ invoke() [2/3]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::invoke	(	mpl::piecewise_ignore< Tp... >	,
		Args &&...	_args
	)

inline

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

Template Parameters

OpT	Operation struct

Definition at line 381 of file lightweight_tuple.hpp.

    {
        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() [3/3]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::invoke	(	mpl::piecewise_select< Tp... >	,
		Args &&...	_args
	)

inline

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

Template Parameters

OpT	Operation struct

Definition at line 370 of file lightweight_tuple.hpp.

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

References tim::_args.

◆ key()

template<typename... Types>

std::string tim::lightweight_tuple< Types >::key ( ) const

inline

Definition at line 640 of file lightweight_tuple.hpp.

640{ return bundle_type::key(); }

Referenced by tim::lightweight_tuple< Types >::print().

◆ laps()

template<typename... Types>

int64_t tim::lightweight_tuple< Types >::laps ( ) const

inline

Definition at line 639 of file lightweight_tuple.hpp.

639{ return bundle_type::laps(); }

◆ mark_begin()

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::mark_begin ( Args &&... _args )

inline

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

Definition at line 307 of file lightweight_tuple.hpp.

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

References tim::_args, tim::lightweight_tuple< Types >::m_data, and tim::invoke::mark_begin().

◆ mark_end()

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::mark_end ( Args &&... _args )

inline

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

Definition at line 317 of file lightweight_tuple.hpp.

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

References tim::_args, tim::lightweight_tuple< Types >::m_data, and tim::invoke::mark_end().

◆ measure() [1/2]

template<typename... Types>

template<typename... Args>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::measure ( Args &&... args )

Definition at line 235 of file lightweight_tuple.cpp.

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

References tim::invoke::measure().

◆ measure() [2/2]

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::measure ( Args && ... )

generic

◆ operator*=()

template<typename... Types>

template<typename Op >

this_type & tim::lightweight_tuple< Types >::operator*= ( Op && rhs )

inline

Definition at line 518 of file lightweight_tuple.hpp.

    {
        using multiply_t = operation_t<operation::multiply>;
        apply_v::access<multiply_t>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

References tim::lightweight_tuple< Types >::m_data.

◆ operator+=() [1/3]

template<typename... Types>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::operator+= ( const this_type & rhs )

Definition at line 412 of file lightweight_tuple.cpp.

{
    invoke::invoke_impl::invoke_data<operation::plus, TIMEMORY_API>(m_data, rhs.m_data);
    m_laps += rhs.m_laps;
    return get_this_type();
}

References tim::lightweight_tuple< Types >::m_data.

◆ operator+=() [2/3]

template<typename... Types>

template<typename Op >

this_type & tim::lightweight_tuple< Types >::operator+= ( Op && rhs )

inline

Definition at line 510 of file lightweight_tuple.hpp.

    {
        using plus_t = operation_t<operation::plus>;
        apply_v::access<plus_t>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

References tim::lightweight_tuple< Types >::m_data.

◆ operator+=() [3/3]

template<typename... Types>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::operator+= ( this_type & rhs )

Definition at line 423 of file lightweight_tuple.cpp.

{
    invoke::invoke_impl::invoke_data<operation::plus, TIMEMORY_API>(m_data, rhs.m_data);
    m_laps += rhs.m_laps;
    return get_this_type();
}

References tim::lightweight_tuple< Types >::m_data.

◆ operator-=() [1/3]

template<typename... Types>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::operator-= ( const this_type & rhs )

Definition at line 390 of file lightweight_tuple.cpp.

{
    invoke::invoke_impl::invoke_data<operation::minus, TIMEMORY_API>(m_data, rhs.m_data);
    m_laps -= rhs.m_laps;
    return get_this_type();
}

References tim::lightweight_tuple< Types >::m_data.

◆ operator-=() [2/3]

template<typename... Types>

template<typename Op >

this_type & tim::lightweight_tuple< Types >::operator-= ( Op && rhs )

inline

Definition at line 502 of file lightweight_tuple.hpp.

    {
        using minus_t = operation_t<operation::minus>;
        apply_v::access<minus_t>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

References tim::lightweight_tuple< Types >::m_data.

◆ operator-=() [3/3]

template<typename... Types>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::operator-= ( this_type & rhs )

Definition at line 401 of file lightweight_tuple.cpp.

{
    invoke::invoke_impl::invoke_data<operation::minus, TIMEMORY_API>(m_data, rhs.m_data);
    m_laps -= rhs.m_laps;
    return get_this_type();
}

References tim::lightweight_tuple< Types >::m_data.

◆ operator/=()

template<typename... Types>

template<typename Op >

this_type & tim::lightweight_tuple< Types >::operator/= ( Op && rhs )

inline

Definition at line 526 of file lightweight_tuple.hpp.

    {
        using divide_t = operation_t<operation::divide>;
        apply_v::access<divide_t>(m_data, std::forward<Op>(rhs));
        return get_this_type();
    }

References tim::lightweight_tuple< Types >::m_data.

◆ operator=() [1/2]

template<typename... Types>

lightweight_tuple & tim::lightweight_tuple< Types >::operator= ( const lightweight_tuple< Types > & rhs )

default

◆ operator=() [2/2]

template<typename... Types>

lightweight_tuple & tim::lightweight_tuple< Types >::operator= ( lightweight_tuple< Types > && )

default

◆ pop() [1/5]

template<typename... Types>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::pop

generic pop out of storage

Definition at line 189 of file lightweight_tuple.cpp.

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

References tim::invoke::pop().

◆ pop() [2/5]

template<typename... Types>

template<typename... Tp>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::pop ( mpl::piecewise_ignore< Tp... > )

Definition at line 220 of file lightweight_tuple.cpp.

{
    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... Types>

template<typename... Tp>

this_type & tim::lightweight_tuple< Types >::pop ( mpl::piecewise_ignore< Tp... > )

selective pop

◆ pop() [4/5]

template<typename... Types>

template<typename... Tp>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::pop ( mpl::piecewise_select< Tp... > )

Definition at line 206 of file lightweight_tuple.cpp.

{
    using pw_type = mpl::implemented_t<Tp...>;
    // set the current node to the parent node
    invoke_piecewise<operation::pop_node>(pw_type{});
    return get_this_type();
}

◆ pop() [5/5]

template<typename... Types>

template<typename... Tp>

this_type & tim::lightweight_tuple< Types >::pop ( mpl::piecewise_select< Tp... > )

selective pop

◆ prefix()

template<typename... Types>

auto tim::lightweight_tuple< Types >::prefix ( ) const

inline

Definition at line 644 of file lightweight_tuple.hpp.

644{ return bundle_type::prefix(); }

◆ print()

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::print	(	std::ostream &	os,
		bool	skip_wo_hash = `true`
	)		const

inline

Definition at line 565 of file lightweight_tuple.hpp.

    {
        using printer_t = typename bundle_type::print_type;
        if(size() == 0)
            return get_this_type();
        if(m_hash == 0 && skip_wo_hash)
            return get_this_type();
        std::stringstream ss_data;
        apply_v::access_with_indices<printer_t>(m_data, std::ref(ss_data), false);
        IF_CONSTEXPR(PrintPrefix)
        {
            bundle_type::update_width();
            auto _key = key();
            if(_key.length() > 0)
            {
                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 << "]";
        return get_this_type();
    }

References tim::lightweight_tuple< Types >::get_prefix(), IF_CONSTEXPR, tim::lightweight_tuple< Types >::key(), tim::lightweight_tuple< Types >::m_data, tim::os, and tim::lightweight_tuple< Types >::size().

◆ push() [1/5]

template<typename... Types>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::push

generic push into storage

Definition at line 138 of file lightweight_tuple.cpp.

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

References tim::invoke::push(), and tim::invoke::reset().

◆ push() [2/5]

template<typename... Types>

template<typename... Tp>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::push ( mpl::piecewise_ignore< Tp... > )

Definition at line 173 of file lightweight_tuple.cpp.

{
    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/5]

template<typename... Types>

template<typename... Tp>

this_type & tim::lightweight_tuple< Types >::push ( mpl::piecewise_ignore< Tp... > )

selective push

◆ push() [4/5]

template<typename... Types>

template<typename... Tp>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::push ( mpl::piecewise_select< Tp... > )

Definition at line 157 of file lightweight_tuple.cpp.

{
    using pw_type = mpl::implemented_t<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() [5/5]

template<typename... Types>

template<typename... Tp>

this_type & tim::lightweight_tuple< Types >::push ( mpl::piecewise_select< Tp... > )

selective push

◆ record() [1/2]

template<typename... Types>

template<typename... Args>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::record ( Args &&... args )

Definition at line 343 of file lightweight_tuple.cpp.

{
    ++m_laps;
    invoke::record(m_data, std::forward<Args>(args)...);
    return get_this_type();
}

References tim::invoke::record().

◆ record() [2/2]

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::record ( Args && ... )

generic

◆ rekey() [1/3]

template<typename... Types>

void tim::lightweight_tuple< Types >::rekey ( const captured_location_t & _loc )

Definition at line 700 of file lightweight_tuple.hpp.

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

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

◆ rekey() [2/3]

template<typename... Types>

void tim::lightweight_tuple< Types >::rekey ( const string_t & _key )

Definition at line 690 of file lightweight_tuple.hpp.

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

References tim::invoke::set_prefix().

◆ rekey() [3/3]

template<typename... Types>

void tim::lightweight_tuple< Types >::rekey ( uint64_t _hash )

Definition at line 710 of file lightweight_tuple.hpp.

{
    m_hash = _hash;
    set_prefix(_hash);
}

References tim::invoke::set_prefix().

◆ reset() [1/2]

template<typename... Types>

template<typename... Args>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::reset ( Args &&... args )

Definition at line 356 of file lightweight_tuple.cpp.

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

References tim::invoke::reset().

◆ reset() [2/2]

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::reset ( Args && ... )

generic

◆ sample() [1/2]

template<typename... Types>

template<typename... Args>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::sample ( Args &&... args )

Definition at line 247 of file lightweight_tuple.cpp.

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

◆ sample() [2/2]

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::sample ( Args && ... )

generic

◆ serialize()

template<typename... Types>

template<typename Archive >

void tim::lightweight_tuple< Types >::serialize	(	Archive &	ar,
		const unsigned int
	)

inline

Definition at line 612 of file lightweight_tuple.hpp.

    {
        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();
    }

References tim::lightweight_tuple< Types >::m_data, PRINT_HERE, and tim::invoke::serialize().

◆ set_prefix() [1/2]

template<typename... Types>

void tim::lightweight_tuple< Types >::set_prefix ( const string_t & _key ) const

protected

Definition at line 452 of file lightweight_tuple.cpp.

{
    invoke::set_prefix(m_data, m_hash, _key);
}

References tim::invoke::set_prefix().

◆ set_prefix() [2/2]

template<typename... Types>

void tim::lightweight_tuple< Types >::set_prefix ( size_t _hash ) const

protected

Definition at line 461 of file lightweight_tuple.cpp.

{
    auto itr = get_hash_ids()->find(_hash);
    if(itr != get_hash_ids()->end())
        invoke::set_prefix(m_data, _hash, itr->second);
}

References tim::invoke::set_prefix().

◆ set_scope()

template<typename... Types>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::set_scope ( scope::config val )

set scope configuration

Definition at line 472 of file lightweight_tuple.cpp.

{
    m_scope = val;
    invoke::set_scope(m_data, m_scope);
    return get_this_type();
}

References tim::invoke::set_scope().

◆ size()

template<typename... Types>

static constexpr std::size_t tim::lightweight_tuple< Types >::size ( )

inlinestaticconstexpr

Definition at line 161 of file lightweight_tuple.hpp.

161{ return std::tuple_size<tuple_type>::value; }

Referenced by tim::lightweight_tuple< Types >::print().

◆ start() [1/6]

template<typename... Types>

template<typename... Args>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::start ( Args &&... args )

Definition at line 259 of file lightweight_tuple.cpp.

{
    invoke::start(m_data, std::forward<Args>(args)...);
    m_is_active(true);
    return get_this_type();
}

References tim::invoke::start().

◆ start() [2/6]

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::start ( Args && ... )

start all applicable components

◆ start() [3/6]

template<typename... Types>

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

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::start	(	mpl::piecewise_ignore< Tp... >	,
		Args &&...	args
	)

Definition at line 285 of file lightweight_tuple.cpp.

{
    using selected_t =
        convert_t<mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>,
                  std::tuple<>>;
    auto&& _data = mpl::get_reference_tuple<selected_t>(m_data);
    invoke::start(_data, std::forward<Args>(args)...);
    return get_this_type();
}

References tim::invoke::start().

◆ start() [4/6]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::start	(	mpl::piecewise_ignore< Tp... >	,
		Args &&	...
	)

selective start

◆ start() [5/6]

template<typename... Types>

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

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::start	(	mpl::piecewise_select< Tp... >	,
		Args &&...	args
	)

Definition at line 272 of file lightweight_tuple.cpp.

{
    auto&& _data = mpl::get_reference_tuple<mpl::available_t<std::tuple<Tp...>>>(m_data);
    invoke::start(_data, std::forward<Args>(args)...);
    return get_this_type();
}

References tim::mpl::get_reference_tuple(), and tim::invoke::start().

◆ start() [6/6]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::start	(	mpl::piecewise_select< Tp... >	,
		Args &&	...
	)

selective start

◆ stop() [1/6]

template<typename... Types>

template<typename... Args>

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::stop ( Args &&... args )

Definition at line 300 of file lightweight_tuple.cpp.

{
    invoke::stop(m_data, std::forward<Args>(args)...);
    ++m_laps;
    m_is_active(false);
    return get_this_type();
}

References tim::invoke::stop().

◆ stop() [2/6]

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::stop ( Args && ... )

stop all applicable components

◆ stop() [3/6]

template<typename... Types>

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

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::stop	(	mpl::piecewise_ignore< Tp... >	,
		Args &&...	args
	)

Definition at line 327 of file lightweight_tuple.cpp.

{
    using selected_t =
        convert_t<mpl::subtract_t<mpl::available_t<type_list_type>, type_list<Tp...>>,
                  std::tuple<>>;
    auto&& _data = mpl::get_reference_tuple<selected_t>(m_data);
    invoke::stop(_data, std::forward<Args>(args)...);
    return get_this_type();
}

References tim::invoke::stop().

◆ stop() [4/6]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::stop	(	mpl::piecewise_ignore< Tp... >	,
		Args &&	...
	)

selection stop

◆ stop() [5/6]

template<typename... Types>

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

lightweight_tuple< Types... > & tim::lightweight_tuple< Types >::stop	(	mpl::piecewise_select< Tp... >	,
		Args &&...	args
	)

Definition at line 314 of file lightweight_tuple.cpp.

{
    auto&& _data = mpl::get_reference_tuple<mpl::available_t<std::tuple<Tp...>>>(m_data);
    invoke::stop(_data, std::forward<Args>(args)...);
    return get_this_type();
}

References tim::mpl::get_reference_tuple(), and tim::invoke::stop().

◆ stop() [6/6]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::stop	(	mpl::piecewise_select< Tp... >	,
		Args &&	...
	)

selective stop

◆ store() [1/3]

template<typename... Types>

bool & tim::lightweight_tuple< Types >::store ( )

inline

Definition at line 642 of file lightweight_tuple.hpp.

642{ return bundle_type::store(); }

tim::invoke::store

void store(TupleT< Tp... > &obj, Args &&... args)

Definition: functional.cpp:564

References tim::invoke::store().

◆ store() [2/3]

template<typename... Types>

const bool & tim::lightweight_tuple< Types >::store ( ) const

inline

Definition at line 643 of file lightweight_tuple.hpp.

643{ return bundle_type::store(); }

References tim::invoke::store().

◆ store() [3/3]

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::store ( Args &&... _args )

inline

store a value

Definition at line 325 of file lightweight_tuple.hpp.

    {
        invoke::store(m_data, std::forward<Args>(_args)...);
        return get_this_type();
    }

References tim::_args, tim::lightweight_tuple< Types >::m_data, and tim::invoke::store().

◆ type_apply() [1/2]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::type_apply	(	Func &&	,
		Args &&	...
	)

inline

Definition at line 485 of file lightweight_tuple.hpp.

    {
        return get_this_type();
    }

◆ type_apply() [2/2]

template<typename... Types>

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

this_type & tim::lightweight_tuple< Types >::type_apply	(	Func &&	_func,
		Args &&...	_args
	)

inline

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

Definition at line 476 of file lightweight_tuple.hpp.

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

References tim::_args.

◆ update_statistics()

template<typename... Types>

template<typename... Args>

this_type & tim::lightweight_tuple< Types >::update_statistics ( Args &&... _args )

inline

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

Definition at line 352 of file lightweight_tuple.hpp.

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

References tim::_args.

Friends And Related Function Documentation

◆ impl::base_bundle

template<typename... Types>

template<typename... Tp>

friend class impl::base_bundle

friend

Definition at line 77 of file lightweight_tuple.hpp.

◆ operator*

template<typename... Types>

template<typename Op >

this_type operator*	(	const this_type &	lhs,
		Op &&	rhs
	)

friend

Definition at line 549 of file lightweight_tuple.hpp.

    {
        this_type tmp(lhs);
        return tmp *= std::forward<Op>(rhs);
    }

◆ operator+

template<typename... Types>

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

friend

Definition at line 536 of file lightweight_tuple.hpp.

    {
        this_type tmp(lhs);
        return tmp += rhs;
    }

◆ operator-

template<typename... Types>

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

friend

Definition at line 542 of file lightweight_tuple.hpp.

    {
        this_type tmp(lhs);
        return tmp -= rhs;
    }

◆ operator/

template<typename... Types>

template<typename Op >

this_type operator/	(	const this_type &	lhs,
		Op &&	rhs
	)

friend

Definition at line 556 of file lightweight_tuple.hpp.

    {
        this_type tmp(lhs);
        return tmp /= std::forward<Op>(rhs);
    }

◆ operator<<

template<typename... Types>

std::ostream & operator<<	(	std::ostream &	os,
		const this_type &	obj
	)

friend

Definition at line 603 of file lightweight_tuple.hpp.

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

Member Data Documentation

◆ has_gotcha_v

template<typename... Types>

constexpr bool tim::lightweight_tuple< Types >::has_gotcha_v = bundle_type::has_gotcha_v

staticconstexpr

Definition at line 107 of file lightweight_tuple.hpp.

◆ has_user_bundle_v

template<typename... Types>

constexpr bool tim::lightweight_tuple< Types >::has_user_bundle_v = bundle_type::has_user_bundle_v

staticconstexpr

Definition at line 108 of file lightweight_tuple.hpp.

◆ m_data

template<typename... Types>

data_type tim::lightweight_tuple< Types >::m_data = data_type{}

mutableprotected

Definition at line 668 of file lightweight_tuple.hpp.

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

timemory/mpl/concepts.hpp
timemory/variadic/lightweight_tuple.hpp
timemory/variadic/lightweight_tuple.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ apply_v

◆ auto_type

◆ bundle_type

◆ captured_location_t

◆ component_type

◆ custom_operation_t

◆ data_type

◆ impl_type

◆ initializer_type

◆ operation_t

◆ quirk_config

◆ reference_type

◆ sample_type

◆ size_type

◆ string_t

◆ this_type

◆ transient_func_t

◆ tuple_type

◆ type

◆ type_list_type

◆ user_bundle_types

Constructor & Destructor Documentation

◆ lightweight_tuple() [1/9]

◆ lightweight_tuple() [2/9]

◆ lightweight_tuple() [3/9]

◆ lightweight_tuple() [4/9]

◆ lightweight_tuple() [5/9]

◆ lightweight_tuple() [6/9]

◆ lightweight_tuple() [7/9]

◆ ~lightweight_tuple()

◆ lightweight_tuple() [8/9]

◆ lightweight_tuple() [9/9]

Member Function Documentation

◆ add_secondary()

◆ assemble() [1/2]

◆ assemble() [2/2]

◆ audit()

◆ clone()

◆ construct()

◆ data() [1/2]

◆ data() [2/2]

◆ derive() [1/2]

◆ derive() [2/2]

◆ execute()

◆ get() [1/8]

◆ get() [2/8]

◆ get() [3/8]

◆ get() [4/8]

◆ get() [5/8]

◆ get() [6/8]

◆ get() [7/8]

◆ get() [8/8]

◆ get_component()

◆ get_data() [1/2]

◆ get_data() [2/2]

◆ get_initializer()

◆ get_labeled() [1/2]

◆ get_labeled() [2/2]

◆ get_prefix()

◆ hash()

◆ init() [1/2]

◆ init() [2/2]

◆ init_storage()

◆ initialize()

◆ invoke() [1/3]

◆ invoke() [2/3]

◆ invoke() [3/3]

◆ key()

◆ laps()

◆ mark_begin()