tpf::types::hidden Namespace Reference

Implementations in this scope is meant NOT to be accessed directly by the client. More...

Classes
struct	append_type_st
struct	append_type_st< ArgType, type_list_t< RightTypes... > >
struct	append_type_st< type_list_t< ArgTypes... >, type_list_t< RightTypes... > >
struct	are_all_in_list_st
struct	are_all_in_list_st< type_list_t< Types... > >
struct	are_all_in_list_st< type_list_t< Types... >, TestType >
struct	are_all_in_list_st< type_list_t< Types... >, TestType, TestTypes... >
struct	are_all_in_list_st< type_list_t< Types... >, type_list_t< TestType > >
struct	are_all_in_list_st< type_list_t< Types... >, type_list_t< TestType, TestTypes... > >
struct	are_all_in_list_st< type_list_t< Types... >, type_list_t<> >
struct	arg_list
struct	common_type_st
struct	common_type_st< Type >
struct	common_type_st< Type1, Type2 >
struct	common_type_st< Type1, Type2, Types... >
struct	common_type_st< type_list_t< Type > >
struct	common_type_st< type_list_t< Type1, Type2 > >
struct	common_type_st< type_list_t< Type1, Type2, Types... > >
struct	common_type_st< type_list_t<> >
class	container_of_tuples_class
class	container_of_tuples_class< std::map, KeyType, ElementTypes... >
class	container_of_tuples_class< std::multimap, KeyType, ElementTypes... >
class	container_of_tuples_class< std::unordered_map, KeyType, ElementTypes... >
class	container_of_tuples_class< std::unordered_multimap, KeyType, ElementTypes... >
struct	container_of_tuples_st
struct	container_of_tuples_st< ContainerType, type_list_t< ElementTypes... > >
class	container_of_variants_class
class	container_of_variants_class< std::map, KeyType, ElementTypes... >
class	container_of_variants_class< std::multimap, KeyType, ElementTypes... >
class	container_of_variants_class< std::pair, KeyType, ElementTypes... >
class	container_of_variants_class< std::unordered_map, KeyType, ElementTypes... >
class	container_of_variants_class< std::unordered_multimap, KeyType, ElementTypes... >
struct	container_of_variants_st
struct	container_of_variants_st< ContainerType, type_list_t< ElementTypes... > >
struct	container_of_variants_st< std::map, KeyType, type_list_t< ElementTypes... > >
struct	container_of_variants_st< std::multimap, KeyType, type_list_t< ElementTypes... > >
struct	container_of_variants_st< std::pair, KeyType, type_list_t< ElementTypes... > >
struct	container_of_variants_st< std::unordered_map, KeyType, type_list_t< ElementTypes... > >
struct	container_of_variants_st< std::unordered_multimap, KeyType, type_list_t< ElementTypes... > >
struct	difference_type_st
struct	difference_type_st< type_list_t< Types... > >
struct	difference_type_st< type_list_t< Types... >, Type >
struct	difference_type_st< type_list_t< Types... >, Type, RightTypes... >
struct	difference_type_st< type_list_t< Types... >, type_list_t< Type > >
struct	difference_type_st< type_list_t< Types... >, type_list_t< Type, RightTypes... > >
struct	difference_type_st< type_list_t< Types... >, type_list_t<> >
struct	first_n_types_list_st
struct	first_n_types_list_st< 0, type_list_t<>, type_list_t< RightType, RightTypes... > >
struct	first_n_types_list_st< 0, type_list_t<>, type_list_t<> >
struct	first_n_types_list_st< 1, type_list_t< LeftTypes... >, type_list_t< RightType, RightTypes... > >
struct	first_n_types_list_st< 1, type_list_t< LeftTypes... >, type_list_t<> >
struct	first_n_types_list_st< FirstN, type_list_t< LeftTypes... >, type_list_t< RightType, RightTypes... > >
struct	first_n_types_list_to_template_class_st
struct	first_n_types_list_to_template_class_st< FirstN, TemplateClass, type_list_t< Types... > >
struct	first_n_types_st
struct	first_n_types_st< FirstN, type_list_t<>, RightTypes... >
struct	first_n_types_st< FirstN, type_list_t<>, type_list_t< RightTypes... > >
struct	first_n_types_to_template_class_st
struct	first_n_types_to_template_class_st< FirstN, TemplateClass< InnerTypes... >, type_list_t< Types... > >
struct	first_n_types_to_template_class_st< FirstN, TemplateClass< InnerTypes... >, Types... >
struct	intersection_type_st
struct	intersection_type_st< type_list_t< Types... > >
struct	intersection_type_st< type_list_t< Types... >, Type >
struct	intersection_type_st< type_list_t< Types... >, Type, RightTypes... >
struct	intersection_type_st< type_list_t< Types... >, type_list_t< Type > >
struct	intersection_type_st< type_list_t< Types... >, type_list_t< Type, RightTypes... > >
struct	intersection_type_st< type_list_t< Types... >, type_list_t<> >
struct	is_any_st
struct	is_any_st< std::any >
struct	is_basic_string_st
struct	is_basic_string_st< std::basic_string< Type, Types... > >
struct	is_basic_string_st< std::basic_string_view< Type, Types... > >
struct	is_char_st
struct	is_char_st< char >
struct	is_char_st< unsigned char >
struct	is_in_list_st
struct	is_in_list_st< TestType >
struct	is_in_list_st< TestType, Type >
struct	is_in_list_st< TestType, Type, Types... >
struct	is_in_list_st< TestType, type_list_t< Type > >
struct	is_in_list_st< TestType, type_list_t< Type, Types... > >
struct	is_in_list_st< TestType, type_list_t<> >
struct	is_map_or_unordered_map_st
struct	is_map_or_unordered_map_st< std::map< KeyType, ValueType, Types... > >
struct	is_map_or_unordered_map_st< std::unordered_map< KeyType, ValueType, Types... > >
struct	is_pair_of_variant_st
struct	is_pair_of_variant_st< std::pair< Type, Types... > >
struct	is_pair_st
struct	is_pair_st< std::pair< Type_1, Type_2 > >
struct	is_reference_wrapper_st
struct	is_reference_wrapper_st< std::reference_wrapper< Type > >
struct	is_same_st
struct	is_same_st< Type >
struct	is_same_st< Type1, Type2 >
struct	is_same_st< Type1, Type2, Types... >
struct	is_same_st< type_list_t< Type > >
struct	is_same_st< type_list_t< Type1, Type2 > >
struct	is_same_st< type_list_t< Type1, Type2, Types... > >
struct	is_same_template_st
struct	is_same_template_st< ContainerType< TypeA, TypeAs... >, ContainerType< TypeB, TypeBs... > >
struct	is_same_template_st< ContainerType< TypeA1, TypeA2, TypeA3, TypeA4, TypeAs... >, ContainerType< TypeB1, TypeB2, TypeB3, TypeB4, TypeBs... > >
struct	is_same_template_st< ContainerType< TypeA1, TypeA2, TypeA3, TypeAs... >, ContainerType< TypeB1, TypeB2, TypeB3, TypeBs... > >
struct	is_same_template_st< ContainerType< TypeA1, TypeA2, TypeAs... >, ContainerType< TypeB1, TypeB2, TypeBs... > >
struct	is_same_template_st< ContainerType< Types1... >, ContainerType< Types2... > >
struct	is_same_template_type_st
struct	is_same_template_type_st< ContainerType< Type, Types... >, ContainerType< Type, Types... > >
struct	is_same_template_type_st< ContainerType< Type1, Type2, Type3, Type4, Types... >, ContainerType< Type1, Type2, Type3, Type4, Types... > >
struct	is_same_template_type_st< ContainerType< Type1, Type2, Type3, Types... >, ContainerType< Type1, Type2, Type3, Types... > >
struct	is_same_template_type_st< ContainerType< Type1, Type2, Types... >, ContainerType< Type1, Type2, Types... > >
struct	is_same_template_type_st< ContainerType< Types... >, ContainerType< Types... > >
struct	is_set_or_unordered_set_st
struct	is_set_or_unordered_set_st< std::set< Type, Types... > >
struct	is_set_or_unordered_set_st< std::unordered_set< Type, Types... > >
struct	is_string_st
struct	is_string_st< const char * >
struct	is_string_st< const wchar_t * >
struct	is_string_st< std::basic_string< CharType > >
struct	is_template_st
struct	is_template_st< ContainerType< Type, Args... > >
struct	is_template_st< ContainerType< Types... > >
struct	is_tuple_st
struct	is_tuple_st< std::tuple< Type, Types... > >
struct	is_tuple_st< std::tuple<> >
struct	is_type_in_list_st
struct	is_type_in_list_st< ArgType >
struct	is_type_in_list_st< ArgType, Type, RightTypes... >
struct	is_type_in_list_st< ArgType, type_list_t< Type, RightTypes... > >
struct	is_type_in_list_st< ArgType, type_list_t<> >
struct	is_type_list_equivalent_st
struct	is_type_list_equivalent_st< type_list_t< LeftTypes... > >
struct	is_type_list_equivalent_st< type_list_t< LeftTypes... >, Type >
struct	is_type_list_equivalent_st< type_list_t< LeftTypes... >, Type, RightTypes... >
struct	is_type_list_equivalent_st< type_list_t< LeftTypes... >, type_list_t< RightTypes... > >
struct	is_unique_ptr_st
struct	is_unique_ptr_st< std::unique_ptr< Type, Types... > >
struct	is_variant_st
struct	is_variant_st< std::variant< Types... > >
struct	last_n_types_list_st
struct	last_n_types_list_st< 0, type_list_t< LeftType, LeftTypes... >, type_list_t<> >
struct	last_n_types_list_st< 0, type_list_t<>, type_list_t<> >
struct	last_n_types_list_st< 1, type_list_t< LeftType, LeftTypes... >, type_list_t< RightTypes... > >
struct	last_n_types_list_st< 1, type_list_t<>, type_list_t< RightTypes... > >
struct	last_n_types_list_st< LastN, type_list_t< LeftType, LeftTypes... >, type_list_t< RightTypes... > >
struct	last_n_types_st
struct	last_n_types_st< LastN, type_list_t< LeftTypes... > >
struct	make_signed_integral_st
struct	make_signed_integral_st< Type, true >
struct	make_signed_st
struct	make_signed_st< Type, true >
struct	make_unsigned_integral_st
struct	make_unsigned_integral_st< Type, true >
struct	make_unsigned_st
struct	make_unsigned_st< Type, true >
struct	nth_type_to_template_class_st
struct	nth_type_to_template_class_st< TypeIndex, TemplateClass< InnerTypes... >, type_list_t< Types... > >
struct	nth_type_to_template_class_st< TypeIndex, TemplateClass< InnerTypes... >, Types... >
struct	pop_back_type_st
struct	pop_back_type_st< type_list_t< LeftTypes... >, type_list_t< Type, RightTypes... > >
struct	pop_back_type_st< type_list_t< LeftTypes... >, type_list_t<> >
struct	pop_back_type_wrapper_st
struct	pop_back_type_wrapper_st< type_list_t< Types... > >
struct	pop_front_type_st
struct	pop_front_type_st< type_list_t< Type, Types... > >
struct	pop_front_type_st< type_list_t<> >
struct	pop_front_wrapper_st
struct	pop_front_wrapper_st< type_list_t< Types... > >
struct	prepend_type_st
struct	prepend_type_st< ArgType, type_list_t< RightTypes... > >
struct	prepend_type_st< type_list_t< ArgTypes... >, type_list_t< RightTypes... > >
struct	push_back_type_st
struct	push_back_type_st< ArgType, type_list_t< Types... > >
struct	push_front_type_st
struct	push_front_type_st< ArgType, type_list_t< Types... > >
struct	remove_type_st
struct	remove_type_st< ArgType >
struct	remove_type_st< ArgType, Type >
struct	remove_type_st< ArgType, Type, RightTypes... >
struct	remove_type_st< ArgType, type_list_t< Type > >
struct	remove_type_st< ArgType, type_list_t< Type, RightTypes... > >
struct	remove_type_st< ArgType, type_list_t<> >
struct	remove_type_wrapper_st
struct	remove_type_wrapper_st< ArgType, type_list_t< Types... > >
struct	replace_type_st
struct	replace_type_st< NewType, OldType >
struct	replace_type_st< NewType, OldType, Type >
struct	replace_type_st< NewType, OldType, Type, RightTypes... >
struct	replace_type_st< NewType, OldType, type_list_t< Type > >
struct	replace_type_st< NewType, OldType, type_list_t< Type, RightTypes... > >
struct	replace_type_st< NewType, OldType, type_list_t<> >
struct	return_type_st
struct	return_type_st< void >
struct	select_first_type_st
struct	select_first_type_st< Type >
struct	select_first_type_st< Type, Types... >
struct	select_first_type_st< type_list_t< Type > >
struct	select_first_type_st< type_list_t< Type, Types... > >
struct	select_first_type_st< type_list_t<> >
struct	select_first_type_st<>
struct	select_last_type_st
struct	select_last_type_st< Type >
struct	select_last_type_st< Type, Types... >
struct	select_last_type_st< type_list_t< Type > >
struct	select_last_type_st< type_list_t< Type, Types... > >
struct	select_last_type_st< type_list_t<> >
struct	select_last_type_st<>
struct	select_nth_type_st
struct	select_nth_type_st< 0, Type, Types... >
struct	select_nth_type_st< 0, type_list_t< Type, Types... > >
struct	select_nth_type_st< SelectIndex >
struct	select_nth_type_st< SelectIndex, Type, Types... >
struct	select_nth_type_st< SelectIndex, type_list_t< Type, Types... > >
struct	select_nth_type_st< SelectIndex, type_list_t<> >
struct	st_arg_to_type_list
struct	st_arg_to_type_list< arg_list< Types... > >
struct	st_arg_to_type_list< type_list_t< Types... > >
struct	st_build_arg_types
struct	st_build_arg_types< type_list_t< Heads... >, type_list_t< Tails... > >
struct	st_common_type_solver
struct	st_common_type_solver< Type >
struct	st_common_type_solver< Type, Types... >
struct	st_common_type_solver< type_list_t< Type > >
struct	st_common_type_solver< type_list_t< Type, Types... > >
struct	st_common_type_solver< type_list_t<> >
struct	st_common_type_solver<>
struct	st_contain_no_type_in_tuple
struct	st_contain_no_type_in_tuple< std::tuple< Type > >
struct	st_contain_no_type_in_tuple< std::tuple< Type, Types... > >
struct	st_contain_no_type_in_tuple< std::tuple<> >
struct	st_create_workhorse_range
struct	st_create_workhorse_range< SequenceInOrder, BeginValue, EndValue >
struct	st_create_workhorse_range< SequenceInOrder, BeginValue, EndValue, IncrementValue >
struct	st_create_workhorse_range< SequenceInOrder, EndValue >
struct	st_dummy_type_container
struct	st_has_tuple_common_type
struct	st_has_tuple_common_type< std::tuple< Types... > >
struct	st_index_tuple_vector
struct	st_index_tuple_vector< std::index_sequence< Is... > >
struct	st_is_arg_list
struct	st_is_arg_list< arg_list< Ts... > >
struct	st_is_callable
struct	st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... > >
struct	st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... >, Type >
struct	st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... >, Type, Types... >
struct	st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... >, type_list_t< Types... > >
struct	st_is_constrained_any
struct	st_is_constrained_any< types::any< Types... > >
struct	st_is_integer_sequence
struct	st_is_integer_sequence< std::integer_sequence< Type, Indices... > >
struct	st_is_invocable
struct	st_is_invocable< CallbackType, arg_list< ArgTypes... > >
struct	st_is_numbers_type_v
struct	st_is_numbers_type_v< ContainerType< Ints... > >
struct	st_is_std_array
struct	st_is_std_array< std::array< Type, Size > >
struct	st_is_tag_type_v
struct	st_is_tag_type_v< tag_type< Type, Tag > >
struct	st_is_template_type
struct	st_is_template_type< TemplateType< arg, Types... > >
struct	st_is_template_type< TemplateType< args... > >
struct	st_is_template_type< TemplateType< T, args... > >
struct	st_is_template_type< TemplateType< Types... > >
struct	st_is_type_list
struct	st_is_type_list< type_list_t< Ts... > >
struct	st_is_vector_v
struct	st_is_vector_v< std::vector< Type, Types... > >
struct	st_make_non_class_wrapper
struct	st_make_non_class_wrapper< Type, Tag, true >
struct	st_pairwise_common
struct	st_pairwise_common< T >
struct	st_pairwise_common< T, S >
struct	st_pairwise_common< T, S, Types... >
struct	st_recursive_type_list
struct	st_recursive_type_list< TemplateType< Types... > >
struct	st_reverse_sequence
struct	st_reverse_sequence< std::integer_sequence< T, args... > >
struct	st_revese_sequence_operation
struct	st_revese_sequence_operation< std::integer_sequence< T, args... >, std::integer_sequence< T > >
struct	st_revese_sequence_operation< std::integer_sequence< T, args1... >, std::integer_sequence< T, first, args2... > >
struct	st_sequence_element_count
struct	st_sequence_element_count< std::integer_sequence< T, Elements... > >
struct	st_sequence_element_type
struct	st_sequence_element_type< std::integer_sequence< T, Elements... > >
struct	st_sequence_first_element
struct	st_sequence_first_element< std::integer_sequence< T, First, Remainders... > >
struct	st_sequence_info
struct	st_sequence_info< T, FirstValue, LastValue, CountValue, !StackInOrder >
struct	st_sequence_last_element
struct	st_sequence_last_element< std::integer_sequence< T, First > >
struct	st_sequence_last_element< std::integer_sequence< T, First, Remainders... > >
struct	st_sequence_nth_element
struct	st_sequence_nth_element< 0, std::integer_sequence< T, First, Remainders... > >
struct	st_sequence_nth_element< Nth, std::integer_sequence< T, First, Remainders... > >
struct	st_sequence_span
struct	st_sequence_span< std::integer_sequence< T, First > >
struct	st_sequence_span< std::integer_sequence< T, First, Second, Remainders... > >
struct	st_std_array_element
struct	st_std_array_element< std::array< Type, Size > >
struct	st_tuple_common_type
struct	st_tuple_common_type< std::tuple< ArgTypes1... >, std::tuple< ArgTypes2... > >
struct	st_tuple_size
struct	st_tuple_size< std::tuple< Type, ArgTypes... > >
struct	st_tuple_to_type_list
struct	st_tuple_to_type_list< std::tuple< Types... > >
struct	st_type_list_to_tuple
struct	st_type_list_to_tuple< type_list_t< Types... > >
struct	st_type_list_to_tuple_of_vectors
struct	st_type_list_to_tuple_of_vectors< CntrType< Types... > >
struct	st_type_list_to_tuple_of_vectors< type_list_t< Types... > >
struct	st_unique_ptr_wrapper
struct	st_unique_ptr_wrapper_deleter
struct	st_variant_to_type_list
struct	st_variant_to_type_list< std::variant< Types... > >
struct	st_vector
struct	st_workhorse_range
struct	to_tuple_st
struct	to_tuple_st< std::variant< Types... > >
struct	to_tuple_st< type_list_t< Types... > >
struct	to_variant_st
struct	to_variant_st< std::tuple< Type, Types... > >
struct	to_variant_st< type_list_t< Type, Types... > >
struct	type_count_st
struct	type_count_st< TemplateType< Types... > >
struct	type_count_st< type_list_t< Types... > >
struct	type_list_to_template_class_st
struct	type_list_to_template_class_st< ClassTemplate, type_list_t< Types... > >
struct	type_list_to_template_class_wrapper_st
struct	type_list_to_template_class_wrapper_st< ClassTemplate, type_list_t< Types... > >
struct	type_list_to_template_class_wrapper_st< std::variant, type_list_t< Types... > >
struct	type_list_to_template_class_wrapper_st< std::variant, Types... >
struct	types_to_template_class_st
struct	types_to_template_class_st< ClassTemplate< InnerTypes... >, type_list_t< Types... > >
struct	types_to_template_class_st< ClassTemplate< InnerTypes... >, Types... >
struct	types_to_template_class_wrapper_st
struct	types_to_template_class_wrapper_st< ClassTemplate< InnerTypes... >, type_list_t< Types... > >
struct	types_to_template_class_wrapper_st< ClassTemplate< InnerTypes... >, Types... >
struct	types_to_template_class_wrapper_st< std::variant< InnerTypes... >, type_list_t< Types... > >
struct	types_to_template_class_wrapper_st< std::variant< InnerTypes... >, Types... >
struct	union_type_st
struct	union_type_st< ArgType, type_list_t< Types... > >
struct	union_type_st< type_list_t< Types... > >
struct	union_type_st< type_list_t< Types... >, Type >
struct	union_type_st< type_list_t< Types... >, Type, RightTypes... >
struct	union_type_st< type_list_t< Types... >, type_list_t< Type > >
struct	union_type_st< type_list_t< Types... >, type_list_t< Type, RightTypes... > >
struct	union_type_st< type_list_t< Types... >, type_list_t<> >
struct	unique_types_st
struct	unique_types_st< type_list_t< Types... > >
struct	unique_types_st< type_list_t< Types... >, Type >
struct	unique_types_st< type_list_t< Types... >, Type, RightTypes... >
struct	unique_types_st< type_list_t< Types... >, type_list_t< RightTypes... > >

Typedefs
template<typename Type , auto Tag>
using	non_class_wrapper_t = typename st_make_non_class_wrapper< Type, Tag, std::is_class_v< Type > >::type
template<typename T >
using	to_recursive_type_list_t = typename st_recursive_type_list< T >::type
template<typename TupleType >
using	tuple_to_type_list_t = typename st_tuple_to_type_list< TupleType >::type
template<typename TypeList >
using	type_list_to_tuple_t = typename st_type_list_to_tuple< TypeList >::type
template<typename VarType >
using	variant_to_type_list_t = typename st_variant_to_type_list< VarType >::type
template<typename Type >
using	map_or_unordered_map_pair_t = typename is_map_or_unordered_map_st< remove_cv_ref_t< Type > >::type
template<typename Type >
using	return_type_t = typename return_type_st< Type >::type
template<typename SequenceType >
using	reverse_sequence_t = typename st_reverse_sequence< SequenceType >::type
template<typename T >
using	sequence_element_t = typename st_sequence_element_type< T >::type
template<bool StackOrder, typename SequenceType >
using	sequence_info_t = st_sequence_info< sequence_element_t< SequenceType >, sequence_first_element_v< SequenceType >, sequence_last_element_v< SequenceType >, sequence_element_count_v< SequenceType >, StackOrder >
template<typename T >
using	iterator_value_type_t = decltype(iterator_value_type_fn(std::declval< T >()))
template<typename Type , typename ReturnType >
using	enable_if_iterator_type_t = std::enable_if_t< is_iterator_type_v< Type >, ReturnType >
template<typename T >
using	enable_if_iterator_value_type_t = std::enable_if_t< is_iterator_type_v< T >, iterator_value_type_t< T > >
template<typename T >
using	conditional_iterator_value_type_t = typename std::conditional< is_iterator_type_v< T >, iterator_value_type_t< T >, T >::type
template<typename Type >
using	template_parameter_type_list_t = typename is_template_st< Type >::type
template<typename Type1 , typename Type2 >
using	is_operable_t = std::remove_reference_t< decltype(is_operable_fn(std::declval< Type1 >(), std::declval< Type2 >()))>
template<typename Type , typename ReturnType = void>
using	enable_if_container_type_t = std::enable_if_t< is_container_type_v< remove_cv_ref_t< Type > >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_integral_t = std::enable_if_t< is_integral_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_signed_integral_t = std::enable_if_t< is_signed_integral_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_unsigned_integral_t = std::enable_if_t< is_unsigned_integral_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_integer_t = std::enable_if_t< is_integer_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_not_integer_t = std::enable_if_t<!is_integer_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_signed_integer_t = std::enable_if_t< is_signed_integer_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_unsigned_integer_t = std::enable_if_t< is_unsigned_integer_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_real_number_t = std::enable_if_t< is_real_number_v< Type >, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_numerical_number_t = std::enable_if_t< is_numerical_number_v< Type >, ReturnType >
template<typename Type >
using	make_signed_t = typename make_signed_st< Type, is_integer_v< Type > >::type
template<typename Type >
using	make_unsigned_t = typename make_unsigned_st< Type, is_integer_v< Type > >::type
template<typename Type >
using	make_signed_integral_t = typename make_signed_integral_st< Type, is_integral_v< Type > >::type
template<typename Type >
using	make_unsigned_integral_t = typename make_unsigned_integral_st< Type, is_integral_v< Type > >::type
template<typename... Types>
using	common_type_t = typename st_common_type_solver< Types... >::type
template<typename... Types>
using	select_first_type_t = typename select_first_type_st< Types... >::type
template<typename... Types>
using	first_type_t = select_first_type_t< Types... >
template<typename... Types>
using	front_type_t = select_first_type_t< Types... >
template<typename... Types>
using	select_last_type_t = typename select_last_type_st< Types... >::type
template<typename... Types>
using	last_type_t = select_last_type_t< Types... >
template<typename... Types>
using	back_type_t = select_last_type_t< Types... >
template<auto SelectIndex, typename... Types>
using	select_nth_type_t = typename select_nth_type_st< SelectIndex, Types... >::type
template<auto SelectIndex, typename... Types>
using	nth_type_t = select_nth_type_t< SelectIndex, Types... >
template<typename Type >
using	first_parameter_type_t = first_type_t< template_parameter_type_list_t< Type > >
template<typename Type >
using	last_parameter_type_t = last_type_t< template_parameter_type_list_t< Type > >
template<auto SelectIndex, typename Type >
using	nth_parameter_type_t = nth_type_t< SelectIndex, template_parameter_type_list_t< Type > >
template<typename ArgType , typename... Types>
using	push_front_type_t = typename push_front_type_st< ArgType, Types... >::type
template<typename ArgType , typename... Types>
using	push_back_type_t = typename push_back_type_st< ArgType, Types... >::type
template<typename... Types>
using	pop_front_type_t = typename pop_front_wrapper_st< Types... >::type
template<typename... Types>
using	pop_back_type_t = typename pop_back_type_wrapper_st< Types... >::type
template<size_t FirstN, typename... RightTypes>
using	first_n_types_t = typename first_n_types_st< FirstN, type_list_t<>, RightTypes... >::type
template<size_t FirstN, typename... RightTypes>
using	select_first_n_types_t = first_n_types_t< FirstN, RightTypes... >
template<size_t LastN, typename... LeftTypes>
using	last_n_types_t = typename last_n_types_st< LastN, LeftTypes... >::type
template<size_t LastN, typename... LeftTypes>
using	select_last_n_types_t = last_n_types_t< LastN, LeftTypes... >
template<typename TestType , typename TypeList , typename ReturnType = TestType>
using	enable_if_in_list_t = std::enable_if_t< is_type_in_list_v< TestType, TypeList >, ReturnType >
template<typename TestTypeList , typename TypeList , typename ReturnType = void>
using	enable_if_all_in_list_t = std::enable_if_t< are_all_in_list_v< TypeList, TestTypeList >, ReturnType >
template<typename... Types>
using	unique_types_t = typename unique_types_st< type_list_t<>, Types... >::type
template<typename Type , typename... Types>
using	to_variant_t = typename to_variant_st< Type, Types... >::type
template<typename... Types>
using	to_tuple_t = typename to_tuple_st< Types... >::type
template<typename ArgType , typename RightList >
using	prepend_type_t = typename prepend_type_st< ArgType, RightList >::type
template<typename ArgType , typename RightList >
using	append_type_t = typename append_type_st< ArgType, RightList >::type
template<typename LeftList , typename RightList >
using	union_type_t = typename union_type_st< LeftList, RightList >::type
template<typename LeftList , typename RightList >
using	intersection_type_t = typename intersection_type_st< LeftList, RightList >::type
template<typename ArgType , typename... Types>
using	remove_type_t = typename remove_type_wrapper_st< ArgType, Types... >::type
template<typename LeftList , typename RightList >
using	difference_type_t = typename difference_type_st< LeftList, RightList >::type
template<typename NewType , typename OldType , typename TypeList >
using	replace_type_t = typename replace_type_st< NewType, OldType, TypeList >::type
template<typename... ArgTypes>
using	make_unique_ptr_wrapper_t = typename st_unique_ptr_wrapper< ArgTypes... >::type
template<typename deleter , typename... ArgTypes>
using	make_unique_ptr_deleter_wrapper_t = typename st_unique_ptr_wrapper_deleter< deleter, ArgTypes... >::type
template<typename FuncType , typename... ArgTypes>
using	function_return_type_t = remove_cvref_t< decltype(function_return_type_fn(std::declval< FuncType >(), std::declval< ArgTypes >()...))>
template<typename TupleType >
using	tuple_common_element_t = typename st_has_tuple_common_type< TupleType >::type
template<typename TupleType >
using	tuple_to_std_array_t = std::array< tuple_common_element_t< TupleType >, tuple_size_v< TupleType > >
template<typename Type >
using	arg_to_type_t = typename st_is_arg_list< Type >::type
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using	container_of_variants_t = typename container_of_variants_st< ContainerType, unique_types_t< ElementTypes... > >::type
template<template< typename, typename... > class ContainerType, typename KeyType , typename... ElementTypes>
using	container_map_of_variants_t = typename container_of_variants_st< ContainerType, KeyType, unique_types_t< ElementTypes... > >::type
template<typename... ElementTypes>
using	vector_of_variants_t = container_of_variants_t< std::vector, ElementTypes... >
template<typename... ElementTypes>
using	deque_of_variants_t = container_of_variants_t< std::deque, ElementTypes... >
template<typename... ElementTypes>
using	list_of_variants_t = container_of_variants_t< std::list, ElementTypes... >
template<typename... ElementTypes>
using	set_of_variants_t = container_of_variants_t< std::set, ElementTypes... >
template<typename... ElementTypes>
using	multiset_of_variants_t = container_of_variants_t< std::multiset, ElementTypes... >
template<typename... ElementTypes>
using	unordered_set_of_variants_t = container_of_variants_t< std::unordered_set, ElementTypes... >
template<typename... ElementTypes>
using	unordered_multiset_of_variants_t = container_of_variants_t< std::unordered_multiset, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	pair_of_variants_t = container_map_of_variants_t< std::pair, KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	map_of_variants_t = container_map_of_variants_t< std::map, KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	multimap_of_variants_t = container_map_of_variants_t< std::multimap, KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_map_of_variants_t = container_map_of_variants_t< std::unordered_map, KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_multimap_of_variants_t = container_map_of_variants_t< std::unordered_multimap, KeyType, ElementTypes... >
template<typename Type , typename... Types>
using	types_to_template_class_t = typename types_to_template_class_wrapper_st< Type, Types... >::type
template<template< typename... >class ClassTemplate, typename... Types>
using	type_list_to_template_class_t = typename type_list_to_template_class_wrapper_st< ClassTemplate, Types... >::type
template<size_t TypeIndex, typename TemplateClass , typename... Types>
using	nth_type_to_template_class_t = typename nth_type_to_template_class_st< TypeIndex, TemplateClass, Types... >::type
template<size_t FirstN, template< typename... > typename TemplateClass, typename... Types>
using	first_n_types_list_to_template_class_t = typename first_n_types_list_to_template_class_st< FirstN, TemplateClass, Types... >::type
template<size_t FirstN, typename TemplateClass , typename... Types>
using	first_n_types_to_template_class_t = typename first_n_types_to_template_class_st< FirstN, TemplateClass, Types... >::type
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using	container_of_tuples_t = typename container_of_tuples_st< ContainerType, ElementTypes... >::type
template<typename... ElementTypes>
using	vector_of_tuples_t = container_of_tuples_t< std::vector, ElementTypes... >
template<typename... ElementTypes>
using	deque_of_tuples_t = container_of_tuples_t< std::deque, ElementTypes... >
template<typename... ElementTypes>
using	list_of_tuples_t = container_of_tuples_t< std::list, ElementTypes... >
template<typename... ElementTypes>
using	set_of_tuples_t = container_of_tuples_t< std::set, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	map_of_tuples_t = container_of_tuples_t< std::map, KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	multimap_of_tuples_t = container_of_tuples_t< std::multimap, KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_map_of_tuples_t = container_of_tuples_t< std::unordered_map, KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_multimap_of_tuples_t = container_of_tuples_t< std::unordered_multimap, KeyType, ElementTypes... >

Functions
template<typename T , typename S >
auto	addition_vaild_fn (T t, S s) -> decltype(t+s)
template<typename T , typename S >
auto	subtraction_vaild_fn (T t, S s) -> decltype(t - s)
template<typename T , typename S >
auto	multiplication_vaild_fn (T t, S s) -> decltype(t *s)
template<typename T , typename S >
auto	division_vaild_fn (T t, S s) -> decltype(t/s)
template<auto Begin, auto End, auto Size>
constexpr auto	compute_span ()
template<typename T , T... Indices, T Begin, T End, T Increment>
constexpr auto	fn_create_sequence_in_order (std::integer_sequence< T, Indices... >, st_workhorse_range< T, Begin, End, Increment >)
template<typename T , T... Indices, T Begin, T End, T Increment>
constexpr auto	fn_create_sequence_reverse_order (std::integer_sequence< T, Indices... >, st_workhorse_range< T, Begin, End, Increment >)
template<typename... ArgTypes>
void	process_arguments (ArgTypes &&...)
template<typename WorkhorseType , auto... Indices>
void	drive_workhorse (WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
template<typename WorkhorseType , auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 > > >	drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
template<typename WorkhorseType , auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_2d_t< 0, 0 > > >	drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
template<typename WorkhorseType , auto... HeightIndices, auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 >, indexer_t< 0 > > >	drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< HeightIndices... >, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
template<typename WorkhorseType , auto... HeightIndices, auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_3d_t< 0, 0, 0 > > >	drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< HeightIndices... >, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
template<typename WorkhorseType , auto... Indices>
std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > > >	run_workhorse (WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
template<typename WorkhorseType , auto... Indices, typename dummy_sequence = sequence_info_t<StackInOrder, typed_sequence_t<1>>>
std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, dummy_sequence > >	run_workhorse (WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
template<typename TupleType , typename WorkhorseType , auto... Indices>
std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > &&std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > > >	run_workhorse (TupleType &&tuple, WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
template<typename TupleType , typename WorkhorseType , auto... Indices>
std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > &&std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, std::tuple_element_t< 0, remove_cvref_t< TupleType > > > >	run_workhorse (TupleType &&tuple, WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
template<auto... Ints, typename FuncType >
auto	for_tuple (FuncType &&f, typed_sequence_t< Ints... >)
template<auto... Ints, typename FuncType >
auto	for_tuple (typed_sequence_t< Ints... >, FuncType &&f)
template<typename T >
constexpr std::enable_if_t< true, typename std::iterator_traits< T >::value_type >	iterator_value_type_fn (T &&)
constexpr no_type_t	iterator_value_type_fn (...)
template<typename Type1 , typename Type2 >
constexpr auto	is_operable_fn (Type1 &&arg1, Type2 &&arg2) noexcept(noexcept(std::declval< remove_cv_ref_t< Type1 > >()) &&noexcept(std::declval< remove_cv_ref_t< Type2 > >())) -> decltype(true ? arg1 :arg2)
constexpr no_type_t	is_operable_fn (...) noexcept
template<typename Type >
constexpr auto	is_empty_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.empty())
constexpr no_type_t	is_empty_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_capacity_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.capacity())
constexpr no_type_t	is_capacity_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_shrink_to_fit_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.shrink_to_fit())
constexpr no_type_t	is_shrink_to_fit_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_size_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.size())
constexpr no_type_t	is_size_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_front_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.front())
constexpr no_type_t	is_front_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_back_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.back())
constexpr no_type_t	is_back_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_begin_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.begin())
constexpr no_type_t	is_begin_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_end_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.end())
constexpr no_type_t	is_end_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_rbegin_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.rbegin())
constexpr no_type_t	is_rbegin_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_rend_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.rend())
constexpr no_type_t	is_rend_available_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_push_front_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.push_front(std::declval< Type >()))
constexpr no_type_t	is_push_front_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_index_operator_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.operator[]((size_t) 1))
constexpr no_type_t	is_index_operator_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_push_back_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.push_back(std::declval< Type >()))
constexpr no_type_t	is_push_back_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_erase_valid_fn (ContainerType< Type, Types... > &&arg) -> decltype(arg.erase(arg.cbegin()))
constexpr no_type_t	is_erase_valid_fn (...)
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_reserve_valid_fn (ContainerType< Type, Types... > &&arg) -> decltype(arg.reserve((size_t) 0))
constexpr no_type_t	is_reserve_valid_fn (...)
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_insert_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.insert(std::declval< Type >()))
constexpr no_type_t	is_insert_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_insert_iterator_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.insert(arg.cend(), std::declval< Type >()))
constexpr no_type_t	is_insert_iterator_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_resize_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.resize(std::declval< size_t >()))
constexpr no_type_t	is_resize_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_emplace_front_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.emplace_front(std::declval< Type >()))
constexpr no_type_t	is_emplace_front_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_emplace_back_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.emplace_back(std::declval< Type >()))
constexpr no_type_t	is_emplace_back_valid_fn (...) noexcept
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto	is_emplace_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.emplace(arg.cbegin(), std::declval< Type >()))
constexpr no_type_t	is_emplace_valid_fn (...) noexcept
template<typename Type >
constexpr auto	is_pop_front_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.pop_front())
constexpr no_type_t	is_pop_front_available_fn (...) noexcept
template<typename Type >
constexpr auto	is_pop_back_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.pop_back())
constexpr no_type_t	is_pop_back_available_fn (...) noexcept
template<typename FuncType , typename... ArgTypes>
auto	safe_apply (FuncType &&f, std::tuple< ArgTypes... > const &args) -> decltype(f(std::declval< ArgTypes >()...))
template<typename FuncType , typename ArgType , std::size_t N, std::size_t... Ints>
auto	array_apply (FuncType &&f, std::array< ArgType, N > const &args, std::index_sequence< Ints... >) -> decltype(f(std::get< Ints >(args)...))
template<typename FuncType , typename ArgType , std::size_t N>
auto	safe_apply (FuncType &&f, std::array< ArgType, N > const &args) -> decltype(array_apply(f, args, std::make_index_sequence< N >{}))
template<typename FuncType , typename TupleType >
auto	fn_apply (FuncType &&f, TupleType &&args) -> decltype(safe_apply(f, args))
template<typename FuncType , typename... ArgTypes>
auto	function_return_type_fn (FuncType &&func, ArgTypes &&... args) -> decltype(func(args...))
template<typename... ArgTypes1, typename... ArgTypes2>
auto	tuple_addition_operator (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b)
template<typename... ArgTypes1, typename... ArgTypes2, auto... Indices>
auto	tuple_addition (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b, types::typed_sequence_t< Indices... >)
template<auto... Ints, typename FuncType >
auto	for_array (FuncType &&f, typed_sequence_t< Ints... >)
template<auto... Ints, typename FuncType >
auto	for_array (typed_sequence_t< Ints... >, FuncType &&f)
template<auto... Ints, typename FuncType >
auto	for_vector (FuncType &&f, typed_sequence_t< Ints... >)
template<auto... Ints, typename FuncType >
auto	for_vector (typed_sequence_t< Ints... >, FuncType &&f)
template<typename ArrayType , typename TupleType , auto... Indices>
auto	set_tuple_to_array (TupleType &&tuple, typed_sequence_t< Indices... >)
template<typename ContainerType , typename TupleType , auto... Indices>
auto	set_tuple_to_container (TupleType &&tuple, typed_sequence_t< Indices... >)
template<typename T , size_t Size, auto... Indices>
auto	set_array_to_tuple (const std::array< T, Size > &array, typed_sequence_t< Indices... >)
template<template< typename, size_t > class ReturnClass, typename TupleType , auto... Indices, typename... ArgTypes>
auto	evaluate_lambdas (typed_sequence_t< Indices... >, TupleType &&tuple, ArgTypes &&... args)
template<template< typename, size_t > class ReturnClass, typename TupleType , auto... Indices, typename ArgTuple >
auto	evaluate_lambdas_tuple (typed_sequence_t< Indices... >, TupleType &&tuple, ArgTuple &&arguments)

Variables
template<typename Type >
constexpr bool	is_tag_type_v = st_is_tag_type_v<Type>::value
template<typename Type >
constexpr bool	is_integer_sequence_v = st_is_integer_sequence<Type>::value
template<typename T >
constexpr bool	is_type_list_v = st_is_type_list<remove_cv_ref_t<T>>::value
template<typename Type >
constexpr bool	is_template_type_v = st_is_template_type<Type>::value
template<typename Type >
constexpr auto	is_variant_v = is_variant_st<Type>::value
template<typename Type >
constexpr auto	is_unique_ptr_v = is_unique_ptr_st<Type>::value
template<typename Type >
constexpr auto	is_pair_v = is_pair_st<Type>::value
template<typename Type >
constexpr auto	is_pair_of_variant_v = is_pair_of_variant_st<Type>::value
template<typename Type >
constexpr auto	is_map_or_unordered_map_v = is_map_or_unordered_map_st<remove_cv_ref_t<Type>>::value
template<typename Type >
constexpr auto	is_set_or_unordered_set_v = is_set_or_unordered_set_st<Type>::value
template<typename Type >
constexpr auto	is_tuple_v = is_tuple_st<Type>::value
template<typename Type >
constexpr auto	is_tuple_empty_v = is_tuple_st<Type>::empty
template<typename Type >
constexpr auto	is_any_v = is_any_st<Type>::value
template<typename Type >
constexpr auto	is_basic_string_v = is_basic_string_st<Type>::value
template<typename Type >
constexpr bool	is_char_v = is_char_st<tpf::remove_cv_ref_t<Type>>::value
template<typename Type >
constexpr auto	tuple_size_v = st_tuple_size<Type>::value
no_type_t	addition_vaild_fn (...)
template<typename T , typename S >
constexpr bool	is_addition_valid_v
no_type_t	subtraction_vaild_fn (...)
template<typename T , typename S >
constexpr bool	is_subtraction_valid_v
no_type_t	multiplication_vaild_fn (...)
template<typename T , typename S >
constexpr bool	is_multiplication_valid_v
no_type_t	division_vaild_fn (...)
template<typename T , typename S >
constexpr bool	is_division_valid_v
template<typename T , typename S >
constexpr bool	is_arithmetic_valid_v
template<typename T >
constexpr auto	sequence_first_element_v = st_sequence_first_element<T>::value
template<typename T >
constexpr auto	sequence_last_element_v = st_sequence_last_element<T>::value
template<auto Nth, typename SequenceType >
constexpr auto	sequence_nth_element_v = st_sequence_nth_element<Nth, SequenceType>::value
template<typename T >
constexpr auto	sequence_element_count_v = st_sequence_element_count<T>::value
template<typename SequenceType >
constexpr auto	sequence_span_v = st_sequence_span<SequenceType>::value
template<typename... Types>
constexpr auto	type_count_v = type_count_st<Types...>::value
template<typename T >
constexpr bool	is_iterator_type_v
template<typename T >
constexpr bool	is_iterator_excluding_pointer_v
template<typename Type >
constexpr auto	is_template_v = is_template_st<Type>::value
template<typename Type >
constexpr auto	template_parameter_count = is_template_st<Type>::count
template<typename Type1 , typename Type2 >
constexpr auto	is_same_template_type_v = is_same_template_type_st<Type1, Type2>::value
template<typename Type1 , typename Type2 >
constexpr auto	is_same_template_v = is_same_template_st<Type1, Type2>::value
template<typename Type >
constexpr auto	is_string_v = is_string_st<remove_cv_ref_t<Type>>::value
template<typename Type1 , typename Type2 >
constexpr auto	is_operable_v
template<typename Type >
constexpr bool	is_empty_available_v
template<typename Type >
constexpr bool	is_capacity_available_v
template<typename Type >
constexpr bool	is_shrink_to_fit_available_v
template<typename Type >
constexpr bool	is_size_available_v
template<typename Type >
constexpr bool	is_front_available_v
template<typename Type >
constexpr bool	is_back_available_v = is_valid_type_v<decltype(is_back_available_fn(std::declval<Type>()))>
template<typename Type >
constexpr bool	is_begin_available_v
template<typename Type >
constexpr bool	is_end_available_v
template<typename Type >
constexpr bool	is_rbegin_available_v
template<typename Type >
constexpr bool	is_rend_available_v
template<typename Type >
constexpr bool	is_push_front_available_v
template<typename Type >
constexpr bool	is_index_operator_available_v
template<typename Type >
constexpr bool	is_push_back_available_v
template<typename Type >
constexpr bool	is_erase_available_v
template<typename Type >
constexpr bool	is_reserve_available_v
template<typename Type >
constexpr bool	is_insert_available_v
template<typename Type >
constexpr bool	is_insert_iterator_available_v
template<typename Type >
constexpr bool	is_resize_available_v
template<typename Type >
constexpr bool	is_emplace_front_available_v
template<typename Type >
constexpr bool	is_emplace_back_available_v
template<typename Type >
constexpr bool	is_emplace_available_v
template<typename Type >
constexpr bool	is_pop_front_available_v
template<typename Type >
constexpr bool	is_pop_back_available_v
template<typename Type >
constexpr bool	is_container_type_v
template<typename Type , typename... Types>
constexpr auto	is_same_v = is_same_st<Type, Types...>::value
template<typename TestType , typename... Types>
constexpr bool	is_in_list_v = is_in_list_st<TestType, Types...>::value
template<typename TypeList , typename... TestTypes>
constexpr auto	are_all_in_list_v = are_all_in_list_st<TypeList, TestTypes...>::value
template<typename Type >
constexpr auto	is_integer_v = is_in_list_v<Type, integer_list_t>
template<typename Type >
constexpr auto	is_unsigned_integer_v = is_in_list_v<Type, unsigned_integer_list_t>
template<typename Type >
constexpr auto	is_signed_integer_v = is_in_list_v<Type, signed_integer_list_t>
template<typename Type >
constexpr auto	is_integral_v = is_in_list_v<Type, integral_list_t>
template<typename Type >
constexpr auto	is_unsigned_integral_v = is_in_list_v<Type, unsigned_integral_list_t>
template<typename Type >
constexpr auto	is_signed_integral_v = is_in_list_v<Type, signed_integral_list_t>
template<typename Type >
constexpr auto	is_real_number_v = is_in_list_v<Type, real_number_list_t>
template<typename Type >
constexpr auto	is_numerical_number_v = is_in_list_v<Type, numerical_number_list_t>
template<typename... Types>
constexpr auto	are_integers_v = are_all_in_list_v<integer_list_t, Types...>
template<typename... Types>
constexpr auto	are_unsigned_integers_v = are_all_in_list_v<unsigned_integer_list_t, Types...>
template<typename... Types>
constexpr auto	are_signed_integers_v = are_all_in_list_v<signed_integer_list_t, Types...>
template<typename... Types>
constexpr auto	are_integrals_v = are_all_in_list_v<integral_list_t, Types...>
template<typename... Types>
constexpr auto	are_unsigned_integrals_v = are_all_in_list_v<unsigned_integral_list_t, Types...>
template<typename... Types>
constexpr auto	are_signed_integrals_v = are_all_in_list_v<signed_integral_list_t, Types...>
template<typename... Types>
constexpr auto	are_real_numbers_v = are_all_in_list_v<real_number_list_t, Types...>
template<typename... Types>
constexpr auto	are_numerical_numbers_v = are_all_in_list_v<numerical_number_list_t, Types...>
template<typename... Types>
constexpr auto	common_type_v = is_valid_type_v<common_type_t<Types...>>
template<typename Type >
constexpr auto	is_reference_wrapper_v
template<typename Type >
constexpr auto	is_template_template_v = is_template_v<first_parameter_type_t<Type>>
template<typename ArgType , typename... Types>
constexpr auto	is_type_in_list_v = is_type_in_list_st<ArgType, Types...>::value
template<typename LeftList , typename RightList >
constexpr auto	is_type_list_equivalent_v = is_type_list_equivalent_st<LeftList, RightList>::value
no_type_t	array_apply (...)
no_type_t	safe_apply (...)
no_type_t	fn_apply (...)
no_type_t	function_return_type_fn (...)
template<typename FuncType , typename... ArgTypes>
constexpr bool	is_callable_v = !is_no_type_v<function_return_type_t<FuncType, ArgTypes...>>
template<typename FuncType , typename... ArgTypes>
constexpr bool	is_void_return_type_v
template<typename TupleType >
constexpr bool	has_tuple_common_type_v = st_has_tuple_common_type<TupleType>::value

Detailed Description

Implementations in this scope is meant NOT to be accessed directly by the client.

Implementation ins this scope is NOT meant to be directly accessed by the client.

Typedef Documentation

append_type_t

template<typename ArgType , typename RightList >

using tpf::types::hidden::append_type_t = typedef typename append_type_st<ArgType, RightList>::type

Definition at line 4678 of file tpf_types.hpp.

arg_to_type_t

template<typename Type >

using tpf::types::hidden::arg_to_type_t = typedef typename st_is_arg_list<Type>::type

Definition at line 6049 of file tpf_types.hpp.

back_type_t

template<typename... Types>

using tpf::types::hidden::back_type_t = typedef select_last_type_t<Types...>

Definition at line 4220 of file tpf_types.hpp.

common_type_t

template<typename... Types>

using tpf::types::hidden::common_type_t = typedef typename st_common_type_solver<Types...>::type

Definition at line 4119 of file tpf_types.hpp.

conditional_iterator_value_type_t

template<typename T >

using tpf::types::hidden::conditional_iterator_value_type_t = typedef typename std::conditional<is_iterator_type_v<T>, iterator_value_type_t<T>, T>::type

Definition at line 3141 of file tpf_types.hpp.

container_map_of_variants_t

template<template< typename, typename... > class ContainerType, typename KeyType , typename... ElementTypes>

using tpf::types::hidden::container_map_of_variants_t = typedef typename container_of_variants_st<ContainerType, KeyType, unique_types_t<ElementTypes...> >::type

Definition at line 6554 of file tpf_types.hpp.

container_of_tuples_t

template<template< typename, typename... > class ContainerType, typename... ElementTypes>

using tpf::types::hidden::container_of_tuples_t = typedef typename container_of_tuples_st<ContainerType, ElementTypes...>::type

Definition at line 6950 of file tpf_types.hpp.

container_of_variants_t

template<template< typename, typename... > class ContainerType, typename... ElementTypes>

using tpf::types::hidden::container_of_variants_t = typedef typename container_of_variants_st<ContainerType, unique_types_t<ElementTypes...> >::type

Definition at line 6549 of file tpf_types.hpp.

deque_of_tuples_t

template<typename... ElementTypes>

using tpf::types::hidden::deque_of_tuples_t = typedef container_of_tuples_t<std::deque, ElementTypes...>

Definition at line 6956 of file tpf_types.hpp.

deque_of_variants_t

template<typename... ElementTypes>

using tpf::types::hidden::deque_of_variants_t = typedef container_of_variants_t<std::deque, ElementTypes...>

Definition at line 6561 of file tpf_types.hpp.

difference_type_t

template<typename LeftList , typename RightList >

using tpf::types::hidden::difference_type_t = typedef typename difference_type_st<LeftList, RightList>::type

Definition at line 4887 of file tpf_types.hpp.

enable_if_all_in_list_t

template<typename TestTypeList , typename TypeList , typename ReturnType = void>

using tpf::types::hidden::enable_if_all_in_list_t = typedef std::enable_if_t<are_all_in_list_v<TypeList, TestTypeList>, ReturnType>

Definition at line 4563 of file tpf_types.hpp.

enable_if_container_type_t

template<typename Type , typename ReturnType = void>

using tpf::types::hidden::enable_if_container_type_t = typedef std::enable_if_t< is_container_type_v<remove_cv_ref_t<Type> >, ReturnType>

Definition at line 3749 of file tpf_types.hpp.

enable_if_in_list_t

template<typename TestType , typename TypeList , typename ReturnType = TestType>

using tpf::types::hidden::enable_if_in_list_t = typedef std::enable_if_t<is_type_in_list_v<TestType, TypeList>, ReturnType>

Definition at line 4560 of file tpf_types.hpp.

enable_if_integer_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_integer_t = typedef std::enable_if_t<is_integer_v<Type>, ReturnType>

Definition at line 3950 of file tpf_types.hpp.

enable_if_integral_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_integral_t = typedef std::enable_if_t<is_integral_v<Type>, ReturnType>

Definition at line 3938 of file tpf_types.hpp.

enable_if_iterator_type_t

template<typename Type , typename ReturnType >

using tpf::types::hidden::enable_if_iterator_type_t = typedef std::enable_if_t<is_iterator_type_v<Type>, ReturnType>

Definition at line 3131 of file tpf_types.hpp.

enable_if_iterator_value_type_t

template<typename T >

using tpf::types::hidden::enable_if_iterator_value_type_t = typedef std::enable_if_t<is_iterator_type_v<T>, iterator_value_type_t<T> >

Definition at line 3136 of file tpf_types.hpp.

enable_if_not_integer_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_not_integer_t = typedef std::enable_if_t<!is_integer_v<Type>, ReturnType>

Definition at line 3954 of file tpf_types.hpp.

enable_if_numerical_number_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_numerical_number_t = typedef std::enable_if_t<is_numerical_number_v<Type>, ReturnType>

Definition at line 3970 of file tpf_types.hpp.

enable_if_real_number_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_real_number_t = typedef std::enable_if_t<is_real_number_v<Type>, ReturnType>

Definition at line 3966 of file tpf_types.hpp.

enable_if_signed_integer_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_signed_integer_t = typedef std::enable_if_t<is_signed_integer_v<Type>, ReturnType>

Definition at line 3958 of file tpf_types.hpp.

enable_if_signed_integral_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_signed_integral_t = typedef std::enable_if_t<is_signed_integral_v<Type>, ReturnType>

Definition at line 3942 of file tpf_types.hpp.

enable_if_unsigned_integer_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_unsigned_integer_t = typedef std::enable_if_t<is_unsigned_integer_v<Type>, ReturnType>

Definition at line 3962 of file tpf_types.hpp.

enable_if_unsigned_integral_t

template<typename Type , typename ReturnType = Type>

using tpf::types::hidden::enable_if_unsigned_integral_t = typedef std::enable_if_t<is_unsigned_integral_v<Type>, ReturnType>

Definition at line 3946 of file tpf_types.hpp.

first_n_types_list_to_template_class_t

template<size_t FirstN, template< typename... > typename TemplateClass, typename... Types>

using tpf::types::hidden::first_n_types_list_to_template_class_t = typedef typename first_n_types_list_to_template_class_st<FirstN, TemplateClass, Types...>::type

Definition at line 6821 of file tpf_types.hpp.

first_n_types_t

template<size_t FirstN, typename... RightTypes>

using tpf::types::hidden::first_n_types_t = typedef typename first_n_types_st<FirstN, type_list_t<>, RightTypes...>::type

Definition at line 4454 of file tpf_types.hpp.

first_n_types_to_template_class_t

template<size_t FirstN, typename TemplateClass , typename... Types>

using tpf::types::hidden::first_n_types_to_template_class_t = typedef typename first_n_types_to_template_class_st<FirstN, TemplateClass, Types...>::type

Definition at line 6857 of file tpf_types.hpp.

first_parameter_type_t

template<typename Type >

using tpf::types::hidden::first_parameter_type_t = typedef first_type_t<template_parameter_type_list_t<Type> >

Definition at line 4286 of file tpf_types.hpp.

first_type_t

template<typename... Types>

using tpf::types::hidden::first_type_t = typedef select_first_type_t<Types...>

Definition at line 4167 of file tpf_types.hpp.

front_type_t

template<typename... Types>

using tpf::types::hidden::front_type_t = typedef select_first_type_t<Types...>

Definition at line 4170 of file tpf_types.hpp.

function_return_type_t

template<typename FuncType , typename... ArgTypes>

using tpf::types::hidden::function_return_type_t = typedef remove_cvref_t<decltype(function_return_type_fn(std::declval<FuncType>(), std::declval<ArgTypes>()...))>

Definition at line 5410 of file tpf_types.hpp.

intersection_type_t

template<typename LeftList , typename RightList >

using tpf::types::hidden::intersection_type_t = typedef typename intersection_type_st<LeftList, RightList>::type

Definition at line 4783 of file tpf_types.hpp.

is_operable_t

template<typename Type1 , typename Type2 >

using tpf::types::hidden::is_operable_t = typedef std::remove_reference_t<decltype(is_operable_fn(std::declval<Type1>(), std::declval<Type2>()))>

Definition at line 3462 of file tpf_types.hpp.

iterator_value_type_t

template<typename T >

using tpf::types::hidden::iterator_value_type_t = typedef decltype(iterator_value_type_fn(std::declval<T>()))

Definition at line 3126 of file tpf_types.hpp.

last_n_types_t

template<size_t LastN, typename... LeftTypes>

using tpf::types::hidden::last_n_types_t = typedef typename last_n_types_st<LastN, LeftTypes...>::type

Definition at line 4523 of file tpf_types.hpp.

last_parameter_type_t

template<typename Type >

using tpf::types::hidden::last_parameter_type_t = typedef last_type_t<template_parameter_type_list_t<Type> >

Definition at line 4292 of file tpf_types.hpp.

last_type_t

template<typename... Types>

using tpf::types::hidden::last_type_t = typedef select_last_type_t<Types...>

Definition at line 4217 of file tpf_types.hpp.

list_of_tuples_t

template<typename... ElementTypes>

using tpf::types::hidden::list_of_tuples_t = typedef container_of_tuples_t<std::list, ElementTypes...>

Definition at line 6959 of file tpf_types.hpp.

list_of_variants_t

template<typename... ElementTypes>

using tpf::types::hidden::list_of_variants_t = typedef container_of_variants_t<std::list, ElementTypes...>

Definition at line 6564 of file tpf_types.hpp.

make_signed_integral_t

template<typename Type >

using tpf::types::hidden::make_signed_integral_t = typedef typename make_signed_integral_st<Type, is_integral_v<Type> >::type

Definition at line 4016 of file tpf_types.hpp.

make_signed_t

template<typename Type >

using tpf::types::hidden::make_signed_t = typedef typename make_signed_st<Type, is_integer_v<Type> >::type

Definition at line 3986 of file tpf_types.hpp.

make_unique_ptr_deleter_wrapper_t

template<typename deleter , typename... ArgTypes>

using tpf::types::hidden::make_unique_ptr_deleter_wrapper_t = typedef typename st_unique_ptr_wrapper_deleter<deleter, ArgTypes...>::type

Definition at line 5208 of file tpf_types.hpp.

make_unique_ptr_wrapper_t

template<typename... ArgTypes>

using tpf::types::hidden::make_unique_ptr_wrapper_t = typedef typename st_unique_ptr_wrapper<ArgTypes...>::type

Definition at line 5194 of file tpf_types.hpp.

make_unsigned_integral_t

template<typename Type >

using tpf::types::hidden::make_unsigned_integral_t = typedef typename make_unsigned_integral_st<Type, is_integral_v<Type> >::type

Definition at line 4031 of file tpf_types.hpp.

make_unsigned_t

template<typename Type >

using tpf::types::hidden::make_unsigned_t = typedef typename make_unsigned_st<Type, is_integer_v<Type> >::type

Definition at line 4001 of file tpf_types.hpp.

map_of_tuples_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::map_of_tuples_t = typedef container_of_tuples_t<std::map, KeyType, ElementTypes...>

Definition at line 6965 of file tpf_types.hpp.

map_of_variants_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::map_of_variants_t = typedef container_map_of_variants_t<std::map, KeyType, ElementTypes...>

Definition at line 6585 of file tpf_types.hpp.

map_or_unordered_map_pair_t

template<typename Type >

using tpf::types::hidden::map_or_unordered_map_pair_t = typedef typename is_map_or_unordered_map_st<remove_cv_ref_t<Type> >::type

Definition at line 1764 of file tpf_types.hpp.

multimap_of_tuples_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::multimap_of_tuples_t = typedef container_of_tuples_t<std::multimap, KeyType, ElementTypes...>

Definition at line 6968 of file tpf_types.hpp.

multimap_of_variants_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::multimap_of_variants_t = typedef container_map_of_variants_t<std::multimap, KeyType, ElementTypes...>

Definition at line 6588 of file tpf_types.hpp.

multiset_of_variants_t

template<typename... ElementTypes>

using tpf::types::hidden::multiset_of_variants_t = typedef container_of_variants_t<std::multiset, ElementTypes...>

Definition at line 6570 of file tpf_types.hpp.

non_class_wrapper_t

template<typename Type , auto Tag>

using tpf::types::hidden::non_class_wrapper_t = typedef typename st_make_non_class_wrapper<Type, Tag, std::is_class_v<Type> >::type

Definition at line 400 of file tpf_types.hpp.

nth_parameter_type_t

template<auto SelectIndex, typename Type >

using tpf::types::hidden::nth_parameter_type_t = typedef nth_type_t<SelectIndex, template_parameter_type_list_t<Type> >

Definition at line 4295 of file tpf_types.hpp.

nth_type_t

template<auto SelectIndex, typename... Types>

using tpf::types::hidden::nth_type_t = typedef select_nth_type_t<SelectIndex, Types...>

Definition at line 4283 of file tpf_types.hpp.

nth_type_to_template_class_t

template<size_t TypeIndex, typename TemplateClass , typename... Types>

using tpf::types::hidden::nth_type_to_template_class_t = typedef typename nth_type_to_template_class_st<TypeIndex, TemplateClass, Types...>::type

Definition at line 6791 of file tpf_types.hpp.

pair_of_variants_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::pair_of_variants_t = typedef container_map_of_variants_t<std::pair, KeyType, ElementTypes...>

Definition at line 6582 of file tpf_types.hpp.

pop_back_type_t

template<typename... Types>

using tpf::types::hidden::pop_back_type_t = typedef typename pop_back_type_wrapper_st<Types...>::type

Definition at line 4389 of file tpf_types.hpp.

pop_front_type_t

template<typename... Types>

using tpf::types::hidden::pop_front_type_t = typedef typename pop_front_wrapper_st<Types...>::type

Definition at line 4355 of file tpf_types.hpp.

prepend_type_t

template<typename ArgType , typename RightList >

using tpf::types::hidden::prepend_type_t = typedef typename prepend_type_st<ArgType, RightList>::type

Definition at line 4660 of file tpf_types.hpp.

push_back_type_t

template<typename ArgType , typename... Types>

using tpf::types::hidden::push_back_type_t = typedef typename push_back_type_st<ArgType, Types...>::type

Definition at line 4325 of file tpf_types.hpp.

push_front_type_t

template<typename ArgType , typename... Types>

using tpf::types::hidden::push_front_type_t = typedef typename push_front_type_st<ArgType, Types...>::type

Definition at line 4310 of file tpf_types.hpp.

remove_type_t

template<typename ArgType , typename... Types>

using tpf::types::hidden::remove_type_t = typedef typename remove_type_wrapper_st<ArgType, Types...>::type

Definition at line 4841 of file tpf_types.hpp.

replace_type_t

template<typename NewType , typename OldType , typename TypeList >

using tpf::types::hidden::replace_type_t = typedef typename replace_type_st<NewType, OldType, TypeList>::type

Definition at line 4933 of file tpf_types.hpp.

return_type_t

template<typename Type >

using tpf::types::hidden::return_type_t = typedef typename return_type_st<Type>::type

Definition at line 2118 of file tpf_types.hpp.

reverse_sequence_t

template<typename SequenceType >

using tpf::types::hidden::reverse_sequence_t = typedef typename st_reverse_sequence<SequenceType>::type

Definition at line 2451 of file tpf_types.hpp.

select_first_n_types_t

template<size_t FirstN, typename... RightTypes>

using tpf::types::hidden::select_first_n_types_t = typedef first_n_types_t<FirstN, RightTypes...>

Definition at line 4457 of file tpf_types.hpp.

select_first_type_t

template<typename... Types>

using tpf::types::hidden::select_first_type_t = typedef typename select_first_type_st<Types...>::type

Definition at line 4164 of file tpf_types.hpp.

select_last_n_types_t

template<size_t LastN, typename... LeftTypes>

using tpf::types::hidden::select_last_n_types_t = typedef last_n_types_t<LastN, LeftTypes...>

Definition at line 4526 of file tpf_types.hpp.

select_last_type_t

template<typename... Types>

using tpf::types::hidden::select_last_type_t = typedef typename select_last_type_st<Types...>::type

Definition at line 4214 of file tpf_types.hpp.

select_nth_type_t

template<auto SelectIndex, typename... Types>

using tpf::types::hidden::select_nth_type_t = typedef typename select_nth_type_st<SelectIndex, Types...>::type

Definition at line 4280 of file tpf_types.hpp.

sequence_element_t

template<typename T >

using tpf::types::hidden::sequence_element_t = typedef typename st_sequence_element_type<T>::type

Definition at line 2466 of file tpf_types.hpp.

sequence_info_t

template<bool StackOrder, typename SequenceType >

using tpf::types::hidden::sequence_info_t = typedef st_sequence_info< sequence_element_t<SequenceType>, sequence_first_element_v<SequenceType>, sequence_last_element_v<SequenceType>, sequence_element_count_v<SequenceType>, StackOrder>

Definition at line 2511 of file tpf_types.hpp.

set_of_tuples_t

template<typename... ElementTypes>

using tpf::types::hidden::set_of_tuples_t = typedef container_of_tuples_t<std::set, ElementTypes...>

Definition at line 6962 of file tpf_types.hpp.

set_of_variants_t

template<typename... ElementTypes>

using tpf::types::hidden::set_of_variants_t = typedef container_of_variants_t<std::set, ElementTypes...>

Definition at line 6567 of file tpf_types.hpp.

template_parameter_type_list_t

template<typename Type >

using tpf::types::hidden::template_parameter_type_list_t = typedef typename is_template_st<Type>::type

Definition at line 3277 of file tpf_types.hpp.

to_recursive_type_list_t

template<typename T >

using tpf::types::hidden::to_recursive_type_list_t = typedef typename st_recursive_type_list<T>::type

Definition at line 1022 of file tpf_types.hpp.

to_tuple_t

template<typename... Types>

using tpf::types::hidden::to_tuple_t = typedef typename to_tuple_st<Types...>::type

Definition at line 4642 of file tpf_types.hpp.

to_variant_t

template<typename Type , typename... Types>

using tpf::types::hidden::to_variant_t = typedef typename to_variant_st<Type, Types...>::type

Definition at line 4621 of file tpf_types.hpp.

tuple_common_element_t

template<typename TupleType >

using tpf::types::hidden::tuple_common_element_t = typedef typename st_has_tuple_common_type<TupleType>::type

Definition at line 5689 of file tpf_types.hpp.

tuple_to_std_array_t

template<typename TupleType >

using tpf::types::hidden::tuple_to_std_array_t = typedef std::array< tuple_common_element_t<TupleType>, tuple_size_v<TupleType> >

Definition at line 5692 of file tpf_types.hpp.

tuple_to_type_list_t

template<typename TupleType >

using tpf::types::hidden::tuple_to_type_list_t = typedef typename st_tuple_to_type_list<TupleType>::type

Definition at line 1150 of file tpf_types.hpp.

type_list_to_template_class_t

template<template< typename... >class ClassTemplate, typename... Types>

using tpf::types::hidden::type_list_to_template_class_t = typedef typename type_list_to_template_class_wrapper_st<ClassTemplate, Types...>::type

Definition at line 6761 of file tpf_types.hpp.

type_list_to_tuple_t

template<typename TypeList >

using tpf::types::hidden::type_list_to_tuple_t = typedef typename st_type_list_to_tuple<TypeList>::type

Definition at line 1162 of file tpf_types.hpp.

types_to_template_class_t

template<typename Type , typename... Types>

using tpf::types::hidden::types_to_template_class_t = typedef typename types_to_template_class_wrapper_st<Type, Types...>::type

Definition at line 6719 of file tpf_types.hpp.

union_type_t

template<typename LeftList , typename RightList >

using tpf::types::hidden::union_type_t = typedef typename union_type_st<LeftList, RightList>::type

Definition at line 4734 of file tpf_types.hpp.

unique_types_t

template<typename... Types>

using tpf::types::hidden::unique_types_t = typedef typename unique_types_st<type_list_t<>, Types...>::type

Definition at line 4598 of file tpf_types.hpp.

unordered_map_of_tuples_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::unordered_map_of_tuples_t = typedef container_of_tuples_t<std::unordered_map, KeyType, ElementTypes...>

Definition at line 6971 of file tpf_types.hpp.

unordered_map_of_variants_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::unordered_map_of_variants_t = typedef container_map_of_variants_t<std::unordered_map, KeyType, ElementTypes...>

Definition at line 6591 of file tpf_types.hpp.

unordered_multimap_of_tuples_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::unordered_multimap_of_tuples_t = typedef container_of_tuples_t<std::unordered_multimap, KeyType, ElementTypes...>

Definition at line 6974 of file tpf_types.hpp.

unordered_multimap_of_variants_t

template<typename KeyType , typename... ElementTypes>

using tpf::types::hidden::unordered_multimap_of_variants_t = typedef container_map_of_variants_t<std::unordered_multimap, KeyType, ElementTypes...>

Definition at line 6594 of file tpf_types.hpp.

unordered_multiset_of_variants_t

template<typename... ElementTypes>

using tpf::types::hidden::unordered_multiset_of_variants_t = typedef container_of_variants_t<std::unordered_multiset, ElementTypes...>

Definition at line 6576 of file tpf_types.hpp.

unordered_set_of_variants_t

template<typename... ElementTypes>

using tpf::types::hidden::unordered_set_of_variants_t = typedef container_of_variants_t<std::unordered_set, ElementTypes...>

Definition at line 6573 of file tpf_types.hpp.

variant_to_type_list_t

template<typename VarType >

using tpf::types::hidden::variant_to_type_list_t = typedef typename st_variant_to_type_list<VarType>::type

Definition at line 1174 of file tpf_types.hpp.

vector_of_tuples_t

template<typename... ElementTypes>

using tpf::types::hidden::vector_of_tuples_t = typedef container_of_tuples_t<std::vector, ElementTypes...>

Definition at line 6953 of file tpf_types.hpp.

vector_of_variants_t

template<typename... ElementTypes>

using tpf::types::hidden::vector_of_variants_t = typedef container_of_variants_t<std::vector, ElementTypes...>

Definition at line 6558 of file tpf_types.hpp.

Function Documentation

addition_vaild_fn()

template<typename T , typename S >

auto tpf::types::hidden::addition_vaild_fn	(	T	t,
		S	s
	)		-> decltype(t+s)

array_apply()

template<typename FuncType , typename ArgType , std::size_t N, std::size_t... Ints>

auto tpf::types::hidden::array_apply	(	FuncType &&	f,
		std::array< ArgType, N > const &	args,
		std::index_sequence< Ints... >
	)		-> decltype(f(std::get< Ints >(args)...))

compute_span()

template<auto Begin, auto End, auto Size>

constexpr auto tpf::types::hidden::compute_span ( )

constexpr

Definition at line 2343 of file tpf_types.hpp.

division_vaild_fn()

template<typename T , typename S >

auto tpf::types::hidden::division_vaild_fn	(	T	t,
		S	s
	)		-> decltype(t/s)

drive_workhorse() [1/5]

template<typename WorkhorseType , auto... HeightIndices, auto... RowIndices, auto... ColumnIndices>

std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 >, indexer_t< 0 > > > tpf::types::hidden::drive_workhorse	(	WorkhorseType &&	cabin,
		typed_sequence_t< HeightIndices... >	,
		typed_sequence_t< RowIndices... >	,
		typed_sequence_t< ColumnIndices... >
	)

Definition at line 2888 of file tpf_types.hpp.

Here is the call graph for this function:

drive_workhorse() [2/5]

template<typename WorkhorseType , auto... HeightIndices, auto... RowIndices, auto... ColumnIndices>

std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_3d_t< 0, 0, 0 > > > tpf::types::hidden::drive_workhorse	(	WorkhorseType &&	cabin,
		typed_sequence_t< HeightIndices... >	,
		typed_sequence_t< RowIndices... >	,
		typed_sequence_t< ColumnIndices... >
	)

Definition at line 2919 of file tpf_types.hpp.

Here is the call graph for this function:

drive_workhorse() [3/5]

template<typename WorkhorseType , auto... RowIndices, auto... ColumnIndices>

std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 > > > tpf::types::hidden::drive_workhorse	(	WorkhorseType &&	cabin,
		typed_sequence_t< RowIndices... >	,
		typed_sequence_t< ColumnIndices... >
	)

Definition at line 2839 of file tpf_types.hpp.

Here is the call graph for this function:

drive_workhorse() [4/5]

template<typename WorkhorseType , auto... RowIndices, auto... ColumnIndices>

std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_2d_t< 0, 0 > > > tpf::types::hidden::drive_workhorse	(	WorkhorseType &&	cabin,
		typed_sequence_t< RowIndices... >	,
		typed_sequence_t< ColumnIndices... >
	)

Definition at line 2865 of file tpf_types.hpp.

Here is the call graph for this function:

drive_workhorse() [5/5]

template<typename WorkhorseType , auto... Indices>

void tpf::types::hidden::drive_workhorse	(	WorkhorseType &&	workhorse,
		typed_sequence_t< Indices... >
	)

Definition at line 2813 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_lambdas()

template<template< typename, size_t > class ReturnClass, typename TupleType , auto... Indices, typename... ArgTypes>

auto tpf::types::hidden::evaluate_lambdas	(	typed_sequence_t< Indices... >	,
		TupleType &&	tuple,
		ArgTypes &&...	args
	)

Definition at line 5946 of file tpf_types.hpp.

evaluate_lambdas_tuple()

template<template< typename, size_t > class ReturnClass, typename TupleType , auto... Indices, typename ArgTuple >

auto tpf::types::hidden::evaluate_lambdas_tuple	(	typed_sequence_t< Indices... >	,
		TupleType &&	tuple,
		ArgTuple &&	arguments
	)

Definition at line 5960 of file tpf_types.hpp.

Here is the call graph for this function:

fn_apply()

template<typename FuncType , typename TupleType >

auto tpf::types::hidden::fn_apply	(	FuncType &&	f,
		TupleType &&	args
	)		-> decltype(safe_apply(f, args))

fn_create_sequence_in_order()

template<typename T , T... Indices, T Begin, T End, T Increment>

constexpr auto tpf::types::hidden::fn_create_sequence_in_order ( std::integer_sequence< T, Indices... >  , st_workhorse_range< T, Begin, End, Increment >    )

constexpr

Definition at line 2554 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

fn_create_sequence_reverse_order()

template<typename T , T... Indices, T Begin, T End, T Increment>

constexpr auto tpf::types::hidden::fn_create_sequence_reverse_order ( std::integer_sequence< T, Indices... >  , st_workhorse_range< T, Begin, End, Increment >    )

constexpr

Definition at line 2588 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

for_array() [1/2]

template<auto... Ints, typename FuncType >

auto tpf::types::hidden::for_array	(	FuncType &&	f,
		typed_sequence_t< Ints... >
	)

Definition at line 5710 of file tpf_types.hpp.

Here is the caller graph for this function:

for_array() [2/2]

template<auto... Ints, typename FuncType >

auto tpf::types::hidden::for_array	(	typed_sequence_t< Ints... >	,
		FuncType &&	f
	)

Definition at line 5719 of file tpf_types.hpp.

for_tuple() [1/2]

template<auto... Ints, typename FuncType >

auto tpf::types::hidden::for_tuple	(	FuncType &&	f,
		typed_sequence_t< Ints... >
	)

Definition at line 3046 of file tpf_types.hpp.

Here is the caller graph for this function:

for_tuple() [2/2]

template<auto... Ints, typename FuncType >

auto tpf::types::hidden::for_tuple	(	typed_sequence_t< Ints... >	,
		FuncType &&	f
	)

Definition at line 3052 of file tpf_types.hpp.

for_vector() [1/2]

template<auto... Ints, typename FuncType >

auto tpf::types::hidden::for_vector	(	FuncType &&	f,
		typed_sequence_t< Ints... >
	)

Definition at line 5748 of file tpf_types.hpp.

Here is the caller graph for this function:

for_vector() [2/2]

template<auto... Ints, typename FuncType >

auto tpf::types::hidden::for_vector	(	typed_sequence_t< Ints... >	,
		FuncType &&	f
	)

Definition at line 5757 of file tpf_types.hpp.

function_return_type_fn()

template<typename FuncType , typename... ArgTypes>

auto tpf::types::hidden::function_return_type_fn	(	FuncType &&	func,
		ArgTypes &&...	args
	)		-> decltype(func(args...))

is_back_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_back_available_fn (   ... )

constexprnoexcept

is_back_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_back_available_fn ( Type &&  arg ) -> decltype(arg.back())

constexprnoexcept

is_begin_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_begin_available_fn (   ... )

constexprnoexcept

is_begin_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_begin_available_fn ( Type &&  arg ) -> decltype(arg.begin())

constexprnoexcept

is_capacity_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_capacity_available_fn (   ... )

constexprnoexcept

is_capacity_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_capacity_available_fn ( Type &&  arg ) -> decltype(arg.capacity())

constexprnoexcept

is_emplace_back_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_emplace_back_valid_fn (   ... )

constexprnoexcept

is_emplace_back_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_emplace_back_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.emplace_back(std::declval< Type >()))

constexprnoexcept

is_emplace_front_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_emplace_front_valid_fn (   ... )

constexprnoexcept

is_emplace_front_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_emplace_front_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.emplace_front(std::declval< Type >()))

constexprnoexcept

is_emplace_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_emplace_valid_fn (   ... )

constexprnoexcept

is_emplace_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_emplace_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.emplace(arg.cbegin(), std::declval< Type >()))

constexprnoexcept

is_empty_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_empty_available_fn (   ... )

constexprnoexcept

is_empty_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_empty_available_fn ( Type &&  arg ) -> decltype(arg.empty())

constexprnoexcept

is_end_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_end_available_fn (   ... )

constexprnoexcept

is_end_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_end_available_fn ( Type &&  arg ) -> decltype(arg.end())

constexprnoexcept

is_erase_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_erase_valid_fn (   ... )

constexpr

is_erase_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_erase_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.erase(arg.cbegin()))

constexpr

is_front_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_front_available_fn (   ... )

constexprnoexcept

is_front_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_front_available_fn ( Type &&  arg ) -> decltype(arg.front())

constexprnoexcept

is_index_operator_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_index_operator_valid_fn (   ... )

constexprnoexcept

is_index_operator_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_index_operator_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.operator[]((size_t) 1))

constexprnoexcept

is_insert_iterator_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_insert_iterator_valid_fn (   ... )

constexprnoexcept

is_insert_iterator_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_insert_iterator_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.insert(arg.cend(), std::declval< Type >()))

constexprnoexcept

is_insert_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_insert_valid_fn (   ... )

constexprnoexcept

is_insert_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_insert_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.insert(std::declval< Type >()))

constexprnoexcept

is_operable_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_operable_fn (   ... )

constexprnoexcept

is_operable_fn() [2/2]

template<typename Type1 , typename Type2 >

constexpr auto tpf::types::hidden::is_operable_fn ( Type1 &&  arg1, Type2 &&  arg2  ) && -> decltype(true ? arg1 :arg2)

constexprnoexcept

is_pop_back_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_pop_back_available_fn (   ... )

constexprnoexcept

is_pop_back_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_pop_back_available_fn ( Type &&  arg ) -> decltype(arg.pop_back())

constexprnoexcept

is_pop_front_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_pop_front_available_fn (   ... )

constexprnoexcept

is_pop_front_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_pop_front_available_fn ( Type &&  arg ) -> decltype(arg.pop_front())

constexprnoexcept

is_push_back_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_push_back_valid_fn (   ... )

constexprnoexcept

is_push_back_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_push_back_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.push_back(std::declval< Type >()))

constexprnoexcept

is_push_front_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_push_front_valid_fn (   ... )

constexprnoexcept

is_push_front_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_push_front_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.push_front(std::declval< Type >()))

constexprnoexcept

is_rbegin_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_rbegin_available_fn (   ... )

constexprnoexcept

is_rbegin_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_rbegin_available_fn ( Type &&  arg ) -> decltype(arg.rbegin())

constexprnoexcept

is_rend_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_rend_available_fn (   ... )

constexprnoexcept

is_rend_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_rend_available_fn ( Type &&  arg ) -> decltype(arg.rend())

constexprnoexcept

is_reserve_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_reserve_valid_fn (   ... )

constexpr

is_reserve_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_reserve_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.reserve((size_t) 0))

constexpr

is_resize_valid_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_resize_valid_fn (   ... )

constexprnoexcept

is_resize_valid_fn() [2/2]

template<template< typename, typename... > class ContainerType, typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_resize_valid_fn ( ContainerType< Type, Types... > &&  arg ) -> decltype(arg.resize(std::declval< size_t >()))

constexprnoexcept

is_shrink_to_fit_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_shrink_to_fit_available_fn (   ... )

constexprnoexcept

is_shrink_to_fit_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_shrink_to_fit_available_fn ( Type &&  arg ) -> decltype(arg.shrink_to_fit())

constexprnoexcept

is_size_available_fn() [1/2]

constexpr no_type_t tpf::types::hidden::is_size_available_fn (   ... )

constexprnoexcept

is_size_available_fn() [2/2]

template<typename Type >

constexpr auto tpf::types::hidden::is_size_available_fn ( Type &&  arg ) -> decltype(arg.size())

constexprnoexcept

iterator_value_type_fn() [1/2]

constexpr no_type_t tpf::types::hidden::iterator_value_type_fn (   ... )

constexpr

iterator_value_type_fn() [2/2]

template<typename T >

constexpr std::enable_if_t< true, typename std::iterator_traits< T >::value_type > tpf::types::hidden::iterator_value_type_fn ( T &&  )

constexpr

multiplication_vaild_fn()

template<typename T , typename S >

auto tpf::types::hidden::multiplication_vaild_fn	(	T	t,
		S	s
	)		-> decltype(t *s)

process_arguments()

template<typename... ArgTypes>

void tpf::types::hidden::process_arguments

(

ArgTypes &&

...

)

Definition at line 2807 of file tpf_types.hpp.

Here is the caller graph for this function:

run_workhorse() [1/4]

template<typename TupleType , typename WorkhorseType , auto... Indices>

std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > && std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > > > tpf::types::hidden::run_workhorse	(	TupleType &&	tuple,
		WorkhorseType &&	workhorse,
		typed_sequence_t< Indices... >
	)

Definition at line 3005 of file tpf_types.hpp.

run_workhorse() [2/4]

template<typename TupleType , typename WorkhorseType , auto... Indices>

std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > && std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, std::tuple_element_t< 0, remove_cvref_t< TupleType > > > > tpf::types::hidden::run_workhorse	(	TupleType &&	tuple,
		WorkhorseType &&	workhorse,
		typed_sequence_t< Indices... >
	)

Definition at line 3014 of file tpf_types.hpp.

run_workhorse() [3/4]

template<typename WorkhorseType , auto... Indices>

std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > > > tpf::types::hidden::run_workhorse	(	WorkhorseType &&	workhorse,
		typed_sequence_t< Indices... >
	)

Definition at line 2988 of file tpf_types.hpp.

Here is the caller graph for this function:

run_workhorse() [4/4]

template<typename WorkhorseType , auto... Indices, typename dummy_sequence = sequence_info_t<StackInOrder, typed_sequence_t<1>>>

std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, dummy_sequence > > tpf::types::hidden::run_workhorse	(	WorkhorseType &&	workhorse,
		typed_sequence_t< Indices... >
	)

Definition at line 2996 of file tpf_types.hpp.

safe_apply() [1/2]

template<typename FuncType , typename ArgType , std::size_t N>

auto tpf::types::hidden::safe_apply	(	FuncType &&	f,
		std::array< ArgType, N > const &	args
	)		-> decltype(array_apply(f, args, std::make_index_sequence< N >{}))

safe_apply() [2/2]

template<typename FuncType , typename... ArgTypes>

auto tpf::types::hidden::safe_apply	(	FuncType &&	f,
		std::tuple< ArgTypes... > const &	args
	)		-> decltype(f(std::declval< ArgTypes >()...))

set_array_to_tuple()

template<typename T , size_t Size, auto... Indices>

auto tpf::types::hidden::set_array_to_tuple	(	const std::array< T, Size > &	array,
		typed_sequence_t< Indices... >
	)

Definition at line 5816 of file tpf_types.hpp.

Here is the caller graph for this function:

set_tuple_to_array()

template<typename ArrayType , typename TupleType , auto... Indices>

auto tpf::types::hidden::set_tuple_to_array	(	TupleType &&	tuple,
		typed_sequence_t< Indices... >
	)

Definition at line 5777 of file tpf_types.hpp.

Here is the call graph for this function:

set_tuple_to_container()

template<typename ContainerType , typename TupleType , auto... Indices>

auto tpf::types::hidden::set_tuple_to_container	(	TupleType &&	tuple,
		typed_sequence_t< Indices... >
	)

Definition at line 5793 of file tpf_types.hpp.

subtraction_vaild_fn()

template<typename T , typename S >

auto tpf::types::hidden::subtraction_vaild_fn	(	T	t,
		S	s
	)		-> decltype(t - s)

tuple_addition()

template<typename... ArgTypes1, typename... ArgTypes2, auto... Indices>

auto tpf::types::hidden::tuple_addition	(	const std::tuple< ArgTypes1... > &	tuple_a,
		const std::tuple< ArgTypes2... > &	tuple_b,
		types::typed_sequence_t< Indices... >
	)

Definition at line 5460 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

tuple_addition_operator()

template<typename... ArgTypes1, typename... ArgTypes2>

auto tpf::types::hidden::tuple_addition_operator	(	const std::tuple< ArgTypes1... > &	tuple_a,
		const std::tuple< ArgTypes2... > &	tuple_b
	)

Definition at line 5482 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

addition_vaild_fn

no_type_t tpf::types::hidden::addition_vaild_fn(...)

(

...

)

are_all_in_list_v

template<typename TypeList , typename... TestTypes>

constexpr auto tpf::types::hidden::are_all_in_list_v = are_all_in_list_st<TypeList, TestTypes...>::value

constexpr

Definition at line 3887 of file tpf_types.hpp.

are_integers_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_integers_v = are_all_in_list_v<integer_list_t, Types...>

constexpr

Definition at line 3914 of file tpf_types.hpp.

are_integrals_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_integrals_v = are_all_in_list_v<integral_list_t, Types...>

constexpr

Definition at line 3923 of file tpf_types.hpp.

are_numerical_numbers_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_numerical_numbers_v = are_all_in_list_v<numerical_number_list_t, Types...>

constexpr

Definition at line 3935 of file tpf_types.hpp.

are_real_numbers_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_real_numbers_v = are_all_in_list_v<real_number_list_t, Types...>

constexpr

Definition at line 3932 of file tpf_types.hpp.

are_signed_integers_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_signed_integers_v = are_all_in_list_v<signed_integer_list_t, Types...>

constexpr

Definition at line 3920 of file tpf_types.hpp.

are_signed_integrals_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_signed_integrals_v = are_all_in_list_v<signed_integral_list_t, Types...>

constexpr

Definition at line 3929 of file tpf_types.hpp.

are_unsigned_integers_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_unsigned_integers_v = are_all_in_list_v<unsigned_integer_list_t, Types...>

constexpr

Definition at line 3917 of file tpf_types.hpp.

are_unsigned_integrals_v

template<typename... Types>

constexpr auto tpf::types::hidden::are_unsigned_integrals_v = are_all_in_list_v<unsigned_integral_list_t, Types...>

constexpr

Definition at line 3926 of file tpf_types.hpp.

array_apply

no_type_t tpf::types::hidden::array_apply(...)

(

...

)

common_type_v

template<typename... Types>

constexpr auto tpf::types::hidden::common_type_v = is_valid_type_v<common_type_t<Types...>>

constexpr

Definition at line 4122 of file tpf_types.hpp.

division_vaild_fn

no_type_t tpf::types::hidden::division_vaild_fn(...)

(

...

)

fn_apply

no_type_t tpf::types::hidden::fn_apply(...)

(

...

)

function_return_type_fn

no_type_t tpf::types::hidden::function_return_type_fn(...)

(

...

)

has_tuple_common_type_v

template<typename TupleType >

constexpr bool tpf::types::hidden::has_tuple_common_type_v = st_has_tuple_common_type<TupleType>::value

constexpr

Definition at line 5686 of file tpf_types.hpp.

is_addition_valid_v

template<typename T , typename S >

constexpr bool tpf::types::hidden::is_addition_valid_v

constexpr

Initial value:

= 
                    !is_no_type_v<decltype(addition_vaild_fn(std::declval<T>(), std::declval<S>()))>

Definition at line 2050 of file tpf_types.hpp.

is_any_v

template<typename Type >

constexpr auto tpf::types::hidden::is_any_v = is_any_st<Type>::value

constexpr

Definition at line 1830 of file tpf_types.hpp.

is_arithmetic_valid_v

template<typename T , typename S >

constexpr bool tpf::types::hidden::is_arithmetic_valid_v

constexpr

Initial value:

= is_addition_valid_v<T, S> && is_subtraction_valid_v<T, S> 
                    && is_multiplication_valid_v<T, S> && is_division_valid_v<T, S>

Definition at line 2078 of file tpf_types.hpp.

is_back_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_back_available_v = is_valid_type_v<decltype(is_back_available_fn(std::declval<Type>()))>

constexpr

Definition at line 3525 of file tpf_types.hpp.

is_basic_string_v

template<typename Type >

constexpr auto tpf::types::hidden::is_basic_string_v = is_basic_string_st<Type>::value

constexpr

Definition at line 1851 of file tpf_types.hpp.

is_begin_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_begin_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_begin_available_fn(std::declval<Type>()))>

Definition at line 3535 of file tpf_types.hpp.

is_callable_v

template<typename FuncType , typename... ArgTypes>

constexpr bool tpf::types::hidden::is_callable_v = !is_no_type_v<function_return_type_t<FuncType, ArgTypes...>>

constexpr

Definition at line 5414 of file tpf_types.hpp.

is_capacity_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_capacity_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_capacity_available_fn(std::declval<Type>()))>

Definition at line 3485 of file tpf_types.hpp.

is_char_v

template<typename Type >

constexpr bool tpf::types::hidden::is_char_v = is_char_st<tpf::remove_cv_ref_t<Type>>::value

constexpr

Definition at line 1872 of file tpf_types.hpp.

is_container_type_v

template<typename Type >

constexpr bool tpf::types::hidden::is_container_type_v

constexpr

Initial value:

= 
                is_empty_available_v<Type> && is_size_available_v<Type> && 
                is_begin_available_v<Type>

Definition at line 3744 of file tpf_types.hpp.

is_division_valid_v

template<typename T , typename S >

constexpr bool tpf::types::hidden::is_division_valid_v

constexpr

Initial value:

= 
                    !is_no_type_v<decltype(division_vaild_fn(std::declval<T>(), std::declval<S>()))>

Definition at line 2074 of file tpf_types.hpp.

is_emplace_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_emplace_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_emplace_valid_fn(std::declval<Type>()))>

Definition at line 3716 of file tpf_types.hpp.

is_emplace_back_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_emplace_back_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_emplace_back_valid_fn(std::declval<Type>()))>

Definition at line 3703 of file tpf_types.hpp.

is_emplace_front_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_emplace_front_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_emplace_front_valid_fn(std::declval<Type>()))>

Definition at line 3691 of file tpf_types.hpp.

is_empty_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_empty_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_empty_available_fn(std::declval<Type>()))>

Definition at line 3475 of file tpf_types.hpp.

is_end_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_end_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_end_available_fn(std::declval<Type>()))>

Definition at line 3546 of file tpf_types.hpp.

is_erase_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_erase_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_erase_valid_fn(std::declval<Type>()))>

Definition at line 3617 of file tpf_types.hpp.

is_front_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_front_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_front_available_fn(std::declval<Type>()))>

Definition at line 3515 of file tpf_types.hpp.

is_in_list_v

template<typename TestType , typename... Types>

constexpr bool tpf::types::hidden::is_in_list_v = is_in_list_st<TestType, Types...>::value

constexpr

Definition at line 3841 of file tpf_types.hpp.

is_index_operator_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_index_operator_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_index_operator_valid_fn(std::declval<Type>()))>

Definition at line 3592 of file tpf_types.hpp.

is_insert_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_insert_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_insert_valid_fn(std::declval<tpf::remove_cv_ref_t<Type>>()))>

Definition at line 3642 of file tpf_types.hpp.

is_insert_iterator_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_insert_iterator_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_insert_iterator_valid_fn(std::declval<tpf::remove_cv_ref_t<Type>>()))>

Definition at line 3667 of file tpf_types.hpp.

is_integer_sequence_v

template<typename Type >

constexpr bool tpf::types::hidden::is_integer_sequence_v = st_is_integer_sequence<Type>::value

constexpr

Definition at line 992 of file tpf_types.hpp.

is_integer_v

template<typename Type >

constexpr auto tpf::types::hidden::is_integer_v = is_in_list_v<Type, integer_list_t>

constexpr

Definition at line 3890 of file tpf_types.hpp.

is_integral_v

template<typename Type >

constexpr auto tpf::types::hidden::is_integral_v = is_in_list_v<Type, integral_list_t>

constexpr

Definition at line 3899 of file tpf_types.hpp.

is_iterator_excluding_pointer_v

template<typename T >

constexpr bool tpf::types::hidden::is_iterator_excluding_pointer_v

constexpr

Initial value:

= 
                is_iterator_type_v<T> && !std::is_pointer_v<T>

Definition at line 3120 of file tpf_types.hpp.

is_iterator_type_v

template<typename T >

constexpr bool tpf::types::hidden::is_iterator_type_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(iterator_value_type_fn(std::declval<T>()))>

Definition at line 3116 of file tpf_types.hpp.

is_map_or_unordered_map_v

template<typename Type >

constexpr auto tpf::types::hidden::is_map_or_unordered_map_v = is_map_or_unordered_map_st<remove_cv_ref_t<Type>>::value

constexpr

Definition at line 1761 of file tpf_types.hpp.

is_multiplication_valid_v

template<typename T , typename S >

constexpr bool tpf::types::hidden::is_multiplication_valid_v

constexpr

Initial value:

= 
                    !is_no_type_v<decltype(multiplication_vaild_fn(std::declval<T>(), std::declval<S>()))>

Definition at line 2066 of file tpf_types.hpp.

is_numerical_number_v

template<typename Type >

constexpr auto tpf::types::hidden::is_numerical_number_v = is_in_list_v<Type, numerical_number_list_t>

constexpr

Definition at line 3911 of file tpf_types.hpp.

is_operable_v

template<typename Type1 , typename Type2 >

constexpr auto tpf::types::hidden::is_operable_v

constexpr

Initial value:

= 
                is_valid_type_v<is_operable_t<Type1, Type2>>

Definition at line 3465 of file tpf_types.hpp.

is_pair_of_variant_v

template<typename Type >

constexpr auto tpf::types::hidden::is_pair_of_variant_v = is_pair_of_variant_st<Type>::value

constexpr

Definition at line 1736 of file tpf_types.hpp.

is_pair_v

template<typename Type >

constexpr auto tpf::types::hidden::is_pair_v = is_pair_st<Type>::value

constexpr

Definition at line 1720 of file tpf_types.hpp.

is_pop_back_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_pop_back_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_pop_back_available_fn(std::declval<Type>()))>

Definition at line 3738 of file tpf_types.hpp.

is_pop_front_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_pop_front_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_pop_front_available_fn(std::declval<Type>()))>

Definition at line 3728 of file tpf_types.hpp.

is_push_back_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_push_back_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_push_back_valid_fn(std::declval<Type>()))>

Definition at line 3604 of file tpf_types.hpp.

is_push_front_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_push_front_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_push_front_valid_fn(std::declval<Type>()))>

Definition at line 3580 of file tpf_types.hpp.

is_rbegin_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_rbegin_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_rbegin_available_fn(std::declval<Type>()))>

Definition at line 3557 of file tpf_types.hpp.

is_real_number_v

template<typename Type >

constexpr auto tpf::types::hidden::is_real_number_v = is_in_list_v<Type, real_number_list_t>

constexpr

Definition at line 3908 of file tpf_types.hpp.

is_reference_wrapper_v

template<typename Type >

constexpr auto tpf::types::hidden::is_reference_wrapper_v

constexpr

Initial value:

= 
                is_reference_wrapper_st<remove_cv_ref_t<Type>>::value

Definition at line 4276 of file tpf_types.hpp.

is_rend_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_rend_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_rend_available_fn(std::declval<Type>()))>

Definition at line 3568 of file tpf_types.hpp.

is_reserve_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_reserve_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_reserve_valid_fn(std::declval<Type>()))>

Definition at line 3630 of file tpf_types.hpp.

is_resize_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_resize_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_resize_valid_fn(std::declval<Type>()))>

Definition at line 3679 of file tpf_types.hpp.

is_same_template_type_v

template<typename Type1 , typename Type2 >

constexpr auto tpf::types::hidden::is_same_template_type_v = is_same_template_type_st<Type1, Type2>::value

constexpr

Definition at line 3323 of file tpf_types.hpp.

is_same_template_v

template<typename Type1 , typename Type2 >

constexpr auto tpf::types::hidden::is_same_template_v = is_same_template_st<Type1, Type2>::value

constexpr

Definition at line 3375 of file tpf_types.hpp.

is_same_v

template<typename Type , typename... Types>

constexpr auto tpf::types::hidden::is_same_v = is_same_st<Type, Types...>::value

constexpr

Definition at line 3793 of file tpf_types.hpp.

is_set_or_unordered_set_v

template<typename Type >

constexpr auto tpf::types::hidden::is_set_or_unordered_set_v = is_set_or_unordered_set_st<Type>::value

constexpr

Definition at line 1788 of file tpf_types.hpp.

is_shrink_to_fit_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_shrink_to_fit_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_shrink_to_fit_available_fn(std::declval<Type>()))>

Definition at line 3495 of file tpf_types.hpp.

is_signed_integer_v

template<typename Type >

constexpr auto tpf::types::hidden::is_signed_integer_v = is_in_list_v<Type, signed_integer_list_t>

constexpr

Definition at line 3896 of file tpf_types.hpp.

is_signed_integral_v

template<typename Type >

constexpr auto tpf::types::hidden::is_signed_integral_v = is_in_list_v<Type, signed_integral_list_t>

constexpr

Definition at line 3905 of file tpf_types.hpp.

is_size_available_v

template<typename Type >

constexpr bool tpf::types::hidden::is_size_available_v

constexpr

Initial value:

= 
                is_valid_type_v<decltype(is_size_available_fn(std::declval<Type>()))>

Definition at line 3505 of file tpf_types.hpp.

is_string_v

template<typename Type >

constexpr auto tpf::types::hidden::is_string_v = is_string_st<remove_cv_ref_t<Type>>::value

constexpr

Definition at line 3432 of file tpf_types.hpp.

is_subtraction_valid_v

template<typename T , typename S >

constexpr bool tpf::types::hidden::is_subtraction_valid_v

constexpr

Initial value:

= 
                    !is_no_type_v<decltype(subtraction_vaild_fn(std::declval<T>(), std::declval<S>()))>

Definition at line 2058 of file tpf_types.hpp.

is_tag_type_v

template<typename Type >

constexpr bool tpf::types::hidden::is_tag_type_v = st_is_tag_type_v<Type>::value

constexpr

Definition at line 347 of file tpf_types.hpp.

is_template_template_v

template<typename Type >

constexpr auto tpf::types::hidden::is_template_template_v = is_template_v<first_parameter_type_t<Type>>

constexpr

Definition at line 4289 of file tpf_types.hpp.

is_template_type_v

template<typename Type >

constexpr bool tpf::types::hidden::is_template_type_v = st_is_template_type<Type>::value

constexpr

Definition at line 1113 of file tpf_types.hpp.

is_template_v

template<typename Type >

constexpr auto tpf::types::hidden::is_template_v = is_template_st<Type>::value

constexpr

Definition at line 3271 of file tpf_types.hpp.

is_tuple_empty_v

template<typename Type >

constexpr auto tpf::types::hidden::is_tuple_empty_v = is_tuple_st<Type>::empty

constexpr

Definition at line 1815 of file tpf_types.hpp.

is_tuple_v

template<typename Type >

constexpr auto tpf::types::hidden::is_tuple_v = is_tuple_st<Type>::value

constexpr

Definition at line 1812 of file tpf_types.hpp.

is_type_in_list_v

template<typename ArgType , typename... Types>

constexpr auto tpf::types::hidden::is_type_in_list_v = is_type_in_list_st<ArgType, Types...>::value

constexpr

Definition at line 4557 of file tpf_types.hpp.

is_type_list_equivalent_v

template<typename LeftList , typename RightList >

constexpr auto tpf::types::hidden::is_type_list_equivalent_v = is_type_list_equivalent_st<LeftList, RightList>::value

constexpr

Definition at line 4969 of file tpf_types.hpp.

is_type_list_v

template<typename T >

constexpr bool tpf::types::hidden::is_type_list_v = st_is_type_list<remove_cv_ref_t<T>>::value

constexpr

Definition at line 1007 of file tpf_types.hpp.

is_unique_ptr_v

template<typename Type >

constexpr auto tpf::types::hidden::is_unique_ptr_v = is_unique_ptr_st<Type>::value

constexpr

Definition at line 1705 of file tpf_types.hpp.

is_unsigned_integer_v

template<typename Type >

constexpr auto tpf::types::hidden::is_unsigned_integer_v = is_in_list_v<Type, unsigned_integer_list_t>

constexpr

Definition at line 3893 of file tpf_types.hpp.

is_unsigned_integral_v

template<typename Type >

constexpr auto tpf::types::hidden::is_unsigned_integral_v = is_in_list_v<Type, unsigned_integral_list_t>

constexpr

Definition at line 3902 of file tpf_types.hpp.

is_variant_v

template<typename Type >

constexpr auto tpf::types::hidden::is_variant_v = is_variant_st<Type>::value

constexpr

Definition at line 1690 of file tpf_types.hpp.

is_void_return_type_v

template<typename FuncType , typename... ArgTypes>

constexpr bool tpf::types::hidden::is_void_return_type_v

constexpr

Initial value:

= is_callable_v<FuncType, ArgTypes...>
                && std::is_void_v<function_return_type_t<FuncType, ArgTypes...>>

Definition at line 5417 of file tpf_types.hpp.

multiplication_vaild_fn

no_type_t tpf::types::hidden::multiplication_vaild_fn(...)

(

...

)

safe_apply

no_type_t tpf::types::hidden::safe_apply(...)

(

...

)

sequence_element_count_v

template<typename T >

constexpr auto tpf::types::hidden::sequence_element_count_v = st_sequence_element_count<T>::value

constexpr

Definition at line 2420 of file tpf_types.hpp.

sequence_first_element_v

template<typename T >

constexpr auto tpf::types::hidden::sequence_first_element_v = st_sequence_first_element<T>::value

constexpr

Definition at line 2369 of file tpf_types.hpp.

sequence_last_element_v

template<typename T >

constexpr auto tpf::types::hidden::sequence_last_element_v = st_sequence_last_element<T>::value

constexpr

Definition at line 2387 of file tpf_types.hpp.

sequence_nth_element_v

template<auto Nth, typename SequenceType >

constexpr auto tpf::types::hidden::sequence_nth_element_v = st_sequence_nth_element<Nth, SequenceType>::value

constexpr

Definition at line 2405 of file tpf_types.hpp.

sequence_span_v

template<typename SequenceType >

constexpr auto tpf::types::hidden::sequence_span_v = st_sequence_span<SequenceType>::value

constexpr

Definition at line 2483 of file tpf_types.hpp.

subtraction_vaild_fn

no_type_t tpf::types::hidden::subtraction_vaild_fn(...)

(

...

)

template_parameter_count

template<typename Type >

constexpr auto tpf::types::hidden::template_parameter_count = is_template_st<Type>::count

constexpr

Definition at line 3274 of file tpf_types.hpp.

tuple_size_v

template<typename Type >

constexpr auto tpf::types::hidden::tuple_size_v = st_tuple_size<Type>::value

constexpr

Definition at line 1913 of file tpf_types.hpp.

type_count_v

template<typename... Types>

constexpr auto tpf::types::hidden::type_count_v = type_count_st<Types...>::value

constexpr

Definition at line 3099 of file tpf_types.hpp.