Classes
struct	api

struct	auto_type
	This concept is used to express how to convert a component bundler into another component bundler which performs automatic starting upon construction. More...

struct	auto_wrapper

struct	comp_wrapper

struct	component

struct	component_type
	This concept is used to express how to convert a component bundler which automatically starts upon construction into a type that requires an explicit call to start. More...

struct	component_type< auto_bundle< Types... > >

struct	component_type< auto_hybrid< Types... > >

struct	component_type< auto_list< Types... > >

struct	component_type< auto_tuple< Types... > >

struct	empty

struct	external_function_wrapper

struct	has_gotcha
	determines if a variadic wrapper contains a gotcha component More...

struct	has_user_bundle
	concept that specifies that a type is a user_bundle type More...

struct	heap_wrapper

struct	is_acceptable_conversion
	This concept designates that is safe to perform a `static_cast<Lhs>(rhs)` where needed. This is primarily used in the tim::component::data_tracker where `data_tracker<unsigned int, ...>` might be provided another integral type, such as `int`. More...

struct	is_api
	concept that specifies that a type is an API. APIs are used to designate different project implementations, different external library tools, etc. More...

struct	is_archive
	concept that specifies that a type is a serialization archive (input or output) More...

struct	is_auto_wrapper
	concept that specifies that a type is a timemory variadic wrapper that performs auto start/stop, e.g. auto_{tuple,list,hybrid} More...

struct	is_comp_wrapper
	concept that specifies that a type is a timemory variadic wrapper that does not perform auto start/stop, e.g. component_{tuple,list,hybrid} More...

struct	is_component
	concept that specifies that a type is a component. Components are used to perform some measurement, capability, or logging implementation. Adding this concept can be performs through inheriting from tim::component::base, inheriting from tim::concepts::component, or specializing either tim::concepts::is_component or tim::trait::is_component (with the latter being deprecated). More...

struct	is_empty
	concept that specifies that a variadic type is empty More...

struct	is_empty< Tuple<> >

struct	is_external_function_wrapper
	concept that specifies that a component type wraps external functions More...

struct	is_heap_wrapper
	concept that specifies that a type is a timemory variadic wrapper and components are heap-allocated More...

struct	is_input_archive
	concept that specifies that a type is an input serialization archive More...

struct	is_mixed_wrapper
	concept that specifies that a type is a timemory variadic wrapper and variadic types are mix of stack- and heap- allocated More...

struct	is_null_type
	concept that specifies that a type is not a useful type More...

struct	is_null_type< statistics< Tuple<> > >

struct	is_null_type< statistics< void > >

struct	is_null_type< statistics<::tim::null_type > >

struct	is_null_type< Tuple<> >

struct	is_null_type< void >

struct	is_null_type<::tim::null_type >

struct	is_output_archive
	concept that specifies that a type is an output serialization archive More...

struct	is_phase_id
	concept that specifies that a type is used for identifying a phase in some measurement. For example, `tim::audit::incoming` and `tim::audit::outgoing` can be added to overloads to distinguish whether the `double` type in `double exp(double val)` is `val` or whether it is the return value. More...

struct	is_placeholder
	concept that specifies that a type is not necessarily marked as not available but is still a dummy type More...

struct	is_placeholder< component::nothing >

struct	is_placeholder< component::placeholder< component::nothing > >

struct	is_placeholder< component::placeholder< Types... > >

struct	is_quirk_type
	concept that specifies that a type is a quirk. Quirks are used to modify the traditional behavior of component bundles slightly. E.g. disable calling start in the constructor of an auto_tuple. More...

struct	is_runtime_configurable
	concept that specifies that a type is used to modify behavior at runtime. For example, the tim::component::user_bundle component is runtime configurable bc it allows you insert components at runtime. The timing category (`tim::category::timing`) is another example of a type that is runtime configurable – setting `tim::trait::runtime_enabled<tim::category::timing>::set(false);` will disable (at runtime) all the types which are part of the timing API. It should be noted that types which satisfy `is_runtime_configurable<Tp>::value == true` (e.g. tim::component::user_bundle) are not eligible to be inserted into other runtime configurable components; i.e. you cannot insert/add tim::component::user_trace_bundle into tim::component::user_global_bundle, etc. This restriction is primarily due to the significant increase in compile-time that arises from allowing this behavior. More...

struct	is_stack_wrapper
	concept that specifies that a type is a timemory variadic wrapper and components are stack-allocated More...

struct	is_string_type
	concept that specifies that a component type wraps external functions More...

struct	is_string_type< char * >

struct	is_string_type< const char * >

struct	is_tagged
	concept that specifies that a type's template parameters include a API specific tag as one of the template parameters (usually first) More...

struct	is_variadic
	concept that specifies that a type is a generic variadic wrapper More...

struct	is_wrapper
	concept that specifies that a type is a timemory variadic wrapper More...

struct	mixed_wrapper

struct	null_type

struct	phase_id

struct	placeholder

struct	quirk_type

struct	runtime_configurable

struct	stack_wrapper

struct	string_type

struct	tagged

struct	tuple_type
	This concept is used to express how to convert a given type into a `std::tuple`, e.g. `tim::component_tuple<T...>` to `std::tuple<T...>`. It is necessary for types like tim::component_bundle where certain template parameters are tags. More...

struct	tuple_type< auto_bundle< T, Types... > >

struct	tuple_type< component_bundle< T, Types... > >

struct	variadic

struct	wrapper

Typedefs
using	input_archive_base = cereal::detail::InputArchiveBase

using	output_archive_base = cereal::detail::OutputArchiveBase

template<typename T >
using	is_empty_t = typename is_empty< T >::type

template<typename T >
using	is_variadic_t = typename is_variadic< T >::type

template<typename T >
using	is_wrapper_t = typename is_wrapper< T >::type

template<typename T >
using	is_stack_wrapper_t = typename is_stack_wrapper< T >::type

template<typename T >
using	is_heap_wrapper_t = typename is_heap_wrapper< T >::type

template<typename T >
using	tuple_type_t = typename tuple_type< T >::type

template<typename T >
using	auto_type_t = typename auto_type< T >::type

template<typename T >
using	component_type_t = typename component_type< T >::type

Class Documentation

◆ tim::concepts::api

struct tim::concepts::api

Definition at line 273 of file concepts.hpp.

Collaboration diagram for tim::concepts::api:

◆ tim::concepts::auto_type

struct tim::concepts::auto_type

template<typename T>
struct tim::concepts::auto_type< T >

This concept is used to express how to convert a component bundler into another component bundler which performs automatic starting upon construction.

Definition at line 513 of file concepts.hpp.

Collaboration diagram for tim::concepts::auto_type< T >:

Class Members
typedef typename auto_type	type

◆ tim::concepts::component_type

struct tim::concepts::component_type

template<typename T>
struct tim::concepts::component_type< T >

This concept is used to express how to convert a component bundler which automatically starts upon construction into a type that requires an explicit call to start.

Definition at line 524 of file concepts.hpp.

Collaboration diagram for tim::concepts::component_type< T >:

Class Members
typedef typename component_type	type

◆ tim::concepts::component_type< auto_bundle< Types... > >

struct tim::concepts::component_type< auto_bundle< Types... > >

template<typename... Types>
struct tim::concepts::component_type< auto_bundle< Types... > >

Definition at line 120 of file types.hpp.

Collaboration diagram for tim::concepts::component_type< auto_bundle< Types... > >:

Class Members
typedef component_bundle< Types... >	type

◆ tim::concepts::component_type< auto_hybrid< Types... > >

struct tim::concepts::component_type< auto_hybrid< Types... > >

template<typename... Types>
struct tim::concepts::component_type< auto_hybrid< Types... > >

Definition at line 126 of file types.hpp.

Collaboration diagram for tim::concepts::component_type< auto_hybrid< Types... > >:

Class Members
typedef component_hybrid< Types... >	type

◆ tim::concepts::component_type< auto_list< Types... > >

struct tim::concepts::component_type< auto_list< Types... > >

template<typename... Types>
struct tim::concepts::component_type< auto_list< Types... > >

Definition at line 114 of file types.hpp.

Collaboration diagram for tim::concepts::component_type< auto_list< Types... > >:

Class Members
typedef component_list< Types... >	type

◆ tim::concepts::component_type< auto_tuple< Types... > >

struct tim::concepts::component_type< auto_tuple< Types... > >

template<typename... Types>
struct tim::concepts::component_type< auto_tuple< Types... > >

Definition at line 108 of file types.hpp.

Collaboration diagram for tim::concepts::component_type< auto_tuple< Types... > >:

Class Members
typedef component_tuple< Types... >	type

◆ tim::concepts::empty

struct tim::concepts::empty

Definition at line 149 of file concepts.hpp.

Collaboration diagram for tim::concepts::empty:

◆ tim::concepts::placeholder

struct tim::concepts::placeholder

Definition at line 198 of file concepts.hpp.

Collaboration diagram for tim::concepts::placeholder:

◆ tim::concepts::string_type

struct tim::concepts::string_type

Definition at line 379 of file concepts.hpp.

Collaboration diagram for tim::concepts::string_type:

◆ tim::concepts::tuple_type

struct tim::concepts::tuple_type

template<typename T>
struct tim::concepts::tuple_type< T >

This concept is used to express how to convert a given type into a std::tuple, e.g. tim::component_tuple<T...> to std::tuple<T...>. It is necessary for types like tim::component_bundle where certain template parameters are tags.

Definition at line 503 of file concepts.hpp.

Collaboration diagram for tim::concepts::tuple_type< T >:

Class Members
typedef typename tuple_type	type

◆ tim::concepts::tuple_type< auto_bundle< T, Types... > >

struct tim::concepts::tuple_type< auto_bundle< T, Types... > >

template<typename T, typename... Types>
struct tim::concepts::tuple_type< auto_bundle< T, Types... > >

Definition at line 250 of file types.hpp.

Collaboration diagram for tim::concepts::tuple_type< auto_bundle< T, Types... > >:

Class Members
typedef tuple< Types... >	type

◆ tim::concepts::tuple_type< component_bundle< T, Types... > >

struct tim::concepts::tuple_type< component_bundle< T, Types... > >

template<typename T, typename... Types>
struct tim::concepts::tuple_type< component_bundle< T, Types... > >

Definition at line 242 of file types.hpp.

Collaboration diagram for tim::concepts::tuple_type< component_bundle< T, Types... > >:

Class Members
typedef tuple< Types... >	type

Typedef Documentation

◆ auto_type_t

template<typename T >

using tim::concepts::auto_type_t = typedef typename auto_type <T>::type

Definition at line 581 of file concepts.hpp.

◆ component_type_t

template<typename T >

using tim::concepts::component_type_t = typedef typename component_type <T>::type

Definition at line 582 of file concepts.hpp.

◆ input_archive_base

using tim::concepts::input_archive_base = typedef cereal::detail::InputArchiveBase

Definition at line 142 of file concepts.hpp.

◆ is_empty_t

template<typename T >

using tim::concepts::is_empty_t = typedef typename is_empty <T>::type

Definition at line 574 of file concepts.hpp.

◆ is_heap_wrapper_t

template<typename T >

using tim::concepts::is_heap_wrapper_t = typedef typename is_heap_wrapper <T>::type

Definition at line 578 of file concepts.hpp.

◆ is_stack_wrapper_t

template<typename T >

using tim::concepts::is_stack_wrapper_t = typedef typename is_stack_wrapper <T>::type

Definition at line 577 of file concepts.hpp.

◆ is_variadic_t

template<typename T >

using tim::concepts::is_variadic_t = typedef typename is_variadic <T>::type

Definition at line 575 of file concepts.hpp.

◆ is_wrapper_t

template<typename T >

using tim::concepts::is_wrapper_t = typedef typename is_wrapper <T>::type

Definition at line 576 of file concepts.hpp.

◆ output_archive_base

using tim::concepts::output_archive_base = typedef cereal::detail::OutputArchiveBase

Definition at line 143 of file concepts.hpp.

◆ tuple_type_t

template<typename T >

using tim::concepts::tuple_type_t = typedef typename tuple_type <T>::type

Definition at line 580 of file concepts.hpp.

Classes

Typedefs

Class Documentation

◆ tim::concepts::api

◆ tim::concepts::auto_type

◆ tim::concepts::component_type

◆ tim::concepts::component_type< auto_bundle< Types... > >

◆ tim::concepts::component_type< auto_hybrid< Types... > >

◆ tim::concepts::component_type< auto_list< Types... > >

◆ tim::concepts::component_type< auto_tuple< Types... > >

◆ tim::concepts::empty

◆ tim::concepts::placeholder

◆ tim::concepts::string_type

◆ tim::concepts::tuple_type

◆ tim::concepts::tuple_type< auto_bundle< T, Types... > >

◆ tim::concepts::tuple_type< component_bundle< T, Types... > >

Typedef Documentation

◆ auto_type_t

◆ component_type_t

◆ input_archive_base

◆ is_empty_t

◆ is_heap_wrapper_t

◆ is_stack_wrapper_t

◆ is_variadic_t

◆ is_wrapper_t

◆ output_archive_base

◆ tuple_type_t