tim::lightweight_tuple< Types > Class Template Reference

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 &&) noexcept=default
lightweight_tuple &	operator= (const lightweight_tuple &rhs)=default
lightweight_tuple &	operator= (lightweight_tuple &&) noexcept=default
lightweight_tuple	clone (bool store, scope::config _scope=scope::get_default())
this_type &	push ()
this_type &	pop ()
template<typename... Args>
this_type &	measure (Args &&...)
template<typename... Args>
this_type &	sample (Args &&...)
template<typename... Args>
this_type &	start (Args &&...)
template<typename... Args>
this_type &	stop (Args &&...)
template<typename... Args>
this_type &	record (Args &&...)
template<typename... Args>
this_type &	reset (Args &&...)
template<typename... Args>
auto	get (Args &&...) const
template<typename... Args>
auto	get_labeled (Args &&...) const
data_type &	data ()
const data_type &	data () const
this_type &	set_scope (scope::config)
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<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<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 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)
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... Args>
lightweight_tuple< Types... > &	stop (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
data_type &	get_data ()
const data_type &	get_data () const
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 44 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 57 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 70 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 81 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 92 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 102 of file lightweight_tuple.cpp.

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

~lightweight_tuple()

template<typename... Types>

tim::lightweight_tuple< Types >::~lightweight_tuple

Definition at line 111 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 > &&  )

defaultnoexcept

Member Function Documentation

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

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

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

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

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

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

References 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 124 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 212 of file lightweight_tuple.hpp.

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

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

data() [1/2]

template<typename... Types>

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

Definition at line 315 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

Definition at line 324 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 239 of file lightweight_tuple.hpp.

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

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

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

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

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

References tim::mpl::execute().

get() [1/6]

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 319 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/6]

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 325 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/6]

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 331 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/6]

template<typename... Types>

template<typename... Args>

auto tim::lightweight_tuple< Types >::get

(

Args &&...

args

)

const

Definition at line 250 of file lightweight_tuple.cpp.

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

References tim::invoke::get().

get() [5/6]

template<typename... Types>

template<typename... Args>

auto tim::lightweight_tuple< Types >::get

(

Args &&

...

)

const

get() [6/6]

template<typename... Types>

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

inline

Definition at line 338 of file lightweight_tuple.hpp.

    {
        using get_t = operation_t<operation::get>;
        apply_v::access<get_t>(m_data, ptr, _hash);
        return const_cast<this_type&>(*this);
    }

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

    {
        return get<T>();
    }

get_data() [1/2]

template<typename... Types>

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

protected

get_data() [2/2]

template<typename... Types>

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

protected

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 261 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

get_prefix()

template<typename... Types>

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

inline

Definition at line 562 of file lightweight_tuple.hpp.

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

{ 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 362 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 376 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 364 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 385 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/2]

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

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

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

invoke() [2/2]

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

    {
        TIMEMORY_FOLD_EXPRESSION(operation::generic_operator<Tp, OpT<Tp>, TIMEMORY_API>(
            this->get<Tp>(), std::forward<Args>(_args)...));
        return *this;
    }

References TIMEMORY_API, and TIMEMORY_FOLD_EXPRESSION.

key()

template<typename... Types>

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

inline

Definition at line 557 of file lightweight_tuple.hpp.

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

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

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

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

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

References 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 174 of file lightweight_tuple.cpp.

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

References tim::invoke::measure().

measure() [2/2]

template<typename... Types>

template<typename... Args>

this_type& tim::lightweight_tuple< Types >::measure

(

Args &&

...

)

operator*=()

template<typename... Types>

template<typename Op >

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

inline

Definition at line 439 of file lightweight_tuple.hpp.

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

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 293 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 *this;
}

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

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

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 304 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 *this;
}

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 271 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 *this;
}

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

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

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 282 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 *this;
}

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

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

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 > &&  )

defaultnoexcept

pop()

template<typename... Types>

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

Definition at line 156 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 *this;
}

References tim::invoke::pop().

prefix()

template<typename... Types>

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

inline

Definition at line 561 of file lightweight_tuple.hpp.

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

    {
        using printer_t = typename bundle_type::print_type;
        if(size() == 0)
            return const_cast<this_type&>(*this);
        if(m_hash == 0 && skip_wo_hash)
            return const_cast<this_type&>(*this);
        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();
            }
        }
        if(ss_data.str().length() > 0)
        {
            os << ss_data.str();
            if(m_laps > 0 && PrintLaps)
                os << " [laps: " << m_laps << "]";
        }
        return const_cast<this_type&>(*this);
    }

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

push()

template<typename... Types>

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

Definition at line 137 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 *this;
}

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

record() [1/2]

template<typename... Types>

template<typename... Args>

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

(

Args &&...

args

)

Definition at line 224 of file lightweight_tuple.cpp.

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

References tim::invoke::record().

record() [2/2]

template<typename... Types>

template<typename... Args>

this_type& tim::lightweight_tuple< Types >::record

(

Args &&

...

)

rekey() [1/3]

template<typename... Types>

void tim::lightweight_tuple< Types >::rekey

(

const captured_location_t &

_loc

)

Definition at line 602 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 592 of file lightweight_tuple.hpp.

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

References tim::add_hash_id(), and tim::invoke::set_prefix().

rekey() [3/3]

template<typename... Types>

void tim::lightweight_tuple< Types >::rekey

(

uint64_t

_hash

)

Definition at line 612 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 237 of file lightweight_tuple.cpp.

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

References tim::invoke::reset().

reset() [2/2]

template<typename... Types>

template<typename... Args>

this_type& tim::lightweight_tuple< Types >::reset

(

Args &&

...

)

sample() [1/2]

template<typename... Types>

template<typename... Args>

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

(

Args &&...

args

)

Definition at line 186 of file lightweight_tuple.cpp.

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

sample() [2/2]

template<typename... Types>

template<typename... Args>

this_type& tim::lightweight_tuple< Types >::sample

(

Args &&

...

)

serialize()

template<typename... Types>

template<typename Archive >

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

inline

Definition at line 529 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::add_hash_id(), tim::get_hash_ids(), 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 333 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 342 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::get_hash_ids(), and tim::invoke::set_prefix().

set_scope()

template<typename... Types>

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

(

scope::config

val

)

Definition at line 353 of file lightweight_tuple.cpp.

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

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.

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

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

start() [1/2]

template<typename... Types>

template<typename... Args>

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

(

Args &&...

args

)

Definition at line 198 of file lightweight_tuple.cpp.

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

References tim::invoke::start().

start() [2/2]

template<typename... Types>

template<typename... Args>

this_type& tim::lightweight_tuple< Types >::start

(

Args &&

...

)

stop() [1/2]

template<typename... Types>

template<typename... Args>

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

(

Args &&...

args

)

Definition at line 210 of file lightweight_tuple.cpp.

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

References tim::invoke::stop().

stop() [2/2]

template<typename... Types>

template<typename... Args>

this_type& tim::lightweight_tuple< Types >::stop

(

Args &&

...

)

store() [1/3]

template<typename... Types>

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

inline

Definition at line 559 of file lightweight_tuple.hpp.

{ return bundle_type::store(); }

References tim::invoke::store().

store() [2/3]

template<typename... Types>

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

inline

Definition at line 560 of file lightweight_tuple.hpp.

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

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

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

    {
        return *this;
    }

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

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

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 470 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 457 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 463 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 477 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 520 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 584 of file lightweight_tuple.hpp.

Referenced by tim::lightweight_tuple< Types >::lightweight_tuple(), tim::lightweight_tuple< Types >::assemble(), tim::lightweight_tuple< Types >::audit(), tim::lightweight_tuple< Types >::construct(), tim::lightweight_tuple< Types >::derive(), tim::lightweight_tuple< Types >::get(), tim::lightweight_tuple< Types >::invoke(), tim::lightweight_tuple< Types >::mark_begin(), tim::lightweight_tuple< Types >::mark_end(), tim::lightweight_tuple< Types >::operator*=(), tim::lightweight_tuple< Types >::operator+=(), tim::lightweight_tuple< Types >::operator-=(), tim::lightweight_tuple< Types >::operator/=(), tim::lightweight_tuple< Types >::print(), tim::lightweight_tuple< Types >::serialize(), and tim::lightweight_tuple< Types >::store().

---

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