sol::meta Namespace Reference

Namespaces
	detail
	meta_detail

Classes
struct	all
struct	all< T, Args... >
struct	all_same
struct	all_same< T, U, Args... >
struct	any
struct	any< T, Args... >
struct	any_same
struct	any_same< T, U, Args... >
struct	at_in_pack
struct	at_in_pack< 0, Arg, Args... >
struct	at_in_pack< I, Arg, Args... >
struct	bind_traits
struct	count_2_for_pack
struct	count_for
struct	count_for< Pred, types< Args... > >
struct	count_for_pack
struct	count_for_to_pack
struct	find_in_pack_v
struct	find_in_pack_v< V, Vs1, Vs... >
struct	has_begin_end
struct	has_deducible_signature
struct	has_iterator
struct	has_key_type
struct	has_key_value_pair
struct	has_mapped_type
struct	has_value_type
struct	identity
struct	index_in
struct	index_in< T, types< Args... > >
struct	index_in_pack
struct	is_associative
struct	is_builtin_type
struct	is_callable
struct	is_invokable
struct	is_invokable< Fun(Args...)>
struct	is_lookup
struct	is_matched_lookup
struct	is_member_object
struct	is_member_object< readonly_wrapper< T > >
struct	is_move_only
struct	is_optional
struct	is_optional< optional< T > >
struct	is_pair
struct	is_pair< std::pair< T1, T2 > >
struct	is_tuple
struct	is_tuple< std::tuple< Args... > >
struct	iterator_tag
struct	iterator_tag< T, std::conditional_t< false, typename T::iterator_category, void > >
struct	pop_front_type
struct	pop_front_type< types< Arg, Args... > >
struct	pop_front_type< types< Args... > >
struct	remove_member_pointer
struct	remove_member_pointer< R T::* >
struct	remove_member_pointer< R T::*const >
struct	return_type
struct	return_type< T >
struct	return_type<>
struct	unwrap_unqualified
struct	unwrapped
struct	unwrapped< std::reference_wrapper< T > >

Typedefs
template<typename T >
using	unqualified = std::remove_cv< std::remove_reference_t< T >>
template<typename T >
using	unqualified_t = typename unqualified< T >::type
template<typename... Args>
using	tuple_types = typename detail::tuple_types_< Args... >::type
template<typename Arg >
using	pop_front_type_t = typename pop_front_type< Arg >::type
template<std::size_t N, typename Tuple >
using	tuple_element = std::tuple_element< N, std::remove_reference_t< Tuple >>
template<std::size_t N, typename Tuple >
using	tuple_element_t = std::tuple_element_t< N, std::remove_reference_t< Tuple >>
template<std::size_t N, typename Tuple >
using	unqualified_tuple_element = unqualified< tuple_element_t< N, Tuple >>
template<std::size_t N, typename Tuple >
using	unqualified_tuple_element_t = unqualified_t< tuple_element_t< N, Tuple >>
template<typename Signature >
using	function_args_t = typename bind_traits< Signature >::args_list
template<typename Signature >
using	function_signature_t = typename bind_traits< Signature >::signature_type
template<typename Signature >
using	function_return_t = typename bind_traits< Signature >::return_type
typedef std::array< char, 1 >	sfinae_yes_t
typedef std::array< char, 2 >	sfinae_no_t
template<typename T >
using	identity_t = typename identity< T >::type
template<typename T >
using	unwrapped_t = typename unwrapped< T >::type
template<typename T >
using	unwrap_unqualified_t = typename unwrap_unqualified< T >::type
template<typename T >
using	remove_member_pointer_t = remove_member_pointer< T >
template<typename T , template< typename... > class Templ>
using	is_specialization_of = meta_detail::is_specialization_of< std::remove_cv_t< T >, Templ >
template<bool B>
using	boolean = std::integral_constant< bool, B >
template<typename T >
using	invoke_t = typename T::type
template<typename T >
using	invoke_b = boolean< T::value >
template<typename T >
using	neg = boolean<!T::value >
template<typename Condition , typename Then , typename Else >
using	condition = std::conditional_t< Condition::value, Then, Else >
template<bool value, typename T = void>
using	disable_if_t = std::enable_if_t<!value, T >
template<typename... Args>
using	enable = std::enable_if_t< all< Args... >::value, enable_t >
template<typename... Args>
using	disable = std::enable_if_t< neg< all< Args... >>::value, enable_t >
template<typename... Args>
using	enable_any = std::enable_if_t< any< Args... >::value, enable_t >
template<typename... Args>
using	disable_any = std::enable_if_t< neg< any< Args... >>::value, enable_t >
template<std::size_t I, typename... Args>
using	at_in_pack_t = typename at_in_pack< I, Args... >::type
template<typename... Args>
using	return_type_t = typename return_type< Args... >::type
template<typename T , typename U = T>
using	supports_op_less = decltype(meta_detail::supports_op_less_test(std::declval< T & >(), std::declval< U & >()))
template<typename T , typename U = T>
using	supports_op_equal = decltype(meta_detail::supports_op_equal_test(std::declval< T & >(), std::declval< U & >()))
template<typename T , typename U = T>
using	supports_op_less_equal = decltype(meta_detail::supports_op_less_equal_test(std::declval< T & >(), std::declval< U & >()))
template<typename T , typename U = std::ostream>
using	supports_ostream_op = decltype(meta_detail::supports_ostream_op(std::declval< T & >(), std::declval< U & >()))
template<typename T >
using	supports_adl_to_string = decltype(meta_detail::supports_adl_to_string(std::declval< T & >()))
template<typename T >
using	supports_to_string_member = meta::boolean< meta_detail::has_to_string_test< T >::value >
template<typename T >
using	has_push_back = meta::boolean< meta_detail::has_push_back_test< T >::value >
template<typename T >
using	has_max_size = meta::boolean< meta_detail::has_max_size_test< T >::value >
template<typename T >
using	has_insert = meta::boolean< meta_detail::has_insert_test< T >::value >
template<typename T >
using	has_insert_after = meta::boolean< meta_detail::has_insert_after_test< T >::value >
template<typename T >
using	has_size = meta::boolean< meta_detail::has_size_test< T >::value||meta_detail::has_size_test< const T >::value >
template<typename T >
using	is_string_like = any< is_specialization_of< meta::unqualified_t< T >, std::basic_string >, is_specialization_of< meta::unqualified_t< T >, basic_string_view >, meta::all< std::is_array< unqualified_t< T >>, meta::any_same< meta::unqualified_t< std::remove_all_extents_t< meta::unqualified_t< T >>>, char, char16_t, char32_t, wchar_t >> >
template<typename T >
using	is_string_constructible = any< meta::all< std::is_array< unqualified_t< T >>, std::is_same< meta::unqualified_t< std::remove_all_extents_t< meta::unqualified_t< T >>>, char >>, std::is_same< unqualified_t< T >, const char * >, std::is_same< unqualified_t< T >, char >, std::is_same< unqualified_t< T >, std::string >, std::is_same< unqualified_t< T >, std::initializer_list< char >> >
template<typename T >
using	is_c_str = any< std::is_same< std::decay_t< unqualified_t< T >>, const char * >, std::is_same< std::decay_t< unqualified_t< T >>, char * >, std::is_same< unqualified_t< T >, std::string >>
template<typename T >
using	is_not_move_only = neg< is_move_only< T >>

Enumerations
enum	enable_t { enable_t::_ }

Functions
template<typename... X>
decltype(auto)	tuplefy (X &&... x)

Variables
constexpr const auto	enabler = enable_t::_

Typedef Documentation

at_in_pack_t

template<std::size_t I, typename... Args>

using sol::meta::at_in_pack_t = typedef typename at_in_pack<I, Args...>::type

boolean

template<bool B>

using sol::meta::boolean = typedef std::integral_constant<bool, B>

condition

template<typename Condition , typename Then , typename Else >

using sol::meta::condition = typedef std::conditional_t<Condition::value, Then, Else>

disable

template<typename... Args>

using sol::meta::disable = typedef std::enable_if_t<neg<all<Args...>>::value, enable_t>

disable_any

template<typename... Args>

using sol::meta::disable_any = typedef std::enable_if_t<neg<any<Args...>>::value, enable_t>

disable_if_t

template<bool value, typename T = void>

using sol::meta::disable_if_t = typedef std::enable_if_t<!value, T>

enable

template<typename... Args>

using sol::meta::enable = typedef std::enable_if_t<all<Args...>::value, enable_t>

enable_any

template<typename... Args>

using sol::meta::enable_any = typedef std::enable_if_t<any<Args...>::value, enable_t>

function_args_t

template<typename Signature >

using sol::meta::function_args_t = typedef typename bind_traits<Signature>::args_list

function_return_t

template<typename Signature >

using sol::meta::function_return_t = typedef typename bind_traits<Signature>::return_type

function_signature_t

template<typename Signature >

using sol::meta::function_signature_t = typedef typename bind_traits<Signature>::signature_type

has_insert

template<typename T >

using sol::meta::has_insert = typedef meta::boolean<meta_detail::has_insert_test<T>::value>

has_insert_after

template<typename T >

using sol::meta::has_insert_after = typedef meta::boolean<meta_detail::has_insert_after_test<T>::value>

has_max_size

template<typename T >

using sol::meta::has_max_size = typedef meta::boolean<meta_detail::has_max_size_test<T>::value>

has_push_back

template<typename T >

using sol::meta::has_push_back = typedef meta::boolean<meta_detail::has_push_back_test<T>::value>

has_size

template<typename T >

using sol::meta::has_size = typedef meta::boolean<meta_detail::has_size_test<T>::value || meta_detail::has_size_test<const T>::value>

identity_t

template<typename T >

using sol::meta::identity_t = typedef typename identity<T>::type

invoke_b

template<typename T >

using sol::meta::invoke_b = typedef boolean<T::value>

invoke_t

template<typename T >

using sol::meta::invoke_t = typedef typename T::type

is_c_str

template<typename T >

using sol::meta::is_c_str = typedef any< std::is_same<std::decay_t<unqualified_t<T>>, const char*>, std::is_same<std::decay_t<unqualified_t<T>>, char*>, std::is_same<unqualified_t<T>, std::string>>

is_not_move_only

template<typename T >

using sol::meta::is_not_move_only = typedef neg<is_move_only<T>>

is_specialization_of

template<typename T , template< typename... > class Templ>

using sol::meta::is_specialization_of = typedef meta_detail::is_specialization_of<std::remove_cv_t<T>, Templ>

is_string_constructible

template<typename T >

using sol::meta::is_string_constructible = typedef any< meta::all<std::is_array<unqualified_t<T>>, std::is_same<meta::unqualified_t<std::remove_all_extents_t<meta::unqualified_t<T>>>, char>>, std::is_same<unqualified_t<T>, const char*>, std::is_same<unqualified_t<T>, char>, std::is_same<unqualified_t<T>, std::string>, std::is_same<unqualified_t<T>, std::initializer_list<char>> >

is_string_like

template<typename T >

using sol::meta::is_string_like = typedef any< is_specialization_of<meta::unqualified_t<T>, std::basic_string>, is_specialization_of<meta::unqualified_t<T>, basic_string_view>, meta::all<std::is_array<unqualified_t<T>>, meta::any_same<meta::unqualified_t<std::remove_all_extents_t<meta::unqualified_t<T>>>, char, char16_t, char32_t, wchar_t>> >

neg

template<typename T >

using sol::meta::neg = typedef boolean<!T::value>

pop_front_type_t

template<typename Arg >

using sol::meta::pop_front_type_t = typedef typename pop_front_type<Arg>::type

remove_member_pointer_t

template<typename T >

using sol::meta::remove_member_pointer_t = typedef remove_member_pointer<T>

return_type_t

template<typename... Args>

using sol::meta::return_type_t = typedef typename return_type<Args...>::type

sfinae_no_t

typedef std::array<char, 2> sol::meta::sfinae_no_t

sfinae_yes_t

typedef std::array<char, 1> sol::meta::sfinae_yes_t

supports_adl_to_string

template<typename T >

using sol::meta::supports_adl_to_string = typedef decltype(meta_detail::supports_adl_to_string(std::declval<T&>()))

supports_op_equal

template<typename T , typename U = T>

using sol::meta::supports_op_equal = typedef decltype(meta_detail::supports_op_equal_test(std::declval<T&>(), std::declval<U&>()))

supports_op_less

template<typename T , typename U = T>

using sol::meta::supports_op_less = typedef decltype(meta_detail::supports_op_less_test(std::declval<T&>(), std::declval<U&>()))

supports_op_less_equal

template<typename T , typename U = T>

using sol::meta::supports_op_less_equal = typedef decltype(meta_detail::supports_op_less_equal_test(std::declval<T&>(), std::declval<U&>()))

supports_ostream_op

template<typename T , typename U = std::ostream>

using sol::meta::supports_ostream_op = typedef decltype(meta_detail::supports_ostream_op(std::declval<T&>(), std::declval<U&>()))

supports_to_string_member

template<typename T >

using sol::meta::supports_to_string_member = typedef meta::boolean<meta_detail::has_to_string_test<T>::value>

tuple_element

template<std::size_t N, typename Tuple >

using sol::meta::tuple_element = typedef std::tuple_element<N, std::remove_reference_t<Tuple>>

tuple_element_t

template<std::size_t N, typename Tuple >

using sol::meta::tuple_element_t = typedef std::tuple_element_t<N, std::remove_reference_t<Tuple>>

tuple_types

template<typename... Args>

using sol::meta::tuple_types = typedef typename detail::tuple_types_<Args...>::type

unqualified

template<typename T >

using sol::meta::unqualified = typedef std::remove_cv<std::remove_reference_t<T>>

unqualified_t

template<typename T >

using sol::meta::unqualified_t = typedef typename unqualified<T>::type

unqualified_tuple_element

template<std::size_t N, typename Tuple >

using sol::meta::unqualified_tuple_element = typedef unqualified<tuple_element_t<N, Tuple>>

unqualified_tuple_element_t

template<std::size_t N, typename Tuple >

using sol::meta::unqualified_tuple_element_t = typedef unqualified_t<tuple_element_t<N, Tuple>>

unwrap_unqualified_t

template<typename T >

using sol::meta::unwrap_unqualified_t = typedef typename unwrap_unqualified<T>::type

unwrapped_t

template<typename T >

using sol::meta::unwrapped_t = typedef typename unwrapped<T>::type

Enumeration Type Documentation

enable_t

enum sol::meta::enable_t

strong

Enumerator
_

                            {
            _
        };

Function Documentation

tuplefy()

template<typename... X>

decltype(auto) sol::meta::tuplefy

(

X &&...

x

)

                                         {
            return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
        }

Variable Documentation

enabler

constexpr const auto sol::meta::enabler = enable_t::_