tim::mpl Namespace Reference

Classes
struct	apply
struct	apply< void >
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_false_types
	generic alias for extracting all types with a specified trait disabled More...
struct	get_false_types< Predicate, type_list< Sequence... > >
struct	function_traits
struct	function_traits< R(*)(Args...)>
struct	function_traits< R(Args...)>
struct	function_traits< R(C::*)(Args...)>
struct	function_traits< R(C::*)(Args...) const >
struct	function_traits< R(C::*)>
struct	get_tuple_size
struct	push_back
struct	push_back< Tuple< Types... >, T >
struct	push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, 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... > >
struct	lightweight
	a generic type for indicating that function call or constructor should be as lightweight as possible. More...
struct	piecewise_select
class	execution_handler
	This is an intermediate type that permits operations such as: More...
class	execution_handler< BundleT, void >
struct	is_invocable
struct	is_invocable_r

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... 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::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
	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
	type

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

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::push_back

struct tim::mpl::push_back

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

Definition at line 953 of file types.hpp.

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

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 956 of file types.hpp.

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

Class Members
	type

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 964 of file types.hpp.

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

Class Members
	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 972 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 1011 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 1015 of file types.hpp.

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

Class Members
	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_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 >:

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 380 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 388 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 461 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 418 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 412 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 415 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 436 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 428 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 432 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 440 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 396 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 465 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 471 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 468 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 474 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 399 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 384 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 392 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 457 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 450 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 1022 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 402 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 924 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));
}

References assign(), and TIMEMORY_FOLD_EXPRESSION.

assign() [2/5]

template<typename Tp >

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

Definition at line 904 of file types.hpp.

{
    _targ = _val;
}

Referenced by assign().

assign() [3/5]

template<typename Tp , typename Vp >

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

Definition at line 945 of file types.hpp.

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

References assign().

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 935 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));
}

References assign(), and TIMEMORY_FOLD_EXPRESSION.

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 911 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);
    }
}

References assign(), get_size(), and resize().

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)...) };
}

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

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

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 838 of file types.hpp.

{
    return 1;
}

Referenced by assign(), tim::math::divide(), get_size(), 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 853 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 874 of file types.hpp.

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

References get_size().

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 867 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 845 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 860 of file types.hpp.

{
    return _val.size();
}

resize() [1/2]

template<typename T >

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

Definition at line 890 of file types.hpp.

{}

Referenced by assign(), 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 895 of file types.hpp.

{
    _targ.resize(_n);
}