Classes
struct	apply

struct	apply< void >

struct	dynamic_buffer_size

class	execution_handler
	This is an intermediate type that permits operations such as: More...

class	execution_handler< BundleT, void >

struct	function_traits

struct	function_traits< R(*)(Args...)>

struct	function_traits< R(Args...)>

struct	function_traits< R(C::*)(Args...) const >

struct	function_traits< R(C::*)(Args...)>

struct	function_traits< R(C::*)>

struct	get_false_types
	generic alias for extracting all types with a specified trait disabled More...

struct	get_false_types< Predicate, type_list< Sequence... > >

struct	get_true_types
	generic alias for extracting all types with a specified trait enabled More...

struct	get_true_types< Predicate, type_list< Sequence... > >

struct	get_tuple_size

struct	is_invocable

struct	is_invocable_r

struct	lightweight
	a generic type for indicating that function call or constructor should be as lightweight as possible. More...

struct	piecewise_ignore

struct	piecewise_select

struct	push_back

struct	push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

struct	push_back< Tuple< Types... >, T >

struct	union_index_of

struct	union_index_of< T *, TupleT< Types... > >

struct	union_index_of< T, TupleT< Types... > >

struct	union_index_sequence

struct	union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

Typedefs
template<template< typename > class Predicate, typename Sequence >
using	filter_true_t = impl::filter_true< Predicate, Sequence >

template<template< typename > class Predicate, typename Sequence >
using	filter_false_t = impl::filter_false< Predicate, Sequence >

template<template< typename > class Predicate, typename... Sequence>
using	get_true_types_t = typename get_true_types< Predicate, Sequence... >::type

template<template< typename > class Predicate, typename... Sequence>
using	get_false_types_t = typename get_false_types< Predicate, Sequence... >::type

template<typename T >
using	non_quirk_t = impl::filter_true< concepts::is_quirk_type, T >

template<typename T >
using	non_placeholder_t = impl::filter_true< concepts::is_placeholder, T >

template<typename... Types>
using	implemented_t = impl::filter_false_after_decay_t< trait::is_available, type_list< Types... > >
	filter out any types that are not available More...

template<typename T >
using	implemented_list_t = impl::filter_false_after_decay_t< trait::is_available, T >

template<typename T >
using	available_t = impl::filter_false< trait::is_available, T >

template<typename Tp , typename... Types>
using	append_type = impl::append_type< Tp, Types... >
	append type to a tuple/bundler More...

template<typename Tp , typename... Types>
using	remove_type = impl::remove_type< Tp, Types... >
	remove any instances of a type from a tuple/bundler More...

template<typename Tp , typename Types >
using	append_type_t = typename impl::append_type< Tp, Types >::type
	append type to a tuple/bundler More...

template<typename Tp , typename Types >
using	remove_type_t = typename impl::remove_type< Tp, Types >::type
	remove any instances of a type from a tuple/bundler More...

template<typename Types >
using	is_one_of_integral = typename impl::is_one_of_integral< Types >
	check if type is in expansion More...

template<typename T >
using	remove_duplicates_t = typename impl::unique< T, type_list<> >::type

template<typename T , typename TupleT = type_list<>>
using	unique_t = convert_t< typename impl::unique< T, type_list<> >::type, TupleT >

template<typename LhsT , typename RhsT >
using	subtract_t = typename impl::subtract< LhsT, RhsT >::type

template<typename... Types>
using	filter_gotchas = get_false_types_t< trait::is_gotcha, std::tuple< Types... > >
	filter out any types that are not available More...

template<typename T >
using	filter_gotchas_t = get_false_types_t< trait::is_gotcha, T >

template<typename T >
using	filter_empty_t = get_true_types_t< concepts::is_empty, T >

template<typename TypeList >
using	get_data_type_t = typename impl::template get_data_tuple< TypeList >::type
	get the tuple of types More...

template<typename TypeList >
using	get_data_value_t = typename impl::template get_data_tuple< TypeList >::value_type
	get the tuple of values More...

template<typename TypeList >
using	get_data_label_t = typename impl::template get_data_tuple< TypeList >::label_type
	get the tuple of pair of descriptor and value More...

template<template< typename > class TraitT, typename TypeList >
using	get_trait_type_t = impl::get_trait_type_t< TraitT, convert_t< TypeList, type_list<> > >
	get the tuple of types More...

template<template< typename > class PrioT, typename Tuple , typename BegT = type_list<>, typename EndT = type_list<>>
using	sort = convert_t< typename ::tim::mpl::impl::sortT< PrioT, convert_t< Tuple, type_list<> >, convert_t< BegT, type_list<> >, convert_t< EndT, type_list<> > >::type, std::tuple<> >

template<typename... Types>
using	runtime_configurable_t = typename get_true_types< concepts::is_runtime_configurable, Types... >::type

template<typename... Types>
using	external_function_wrappers_t = typename get_true_types< concepts::is_external_function_wrapper, Types... >::type

template<typename Tp >
using	negative_start_priority = impl::negative_start_priority< Tp >

template<typename Tp >
using	positive_start_priority = impl::positive_start_priority< Tp >

template<typename Tp >
using	negative_stop_priority = impl::negative_stop_priority< Tp >

template<typename Tp >
using	positive_stop_priority = impl::positive_stop_priority< Tp >

template<typename... T>
using	union_index_sequence_t = typename union_index_sequence< T... >::type

Functions
template<typename Tp , typename std::enable_if<(std::is_arithmetic< Tp >::value), int >::type = 0>
constexpr auto	get_size (const Tp &, std::tuple<>) -> size_t

template<typename Tp >
auto	get_size (const Tp &_val, std::tuple<>) -> decltype(_val.size(), size_t())

template<typename Tp , typename std::enable_if<(std::is_arithmetic< Tp >::value), int >::type = 0>
constexpr auto	get_size (const Tp &, type_list<>) -> size_t

template<typename Tp >
auto	get_size (const Tp &_val, type_list<>) -> decltype(_val.size(), size_t())

template<typename Tp , size_t... Idx>
constexpr auto	get_size (const Tp &_val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_val), size_t())

template<typename Tp >
auto	get_size (const Tp &_val) -> decltype(get_size(_val, get_index_sequence< decay_t< Tp > >::value))

template<typename T >
auto	resize (T &,...) -> void

template<typename T >
auto	resize (T &_targ, size_t _n) -> decltype(_targ.resize(_n), void())

template<typename Tp >
void	assign (Tp &_targ, const Tp &_val,...)

template<typename Tp , typename Vp , typename ValueType = typename Tp::value_type>
auto	assign (Tp &_targ, const Vp &_val, type_list<>) -> decltype(_targ[0], void())

template<typename Tp , size_t... Idx>
auto	assign (Tp &_targ, const Tp &_val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_val), void())

template<typename Tp , typename Vp , size_t... Idx, enable_if_t<!std::is_same< Tp, Vp >::value, int > = 0>
auto	assign (Tp &_targ, const Vp &_val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_targ)= *std::begin(_val), void())

template<typename Tp , typename Vp >
void	assign (Tp &_targ, const Vp &_val)

template<typename Rp , typename Tp >
decltype(auto)	get_reference_tuple (Tp &&_tuple)

template<typename BundleT , typename FuncT , typename... Args>
auto	execute (BundleT &&_bundle, FuncT &&_func, Args &&... _args, enable_if_t< is_invocable< FuncT, Args... >::value &&!std::is_void< std::result_of_t< FuncT(Args...)> >::value, int >)

template<typename BundleT , typename FuncT , typename... Args>
auto	execute (BundleT &&_bundle, FuncT &&_func, Args &&... _args, enable_if_t< is_invocable< FuncT, Args... >::value &&std::is_void< std::result_of_t< FuncT(Args...)> >::value, int >)

template<typename BundleT , typename ValueT >
auto	execute (BundleT &&_bundle, ValueT &&_value, enable_if_t<!is_invocable< ValueT >::value, long >)

Class Documentation

◆ tim::mpl::function_traits

struct tim::mpl::function_traits

template<typename T>
struct tim::mpl::function_traits< T >

Definition at line 51 of file function_traits.hpp.

Collaboration diagram for tim::mpl::function_traits< T >:

◆ tim::mpl::get_false_types

struct tim::mpl::get_false_types

template<template< typename > class Predicate, typename... Sequence>
struct tim::mpl::get_false_types< Predicate, Sequence >

generic alias for extracting all types with a specified trait disabled

Definition at line 282 of file available.hpp.

Collaboration diagram for tim::mpl::get_false_types< Predicate, Sequence >:

Class Members
typedef filter_true< Predicate, tuple< Sequence... > >	type

◆ tim::mpl::get_false_types< Predicate, type_list< Sequence... > >

struct tim::mpl::get_false_types< Predicate, type_list< Sequence... > >

template<template< typename > class Predicate, typename... Sequence>
struct tim::mpl::get_false_types< Predicate, type_list< Sequence... > >

Definition at line 294 of file available.hpp.

Collaboration diagram for tim::mpl::get_false_types< Predicate, type_list< Sequence... > >:

Class Members
typedef convert_t< filter_true< Predicate, tuple< Sequence... > >, type_list<> >	type

◆ tim::mpl::get_true_types

struct tim::mpl::get_true_types

template<template< typename > class Predicate, typename... Sequence>
struct tim::mpl::get_true_types< Predicate, Sequence >

generic alias for extracting all types with a specified trait enabled

Definition at line 257 of file available.hpp.

Collaboration diagram for tim::mpl::get_true_types< Predicate, Sequence >:

Class Members
typedef filter_false< Predicate, tuple< Sequence... > >	type

◆ tim::mpl::get_true_types< Predicate, type_list< Sequence... > >

struct tim::mpl::get_true_types< Predicate, type_list< Sequence... > >

template<template< typename > class Predicate, typename... Sequence>
struct tim::mpl::get_true_types< Predicate, type_list< Sequence... > >

Definition at line 269 of file available.hpp.

Collaboration diagram for tim::mpl::get_true_types< Predicate, type_list< Sequence... > >:

Class Members
typedef convert_t< filter_false< Predicate, tuple< Sequence... > >, type_list<> >	type

◆ tim::mpl::lightweight

struct tim::mpl::lightweight

a generic type for indicating that function call or constructor should be as lightweight as possible.

Definition at line 327 of file types.hpp.

Collaboration diagram for tim::mpl::lightweight:

◆ tim::mpl::piecewise_ignore

struct tim::mpl::piecewise_ignore

template<typename... Tp>
struct tim::mpl::piecewise_ignore< Tp >

Definition at line 337 of file types.hpp.

Collaboration diagram for tim::mpl::piecewise_ignore< Tp >:

◆ tim::mpl::piecewise_select

struct tim::mpl::piecewise_select

template<typename... Tp>
struct tim::mpl::piecewise_select< Tp >

Definition at line 333 of file types.hpp.

Collaboration diagram for tim::mpl::piecewise_select< Tp >:

◆ tim::mpl::push_back

struct tim::mpl::push_back

template<typename Tuple, typename T>
struct tim::mpl::push_back< Tuple, T >

Definition at line 992 of file types.hpp.

Collaboration diagram for tim::mpl::push_back< Tuple, T >:

◆ tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

struct tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

template<template< typename, typename > class Hybrid, template< typename... > class Lhs, typename... LhsTypes, template< typename... > class Rhs, typename... RhsTypes, typename T>
struct tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

Definition at line 1003 of file types.hpp.

Collaboration diagram for tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >:

Class Members
typedef Hybrid< Lhs< LhsTypes..., T >, Rhs< RhsTypes... > >	type

◆ tim::mpl::push_back< Tuple< Types... >, T >

struct tim::mpl::push_back< Tuple< Types... >, T >

template<template< typename... > class Tuple, typename... Types, typename T>
struct tim::mpl::push_back< Tuple< Types... >, T >

Definition at line 995 of file types.hpp.

Collaboration diagram for tim::mpl::push_back< Tuple< Types... >, T >:

Class Members
typedef Tuple< Types..., T >	type

◆ tim::mpl::union_index_of

struct tim::mpl::union_index_of

template<typename... T>
struct tim::mpl::union_index_of< T >

Definition at line 1011 of file types.hpp.

Collaboration diagram for tim::mpl::union_index_of< T >:

◆ tim::mpl::union_index_sequence

struct tim::mpl::union_index_sequence

template<typename... T>
struct tim::mpl::union_index_sequence< T >

Definition at line 1050 of file types.hpp.

Collaboration diagram for tim::mpl::union_index_sequence< T >:

◆ tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

struct tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

template<template< typename... > class LhsT, typename... Lhs, template< typename... > class RhsT, typename... Rhs>
struct tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

Definition at line 1054 of file types.hpp.

Collaboration diagram for tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >:

Class Members
typedef index_sequence< union_index_of< decay_t< Lhs >, RhsT< decay_t< Rhs >... > >::value(0)... >	type

Typedef Documentation

◆ append_type

template<typename Tp , typename... Types>

using tim::mpl::append_type = typedef impl::append_type<Tp, Types...>

append type to a tuple/bundler

Definition at line 401 of file filters.hpp.

◆ append_type_t

template<typename Tp , typename Types >

using tim::mpl::append_type_t = typedef typename impl::append_type<Tp, Types>::type

append type to a tuple/bundler

Definition at line 409 of file filters.hpp.

◆ available_t

template<typename T >

using tim::mpl::available_t = typedef impl::filter_false<trait::is_available, T>

Definition at line 324 of file available.hpp.

◆ external_function_wrappers_t

template<typename... Types>

using tim::mpl::external_function_wrappers_t = typedef typename get_true_types<concepts::is_external_function_wrapper, Types...>::type

Definition at line 485 of file filters.hpp.

◆ filter_empty_t

template<typename T >

using tim::mpl::filter_empty_t = typedef get_true_types_t<concepts::is_empty, T>

Definition at line 442 of file filters.hpp.

◆ filter_false_t

template<template< typename > class Predicate, typename Sequence >

using tim::mpl::filter_false_t = typedef impl::filter_false<Predicate, Sequence>

Definition at line 251 of file available.hpp.

◆ filter_gotchas

template<typename... Types>

using tim::mpl::filter_gotchas = typedef get_false_types_t<trait::is_gotcha, std::tuple<Types...> >

filter out any types that are not available

Definition at line 436 of file filters.hpp.

◆ filter_gotchas_t

template<typename T >

using tim::mpl::filter_gotchas_t = typedef get_false_types_t<trait::is_gotcha, T>

Definition at line 439 of file filters.hpp.

◆ filter_true_t

template<template< typename > class Predicate, typename Sequence >

using tim::mpl::filter_true_t = typedef impl::filter_true<Predicate, Sequence>

Definition at line 248 of file available.hpp.

◆ get_data_label_t

template<typename TypeList >

using tim::mpl::get_data_label_t = typedef typename impl::template get_data_tuple<TypeList>::label_type

get the tuple of pair of descriptor and value

Definition at line 460 of file filters.hpp.

◆ get_data_type_t

template<typename TypeList >

using tim::mpl::get_data_type_t = typedef typename impl::template get_data_tuple<TypeList>::type

get the tuple of types

Definition at line 452 of file filters.hpp.

◆ get_data_value_t

template<typename TypeList >

using tim::mpl::get_data_value_t = typedef typename impl::template get_data_tuple<TypeList>::value_type

get the tuple of values

Definition at line 456 of file filters.hpp.

◆ get_false_types_t

template<template< typename > class Predicate, typename... Sequence>

using tim::mpl::get_false_types_t = typedef typename get_false_types<Predicate, Sequence...>::type

Definition at line 301 of file available.hpp.

◆ get_trait_type_t

template<template< typename > class TraitT, typename TypeList >

using tim::mpl::get_trait_type_t = typedef impl::get_trait_type_t<TraitT, convert_t<TypeList, type_list<> >>

get the tuple of types

Definition at line 464 of file filters.hpp.

◆ get_true_types_t

template<template< typename > class Predicate, typename... Sequence>

using tim::mpl::get_true_types_t = typedef typename get_true_types<Predicate, Sequence...>::type

Definition at line 276 of file available.hpp.

◆ implemented_list_t

template<typename T >

using tim::mpl::implemented_list_t = typedef impl::filter_false_after_decay_t<trait::is_available, T>

Definition at line 321 of file available.hpp.

◆ implemented_t

template<typename... Types>

using tim::mpl::implemented_t = typedef impl::filter_false_after_decay_t<trait::is_available, type_list<Types...> >

filter out any types that are not available

Definition at line 317 of file available.hpp.

◆ is_one_of_integral

template<typename Types >

using tim::mpl::is_one_of_integral = typedef typename impl::is_one_of_integral<Types>

check if type is in expansion

Definition at line 417 of file filters.hpp.

◆ negative_start_priority

template<typename Tp >

using tim::mpl::negative_start_priority = typedef impl::negative_start_priority<Tp>

Definition at line 489 of file filters.hpp.

◆ negative_stop_priority

template<typename Tp >

using tim::mpl::negative_stop_priority = typedef impl::negative_stop_priority<Tp>

Definition at line 495 of file filters.hpp.

◆ non_placeholder_t

template<typename T >

using tim::mpl::non_placeholder_t = typedef impl::filter_true<concepts::is_placeholder, T>

Definition at line 313 of file available.hpp.

◆ non_quirk_t

template<typename T >

using tim::mpl::non_quirk_t = typedef impl::filter_true<concepts::is_quirk_type, T>

Definition at line 310 of file available.hpp.

◆ positive_start_priority

template<typename Tp >

using tim::mpl::positive_start_priority = typedef impl::positive_start_priority<Tp>

Definition at line 492 of file filters.hpp.

◆ positive_stop_priority

template<typename Tp >

using tim::mpl::positive_stop_priority = typedef impl::positive_stop_priority<Tp>

Definition at line 498 of file filters.hpp.

◆ remove_duplicates_t

template<typename T >

using tim::mpl::remove_duplicates_t = typedef typename impl::unique<T, type_list<> >::type

Definition at line 420 of file filters.hpp.

◆ remove_type

template<typename Tp , typename... Types>

using tim::mpl::remove_type = typedef impl::remove_type<Tp, Types...>

remove any instances of a type from a tuple/bundler

Definition at line 405 of file filters.hpp.

◆ remove_type_t

template<typename Tp , typename Types >

using tim::mpl::remove_type_t = typedef typename impl::remove_type<Tp, Types>::type

remove any instances of a type from a tuple/bundler

Definition at line 413 of file filters.hpp.

◆ runtime_configurable_t

template<typename... Types>

using tim::mpl::runtime_configurable_t = typedef typename get_true_types<concepts::is_runtime_configurable, Types...>::type

Definition at line 481 of file filters.hpp.

◆ sort

template<template< typename > class PrioT, typename Tuple , typename BegT = type_list<>, typename EndT = type_list<>>

using tim::mpl::sort = typedef convert_t<typename ::tim::mpl::impl::sortT<PrioT, convert_t<Tuple, type_list<> >, convert_t<BegT, type_list<> >, convert_t<EndT, type_list<> >>::type, std::tuple<> >

Definition at line 474 of file filters.hpp.

◆ subtract_t

template<typename LhsT , typename RhsT >

using tim::mpl::subtract_t = typedef typename impl::subtract<LhsT, RhsT>::type

Definition at line 426 of file filters.hpp.

◆ union_index_sequence_t

template<typename... T>

using tim::mpl::union_index_sequence_t = typedef typename union_index_sequence<T...>::type

Definition at line 1061 of file types.hpp.

◆ unique_t

template<typename T , typename TupleT = type_list<>>

using tim::mpl::unique_t = typedef convert_t<typename impl::unique<T, type_list<> >::type, TupleT>

Definition at line 423 of file filters.hpp.

Function Documentation

◆ assign() [1/5]

template<typename Tp , size_t... Idx>

auto tim::mpl::assign	(	Tp &	_targ,
		const Tp &	_val,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_val), void())

Definition at line 963 of file types.hpp.

{
    TIMEMORY_FOLD_EXPRESSION(
        assign(std::get<Idx>(_targ), std::get<Idx>(_val),
               get_index_sequence<decay_t<decltype(std::get<Idx>(_targ))>>::value));
}

◆ assign() [2/5]

template<typename Tp >

void tim::mpl::assign	(	Tp &	_targ,
		const Tp &	_val,
			...
	)

Definition at line 943 of file types.hpp.

{
    _targ = _val;
}

◆ assign() [3/5]

template<typename Tp , typename Vp >

void tim::mpl::assign	(	Tp &	_targ,
		const Vp &	_val
	)

Definition at line 984 of file types.hpp.

{
    assign(_targ, _val, get_index_sequence<decay_t<Tp>>::value);
}

◆ assign() [4/5]

template<typename Tp , typename Vp , size_t... Idx, enable_if_t<!std::is_same< Tp, Vp >::value, int > = 0>

auto tim::mpl::assign	(	Tp &	_targ,
		const Vp &	_val,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_targ) = *std::begin(_val), void())

Definition at line 974 of file types.hpp.

{
    TIMEMORY_FOLD_EXPRESSION(
        assign(std::get<Idx>(_targ), *(std::begin(_val) + Idx),
               get_index_sequence<decay_t<decltype(std::get<Idx>(_targ))>>::value));
}

◆ assign() [5/5]

template<typename Tp , typename Vp , typename ValueType = typename Tp::value_type>

auto tim::mpl::assign	(	Tp &	_targ,
		const Vp &	_val,
		type_list<>
	)		-> decltype(_targ[0], void())

Definition at line 950 of file types.hpp.

{
    auto _n = get_size(_val);
    resize(_targ, _n);
    for(decltype(_n) i = 0; i < _n; ++i)
    {
        assign(_targ[i], *(_val.begin() + i),
               get_index_sequence<decay_t<ValueType>>::value);
    }
}

◆ execute() [1/3]

template<typename BundleT , typename FuncT , typename... Args>

auto tim::mpl::execute	(	BundleT &&	_bundle,
		FuncT &&	_func,
		Args &&...	_args,
		enable_if_t< is_invocable< FuncT, Args... >::value &&!std::is_void< std::result_of_t< FuncT(Args...)> >::value, int >
	)

Definition at line 40 of file bundle_execute.hpp.

{
    using result_type  = std::result_of_t<FuncT(Args...)>;
    using handler_type = execution_handler<decay_t<BundleT>, result_type>;
    return handler_type{ std::forward<BundleT>(_bundle),
                         std::forward<FuncT>(_func)(std::forward<Args>(_args)...) };
}

References tim::_args.

Referenced by tim::auto_base_bundle< Tag, CompT, BundleT >::execute(), tim::lightweight_tuple< Types >::execute(), tim::mpl::execution_handler< BundleT, DataT >::get(), tim::mpl::execution_handler< BundleT, void >::get(), tim::mpl::execution_handler< BundleT, DataT >::get_labeled(), and tim::mpl::execution_handler< BundleT, void >::get_labeled().

◆ execute() [2/3]

template<typename BundleT , typename FuncT , typename... Args>

auto tim::mpl::execute	(	BundleT &&	_bundle,
		FuncT &&	_func,
		Args &&...	_args,
		enable_if_t< is_invocable< FuncT, Args... >::value &&std::is_void< std::result_of_t< FuncT(Args...)> >::value, int >
	)

Definition at line 53 of file bundle_execute.hpp.

{
    _func(std::forward<Args>(_args)...);
    return std::forward<BundleT>(_bundle);
}

References tim::_args.

◆ execute() [3/3]

template<typename BundleT , typename ValueT >

auto tim::mpl::execute	(	BundleT &&	_bundle,
		ValueT &&	_value,
		enable_if_t<!is_invocable< ValueT >::value, long >
	)

Definition at line 64 of file bundle_execute.hpp.

{
    using handler_type = execution_handler<decay_t<BundleT>, ValueT>;
    return handler_type{ std::forward<BundleT>(_bundle), std::forward<ValueT>(_value) };
}

◆ get_reference_tuple()

template<typename Rp , typename Tp >

decltype(auto) tim::mpl::get_reference_tuple ( Tp && _tuple )

Definition at line 1075 of file types.hpp.

{
    // static_assert(concepts::is_variadic<Tp>::value, "Requires variadic type");
    using sequence_type = union_index_sequence_t<Rp, decay_t<Tp>>;
    return impl::get_reference_tuple(std::forward<Tp>(_tuple), sequence_type{});
}

Referenced by tim::lightweight_tuple< Types >::start(), and tim::lightweight_tuple< Types >::stop().

◆ get_size() [1/6]

template<typename Tp , typename std::enable_if<(std::is_arithmetic< Tp >::value), int >::type = 0>

constexpr auto tim::mpl::get_size	(	const Tp &	,
		std::tuple<>
	)		-> size_t

constexpr

Definition at line 877 of file types.hpp.

{
    return 1;
}

Referenced by tim::math::divide(), tim::math::minus(), tim::math::multiply(), and tim::math::plus().

◆ get_size() [2/6]

template<typename Tp , typename std::enable_if<(std::is_arithmetic< Tp >::value), int >::type = 0>

constexpr auto tim::mpl::get_size	(	const Tp &	,
		type_list<>
	)		-> size_t

constexpr

Definition at line 892 of file types.hpp.

{
    return 1;
}

◆ get_size() [3/6]

template<typename Tp >

auto tim::mpl::get_size ( const Tp & _val ) -> decltype(get_size(_val, get_index_sequence<decay_t<Tp>>::value))

Definition at line 913 of file types.hpp.

{
    return get_size(_val, get_index_sequence<decay_t<Tp>>::value);
}

◆ get_size() [4/6]

template<typename Tp , size_t... Idx>

constexpr auto tim::mpl::get_size	(	const Tp &	_val,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_val), size_t())

constexpr

Definition at line 906 of file types.hpp.

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

◆ get_size() [5/6]

template<typename Tp >

auto tim::mpl::get_size	(	const Tp &	_val,
		std::tuple<>
	)		-> decltype(_val.size(), size_t())

Definition at line 884 of file types.hpp.

{
    return _val.size();
}

◆ get_size() [6/6]

template<typename Tp >

auto tim::mpl::get_size	(	const Tp &	_val,
		type_list<>
	)		-> decltype(_val.size(), size_t())

Definition at line 899 of file types.hpp.

{
    return _val.size();
}

◆ resize() [1/2]

template<typename T >

auto tim::mpl::resize	(	T &	,
			...
	)		-> void

Definition at line 929 of file types.hpp.

930{}

Referenced by tim::math::divide(), tim::math::minus(), tim::math::multiply(), and tim::math::plus().

◆ resize() [2/2]

template<typename T >

auto tim::mpl::resize	(	T &	_targ,
		size_t	_n
	)		-> decltype(_targ.resize(_n), void())

Definition at line 934 of file types.hpp.

{
    _targ.resize(_n);
}

Classes

Typedefs

Functions

Class Documentation

◆ tim::mpl::function_traits

◆ tim::mpl::get_false_types

◆ tim::mpl::get_false_types< Predicate, type_list< Sequence... > >

◆ tim::mpl::get_true_types

◆ tim::mpl::get_true_types< Predicate, type_list< Sequence... > >

◆ tim::mpl::lightweight

◆ tim::mpl::piecewise_ignore

◆ tim::mpl::piecewise_select

◆ tim::mpl::push_back

◆ tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

◆ tim::mpl::push_back< Tuple< Types... >, T >

◆ tim::mpl::union_index_of

◆ tim::mpl::union_index_sequence

◆ tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

Typedef Documentation

◆ append_type

◆ append_type_t

◆ available_t

◆ external_function_wrappers_t

◆ filter_empty_t

◆ filter_false_t

◆ filter_gotchas

◆ filter_gotchas_t

◆ filter_true_t

◆ get_data_label_t

◆ get_data_type_t

◆ get_data_value_t

◆ get_false_types_t

◆ get_trait_type_t

◆ get_true_types_t

◆ implemented_list_t

◆ implemented_t

◆ is_one_of_integral

◆ negative_start_priority

◆ negative_stop_priority

◆ non_placeholder_t

◆ non_quirk_t

◆ positive_start_priority

◆ positive_stop_priority

◆ remove_duplicates_t

◆ remove_type

◆ remove_type_t

◆ runtime_configurable_t

◆ sort

◆ subtract_t

◆ union_index_sequence_t

◆ unique_t

Function Documentation

◆ assign() [1/5]

◆ assign() [2/5]

◆ assign() [3/5]

◆ assign() [4/5]

◆ assign() [5/5]

◆ execute() [1/3]

◆ execute() [2/3]

◆ execute() [3/3]

◆ get_reference_tuple()

◆ get_size() [1/6]

◆ get_size() [2/6]

◆ get_size() [3/6]

◆ get_size() [4/6]

◆ get_size() [5/6]

◆ get_size() [6/6]

◆ resize() [1/2]

◆ resize() [2/2]