Classes
struct	always_true

struct	basic_traits

struct	callable_traits

struct	callable_traits< R(T::*), true >

struct	check_deducible_signature

struct	count_for_pack

struct	fx_traits

struct	fx_traits< R(*)(Args...), false >

struct	fx_traits< R(*)(Args...,...), false >

struct	fx_traits< R(Args...), false >

struct	fx_traits< R(Args...,...), false >

struct	fx_traits< R(T::*)(Args...) const &&, false >

struct	fx_traits< R(T::*)(Args...) const &, false >

struct	fx_traits< R(T::*)(Args...) const volatile &&, false >

struct	fx_traits< R(T::*)(Args...) const volatile &, false >

struct	fx_traits< R(T::*)(Args...) const volatile, false >

struct	fx_traits< R(T::*)(Args...) const, false >

struct	fx_traits< R(T::*)(Args...)&&, false >

struct	fx_traits< R(T::*)(Args...)&, false >

struct	fx_traits< R(T::*)(Args...), false >

struct	fx_traits< R(T::*)(Args...,...) const &&, false >

struct	fx_traits< R(T::*)(Args...,...) const &, false >

struct	fx_traits< R(T::*)(Args...,...) const volatile &&, false >

struct	fx_traits< R(T::*)(Args...,...) const volatile &, false >

struct	fx_traits< R(T::*)(Args...,...) const volatile, false >

struct	fx_traits< R(T::*)(Args...,...) const, false >

struct	fx_traits< R(T::*)(Args...,...)&&, false >

struct	fx_traits< R(T::*)(Args...,...)&, false >

struct	fx_traits< R(T::*)(Args...,...), false >

struct	fx_traits< Signature, true >

struct	has_begin_end_impl

struct	has_insert_after_test

struct	has_insert_test

struct	has_iterator_impl

struct	has_key_type_impl

struct	has_key_value_pair_impl

struct	has_mapped_type_impl

struct	has_max_size_test

struct	has_push_back_test

struct	has_size_test

struct	has_to_string_test

struct	has_value_type_impl

struct	index_in_pack

struct	index_in_pack< I, T, T1, Args... >

struct	is_callable

struct	is_callable< T, std::enable_if_t< std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_same< decltype(void(&T::operator())), void >::value > >

struct	is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >

struct	is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >

struct	is_invokable_tester

struct	is_matched_lookup_impl

struct	is_matched_lookup_impl< T, true >

struct	is_specialization_of

struct	is_specialization_of< Templ< T... >, Templ >

struct	void_tuple_element

struct	void_tuple_element< I, std::tuple<> >

Typedefs
template<std::size_t I, typename T >
using	void_tuple_element_t = typename void_tuple_element< I, T >::type

Functions
template<typename T , typename U , typename = decltype(std::declval<T&>() < std::declval<U&>())>
std::true_type	supports_op_less_test (const T &, const U &)

std::false_type	supports_op_less_test (...)

template<typename T , typename U , typename = decltype(std::declval<T&>() == std::declval<U&>())>
std::true_type	supports_op_equal_test (const T &, const U &)

std::false_type	supports_op_equal_test (...)

template<typename T , typename U , typename = decltype(std::declval<T&>() <= std::declval<U&>())>
std::true_type	supports_op_less_equal_test (const T &, const U &)

std::false_type	supports_op_less_equal_test (...)

template<typename T , typename OS , typename = decltype(std::declval<OS&>() << std::declval<T&>())>
std::true_type	supports_ostream_op (const T &, const OS &)

std::false_type	supports_ostream_op (...)

template<typename T , typename = decltype(to_string(std::declval<T&>()))>
std::true_type	supports_adl_to_string (const T &)

std::false_type	supports_adl_to_string (...)

template<typename T , meta::disable< meta::is_specialization_of< meta::unqualified_t< T >, std::tuple >> = meta::enabler>
decltype(auto)	force_tuple (T &&x)

Typedef Documentation

§ void_tuple_element_t

template<std::size_t I, typename T >

using sol::meta::meta_detail::void_tuple_element_t = typedef typename void_tuple_element<I, T>::type

Function Documentation

§ force_tuple()

template<typename T , meta::disable< meta::is_specialization_of< meta::unqualified_t< T >, std::tuple >> = meta::enabler>

decltype(auto) sol::meta::meta_detail::force_tuple ( T && x )

                                               {
                 return std::tuple<std::decay_t<T>>(std::forward<T>(x));
             }

§ supports_adl_to_string() [1/2]

template<typename T , typename = decltype(to_string(std::declval<T&>()))>

std::true_type sol::meta::meta_detail::supports_adl_to_string ( const T & )

§ supports_adl_to_string() [2/2]

std::false_type sol::meta::meta_detail::supports_adl_to_string ( ... )

§ supports_op_equal_test() [1/2]

template<typename T , typename U , typename = decltype(std::declval<T&>() == std::declval<U&>())>

std::true_type sol::meta::meta_detail::supports_op_equal_test	(	const T &	,
		const U &
	)

§ supports_op_equal_test() [2/2]

std::false_type sol::meta::meta_detail::supports_op_equal_test ( ... )

§ supports_op_less_equal_test() [1/2]

template<typename T , typename U , typename = decltype(std::declval<T&>() <= std::declval<U&>())>

std::true_type sol::meta::meta_detail::supports_op_less_equal_test	(	const T &	,
		const U &
	)

§ supports_op_less_equal_test() [2/2]

std::false_type sol::meta::meta_detail::supports_op_less_equal_test ( ... )

§ supports_op_less_test() [1/2]

template<typename T , typename U , typename = decltype(std::declval<T&>() < std::declval<U&>())>

std::true_type sol::meta::meta_detail::supports_op_less_test	(	const T &	,
		const U &
	)

§ supports_op_less_test() [2/2]

std::false_type sol::meta::meta_detail::supports_op_less_test ( ... )

§ supports_ostream_op() [1/2]

template<typename T , typename OS , typename = decltype(std::declval<OS&>() << std::declval<T&>())>

std::true_type sol::meta::meta_detail::supports_ostream_op	(	const T &	,
		const OS &
	)

§ supports_ostream_op() [2/2]

std::false_type sol::meta::meta_detail::supports_ostream_op ( ... )

Classes

Typedefs

Functions