tpf::types Namespace Reference

Type to string name conversions are defined. More...

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

Classes
class	any
struct	any_visitors
struct	array_wrapper_t
struct	compile_time_loop
struct	concate_type_st
struct	concate_type_st< Type >
struct	concate_type_st< Type, type_list_t< Head2, Tails2... > >
struct	concate_type_st< Type, Types... >
struct	concate_type_st< type_list_t< Head, Tails... >, Types... >
struct	concate_type_st< type_list_t< Type > >
struct	concate_type_st< type_list_t< Type, Types... > >
struct	concate_type_st< type_list_t< Types1... >, type_list_t< Types2... > >
struct	concate_type_st< type_list_t<> >
struct	concate_type_st<>
struct	indexer_2d_type
struct	indexer_3d_type
struct	indexer_type
struct	is_pair_of_variant_type_st
struct	is_pair_of_variant_type_st< std::pair< KeyType, std::variant< Types... > > >
struct	is_pair_of_variant_type_st< std::pair< Type, std::variant< Types... > > >
struct	is_pair_type_st
struct	is_pair_type_st< std::pair< Type_1, Type_2 > >
struct	is_variant_type_st
struct	is_variant_type_st< std::variant< Types... > >
struct	no_type_t
	This type is used to test validity of a type. More...
struct	numbers_t
struct	overloaded
struct	range
class	reverse_st
class	reverse_st< ElementType(&)[ElementCount]>
struct	st_process_any
struct	st_process_any< type_list_t< Type, Types... > >
struct	static_loop_struct
class	tag_type
struct	type_list_t
	This type is used to manipulate type list. More...
struct	type_opr_over_set_st
struct	type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, Head, type_list_t< ListHead, ListTails... > >
struct	type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, type_list_t< ListHead, ListTails... > >
struct	type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, type_list_t< ListHead, ListTails... >, Head, Tails... >
struct	type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, type_list_t< ListHead, ListTails... >, type_list_t< Head, Tails... > >
struct	type_over_set_st
struct	type_over_set_st< boolean::And, boolean::Left, Type, BinaryPredicate, ListHead >
struct	type_over_set_st< boolean::And, boolean::Left, Type, BinaryPredicate, ListHead, ListTails... >
struct	type_over_set_st< boolean::And, boolean::Right, Type, BinaryPredicate, ListHead >
struct	type_over_set_st< boolean::And, boolean::Right, Type, BinaryPredicate, ListHead, ListTails... >
struct	type_over_set_st< boolean::And, LeftRight, Type, BinaryPredicate, ListHead, ListTails... >
struct	type_over_set_st< boolean::Or, boolean::Left, Type, BinaryPredicate, ListHead >
struct	type_over_set_st< boolean::Or, boolean::Left, Type, BinaryPredicate, ListHead, ListTails... >
struct	type_over_set_st< boolean::Or, boolean::Right, Type, BinaryPredicate, ListHead >
struct	type_over_set_st< boolean::Or, boolean::Right, Type, BinaryPredicate, ListHead, ListTails... >
struct	type_over_set_st< boolean::Or, LeftRight, Type, BinaryPredicate, ListHead, ListTails... >
struct	unique_ptr_wrapper
struct	variant_visitors
struct	void_type_t

Typedefs
template<typename Type , typename ReturnType = void>
using	enable_if_pair_t = std::enable_if_t< is_pair_type_v< Type >, ReturnType >
template<typename Type , typename ReturnType = void>
using	enable_if_pair_of_variant_t = std::enable_if_t< is_pair_of_variant_type_v< Type >, ReturnType >
template<typename Type , typename ReturnType = void>
using	enable_if_variant_t = std::enable_if_t< is_variant_type_v< Type >, ReturnType >
template<auto N, typename TypeAny >
using	any_element_t = select_nth_type_t< N, typename TypeAny::element_types_t >
using	big_integer_t = long long
using	big_unsigned_t = unsigned long long
template<auto Id, auto... Ids>
using	index_t = std::index_sequence<(std::size_t) Id,(std::size_t) Ids... >
template<auto N>
using	make_index_t = std::make_index_sequence<(std::size_t) N >
template<typename ... Types>
using	index_for = std::make_index_sequence< sizeof...(Types)>
template<typename Type >
using	remove_cvref_t = remove_cv_ref_t< Type >
template<typename Type , auto Tag>
using	non_class_wrapper_t = hidden::non_class_wrapper_t< Type, Tag >
template<typename Type , auto Size>
using	create_tuple_t = decltype(types::convert_to_tuple(std::array< Type, Size >{}))
template<typename T >
using	to_recursive_type_list_t = hidden::to_recursive_type_list_t< remove_cv_ref_t< T > >
template<typename... Types>
using	remove_cv_ref_type_list_t = type_list_t< tpf::remove_cv_ref_t< Types >... >
	Create type_list_t by removing const, volatile, reference. More...
template<typename... Types>
using	decay_remove_cv_ref_type_list_t = type_list_t< tpf::decay_remove_cv_ref_t< Types >... >
	Create type_list_t by decaying and removing const, volatile, reference. More...
template<typename... Types>
using	decay_remove_ref_type_list_t = type_list_t< tpf::decay_remove_ref_t< Types >... >
	Create type_list_t by decaying and removing reference. More...
template<typename TupleType >
using	tuple_to_type_list_t = hidden::tuple_to_type_list_t< remove_cvref_t< TupleType > >
template<typename TypeList >
using	type_list_to_tuple_t = hidden::type_list_to_tuple_t< remove_cvref_t< TypeList > >
template<typename VarType >
using	variant_to_type_list_t = hidden::variant_to_type_list_t< remove_cvref_t< VarType > >
template<typename... Types>
using	tuple_of_vectors_t = typename hidden::st_type_list_to_tuple_of_vectors< Types... >::type
template<std::size_t N>
using	index_tuple_vector_t = typename hidden::st_index_tuple_vector< std::make_index_sequence< N > >::type
template<typename Type >
using	map_or_unordered_map_pair_t = hidden::map_or_unordered_map_pair_t< Type >
using	no_throw_t = no_type_t
using	invalid_t = no_type_t
template<typename Type >
using	return_type_t = hidden::return_type_t< Type >
template<typename Type >
using	std_array_element_t = typename hidden::st_std_array_element< remove_cv_ref_t< Type > >::type
template<auto Index>
using	indexer_t = indexer_type< remove_cvref_t< decltype(Index)>, Index >
template<auto RowValue, auto ColumnValue>
using	indexer_2d_t = indexer_2d_type< remove_cvref_t< decltype(RowValue)>, RowValue, ColumnValue >
template<auto HeightValue, auto RowValue, auto ColumnValue>
using	indexer_3d_t = indexer_3d_type< remove_cvref_t< decltype(RowValue)>, HeightValue, RowValue, ColumnValue >
template<auto... Indices>
using	typed_sequence_t = std::integer_sequence< std::common_type_t< remove_cvref_t< decltype(Indices)>... >, Indices... >
template<auto Size>
using	make_typed_sequence_t = std::make_integer_sequence< remove_cvref_t< decltype(Size)>, Size >
template<typename SequenceType >
using	reverse_sequence_t = hidden::reverse_sequence_t< remove_cvref_t< SequenceType > >
template<typename SequenceType >
using	sequence_element_t = hidden::sequence_element_t< remove_cvref_t< SequenceType > >
template<bool StackOrder, typename SequenceType >
using	sequence_info_t = typename hidden::sequence_info_t< StackOrder, remove_cvref_t< SequenceType > >
template<bool SequenceInOrder, auto... RangeValues>
using	make_sequence_t = typename hidden::st_create_workhorse_range< SequenceInOrder, RangeValues... >::type
template<typename Type , typename ReturnType >
using	enable_if_iterator_type_t = hidden::enable_if_iterator_type_t< remove_cv_ref_t< Type >, ReturnType >
using	character_list_t = type_list_t< char, unsigned char, wchar_t >
	Type list of character types. More...
using	integer_list_t = type_list_t< short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long >
	Type list of integers EXCLUSING character type and boolean type. More...
using	signed_integer_list_t = type_list_t< short, int, long, long long >
	Signed integers EXCLUDING char and boolean. More...
using	unsigned_integer_list_t = type_list_t< unsigned short, unsigned int, unsigned long, unsigned long long >
	Unsigned integers EXCLUDING unsigned char and boolean. More...
using	integral_list_t = type_list_t< char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long >
	Type list of integral type INCLUDING character type, but EXCLUDING boolean type. More...
using	unsigned_integral_list_t = type_list_t< unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long >
	Type list of unsigned integral type INCLUDING character type, but EXCLUDING boolean type. More...
using	signed_integral_list_t = type_list_t< char, short, int, long int, long long int >
	Type list of signed integral type INCLUDING character type, but EXCLUDING boolean type. More...
using	real_number_list_t = type_list_t< float, double, long double >
	Type list of real numbers (floating-point numbers). More...
using	numerical_number_list_t = type_list_t< char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, float, double, long double >
	All numbers mathematical operations. More...
using	arithmetic_number_list_t = type_list_t< char, short, int, long, long long, float, double, long double >
	Arithmetic numbers for mathematical analysis. More...
using	floating_point_list_t = real_number_list_t
	The same to real_number_list_t, real numbers. More...
template<typename Type >
using	template_parameter_type_list_t = hidden::template_parameter_type_list_t< Type >
template<typename Type , typename... Types>
using	flat_type_list_t = tpf::types::type_list_t< decay_remove_cv_ref_t< Type >, decay_remove_cv_ref_t< Types >... >
template<typename ReturnType , typename Type , typename... Types>
using	enable_if_same_t = std::enable_if_t< is_same_v< Type, Types... >, ReturnType >
template<typename ReturnType , typename... Types>
using	enable_if_all_the_same_t = std::enable_if_t< is_same_v< Types... >, ReturnType >
template<typename ReturnType , typename Type , typename... Types>
using	enable_if_same_flat_t = std::enable_if_t< is_same_flat_v< Type, Types... >, ReturnType >
template<typename ReturnType , typename... Types>
using	enable_if_all_the_same_flat_t = std::enable_if_t< is_same_flat_v< Types... >, ReturnType >
template<typename Type , typename... Types>
using	void_if_same_t = std::enable_if_t< is_same_v< Type, Types... > >
template<typename... Types>
using	void_if_all_the_same_t = std::enable_if_t< is_same_v< Types... > >
template<typename Type , typename... Types>
using	void_if_same_flat_t = std::enable_if_t< is_same_flat_v< Type, Types... > >
template<typename... Types>
using	void_if_all_the_same_flat_t = std::enable_if_t< is_same_flat_v< Types... > >
template<typename Type , typename ReturnType = Type>
using	enable_if_integral_t = hidden::enable_if_integral_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_signed_integral_t = hidden::enable_if_signed_integral_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_unsigned_integral_t = hidden::enable_if_unsigned_integral_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_integer_t = hidden::enable_if_integer_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_not_integer_t = hidden::enable_if_not_integer_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_signed_integer_t = hidden::enable_if_signed_integer_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_unsigned_integer_t = hidden::enable_if_unsigned_integer_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_real_number_t = hidden::enable_if_real_number_t< Type, ReturnType >
template<typename Type , typename ReturnType = Type>
using	enable_if_numerical_number_t = hidden::enable_if_numerical_number_t< Type, ReturnType >
template<typename Type >
using	make_unsigned_t = hidden::make_unsigned_t< Type >
template<typename Type >
using	make_signed_t = hidden::make_signed_t< Type >
template<typename Type >
using	make_unsigned_integral_t = hidden::make_unsigned_integral_t< Type >
template<typename Type >
using	make_signed_integral_t = hidden::make_signed_integral_t< Type >
template<typename... Types>
using	common_type_t = hidden::common_type_t< Types... >
template<typename... Types>
using	make_common_unsigned_t = make_unsigned_t< common_type_t< Types... > >
template<typename... Types>
using	common_unsigned_t = make_unsigned_t< common_type_t< Types... > >
template<typename... Types>
using	make_common_signed_t = make_signed_t< common_type_t< Types... > >
template<typename... Types>
using	common_signed_t = make_signed_t< common_type_t< Types... > >
template<typename ReturnType , typename... ArgTypes>
using	enable_if_common_exisits_t = std::enable_if_t< common_type_v< remove_cvref_t< ArgTypes >... >, ReturnType >
template<typename... ArgTypes>
using	void_if_common_exisits_t = std::enable_if_t< common_type_v< remove_cvref_t< ArgTypes >... > >
template<typename FuncType , typename TupleType >
using	apply_return_t = decltype(hidden::fn_apply(std::declval< FuncType >(), std::declval< TupleType >()))
template<typename FuncType , typename... TupleTypes>
using	common_apply_t = std::common_type_t< apply_return_t< FuncType, TupleTypes >... >
template<typename ReturnType , typename FuncType , typename... TupleTypes>
using	enable_if_all_apply_t = std::enable_if_t< all_apply_v< FuncType, TupleTypes... >, ReturnType >
template<typename FuncType , typename... TupleTypes>
using	apply_return_tuple_t = std::tuple< apply_return_t< FuncType, TupleTypes > ... >
template<typename FuncType , typename... TupleTypes>
using	apply_return_array_t = std::array< std::common_type_t< apply_return_t< FuncType, TupleTypes >... >, sizeof...(TupleTypes)>
template<typename FuncType , typename... TupleTypes>
using	apply_return_vector_t = std::vector< std::common_type_t< apply_return_t< FuncType, TupleTypes >... > >
template<typename FuncType , typename... TupleTypes>
using	void_if_all_apply_t = enable_if_all_apply_t< void, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	tuple_if_all_apply_t = enable_if_all_apply_t< apply_return_tuple_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	array_if_all_apply_t = enable_if_all_apply_t< apply_return_array_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	vector_if_all_apply_t = enable_if_all_apply_t< apply_return_vector_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	common_type_if_all_apply_t = std::enable_if_t< common_apply_v< FuncType, TupleTypes... >, std::common_type_t< apply_return_t< FuncType, TupleTypes >... > >
template<typename FuncType , typename... ArgTypes>
using	function_return_type_t = hidden::function_return_type_t< FuncType, ArgTypes... >
template<typename T , typename... Types>
using	enable_pairwise_common_type_t = std::enable_if_t< pairwise_common_type_v< T, Types... > >
template<typename T , typename S >
using	tuple_common_type_t = typename hidden::st_tuple_common_type< remove_cvref_t< T >, remove_cvref_t< S > >::type
template<typename T , typename S >
using	tuple_operation_valid_t = std::enable_if_t< tuple_common_type_v< T, S >, tuple_common_type_t< T, S > >
template<typename Type , typename ReturnType = void>
using	enable_if_container_type_t = hidden::enable_if_container_type_t< Type, ReturnType >
template<typename... Types>
using	select_first_type_t = hidden::select_first_type_t< Types... >
template<typename... Types>
using	first_type_t = hidden::first_type_t< Types... >
template<typename... Types>
using	front_type_t = hidden::front_type_t< Types... >
template<typename... Types>
using	select_last_type_t = hidden::select_last_type_t< Types... >
template<typename... Types>
using	last_type_t = hidden::last_type_t< Types... >
template<typename... Types>
using	back_type_t = hidden::back_type_t< Types... >
template<auto SelectIndex, typename... Types>
using	select_nth_type_t = hidden::select_nth_type_t< SelectIndex, Types... >
template<auto SelectIndex, typename... Types>
using	nth_type_t = hidden::nth_type_t< SelectIndex, Types... >
template<typename Type >
using	first_parameter_type_t = hidden::first_parameter_type_t< Type >
template<typename Type >
using	last_parameter_type_t = hidden::last_type_t< Type >
template<auto SelectIndex, typename Type >
using	nth_parameter_type_t = hidden::nth_type_t< SelectIndex, Type >
template<typename ArgType , typename... Types>
using	push_front_type_t = hidden::push_front_type_t< ArgType, Types... >
template<typename ArgType , typename... Types>
using	push_back_type_t = hidden::push_back_type_t< ArgType, Types... >
template<typename... Types>
using	pop_front_type_t = hidden::pop_front_type_t< Types... >
template<typename... Types>
using	pop_back_type_t = hidden::pop_back_type_t< Types... >
template<size_t FirstN, typename... Types>
using	first_n_types_t = hidden::first_n_types_t< FirstN, Types... >
template<size_t FirstN, typename... Types>
using	select_first_n_types_t = hidden::select_first_n_types_t< FirstN, Types... >
template<size_t LastN, typename... Types>
using	last_n_types_t = hidden::last_n_types_t< LastN, Types... >
template<size_t LastN, typename... Types>
using	select_last_n_types_t = hidden::select_last_n_types_t< LastN, Types... >
template<typename... Types>
using	unique_types_t = hidden::unique_types_t< Types... >
template<typename Type , typename... Types>
using	to_variant_t = hidden::to_variant_t< Type, Types... >
template<typename TupleType >
using	tuple_to_variant_t = hidden::to_variant_t< TupleType >
template<template< typename, typename... > class Container, typename TupleType >
using	tuple_to_container_of_variants_t = Container< types::to_variant_t< remove_cvref_t< TupleType > > >
template<typename... Types>
using	to_tuple_t = hidden::to_tuple_t< Types... >
template<typename VarType >
using	variant_to_tuple_t = hidden::to_tuple_t< VarType >
template<typename ArgType , typename RightList >
using	prepend_type_t = hidden::prepend_type_t< ArgType, RightList >
template<typename ArgType , typename RightList >
using	append_type_t = hidden::append_type_t< ArgType, RightList >
template<typename LeftList , typename RightList >
using	union_type_t = hidden::union_type_t< unique_types_t< LeftList >, unique_types_t< RightList > >
template<typename LeftList , typename RightList >
using	intersection_type_t = hidden::intersection_type_t< unique_types_t< LeftList >, unique_types_t< RightList > >
template<typename ArgType , typename... Types>
using	remove_type_t = hidden::remove_type_t< ArgType, Types... >
template<typename LeftList , typename RightList >
using	difference_type_t = hidden::difference_type_t< LeftList, RightList >
template<typename NewType , typename OldType , typename TypeList >
using	replace_type_t = hidden::replace_type_t< NewType, OldType, TypeList >
template<typename TupleType >
using	tuple_common_element_t = hidden::tuple_common_element_t< remove_cvref_t< TupleType > >
template<typename TupleType >
using	tuple_to_std_array_t = hidden::tuple_to_std_array_t< remove_cvref_t< TupleType > >
template<typename... Types>
using	arg_to_type_list_t = typename hidden::st_arg_to_type_list< Types... >::type
template<typename Heads , typename Tails >
using	arg_list_t = typename hidden::st_build_arg_types< Heads, Tails >::type
template<typename CallbackType , typename... Types>
using	callable_list_t = typename hidden::st_is_callable< CallbackType, type_list_t<>, type_list_t<>, Types... >::callables
template<typename CallbackType , typename... Types>
using	non_callable_list_t = typename hidden::st_is_callable< CallbackType, type_list_t<>, type_list_t<>, Types... >::non_callables
template<typename... Types>
using	concate_type_t = typename concate_type_st< Types... >::type
template<typename TestType , typename TypeList , typename ReturnType = TestType>
using	enable_if_in_list_t = hidden::enable_if_in_list_t< TestType, TypeList, ReturnType >
template<typename TestTypeList , typename TypeList , typename ReturnType = void>
using	enable_if_all_in_list_t = hidden::enable_if_all_in_list_t< TestTypeList, TypeList, ReturnType >
template<typename Type1 , typename Type2 , typename common_t = common_type_t<Type1, Type2>, bool is_integral_type = is_integral_v<common_t>, typename result_type = std::conditional_t< is_integral_type, make_signed_t<common_t>, common_t>>
using	signed_common_t = result_type
template<typename Type1 , typename Type2 , typename common_t = common_type_t<Type1, Type2>, bool is_integral_type = is_integral_v<common_t>, typename result_type = std::conditional_t< is_integral_type, make_unsigned_t<common_t>, common_t>>
using	unsigned_common_t = result_type
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using	container_of_variants_t = hidden::container_of_variants_t< ContainerType, ElementTypes... >
template<typename... ElementTypes>
using	vector_of_variants_t = hidden::vector_of_variants_t< ElementTypes... >
template<typename... ElementTypes>
using	deque_of_variants_t = hidden::deque_of_variants_t< ElementTypes... >
template<typename... ElementTypes>
using	list_of_variants_t = hidden::list_of_variants_t< ElementTypes... >
template<typename... ElementTypes>
using	set_of_variants_t = hidden::set_of_variants_t< ElementTypes... >
template<typename... ElementTypes>
using	multiset_of_variants_t = hidden::multiset_of_variants_t< ElementTypes... >
template<typename... ElementTypes>
using	unordered_set_of_variants_t = hidden::unordered_set_of_variants_t< ElementTypes... >
template<typename... ElementTypes>
using	unordered_multiset_of_variants_t = hidden::unordered_multiset_of_variants_t< ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	map_of_variants_t = hidden::map_of_variants_t< KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	multimap_of_variants_t = hidden::multimap_of_variants_t< KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_map_of_variants_t = hidden::unordered_map_of_variants_t< KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_multimap_of_variants_t = hidden::unordered_multimap_of_variants_t< KeyType, ElementTypes... >
template<typename Type , typename... Types>
using	types_to_template_class_t = hidden::types_to_template_class_t< Type, Types... >
template<template< typename... > class ClassTemplate, typename... Types>
using	type_list_to_template_class_t = hidden::type_list_to_template_class_t< ClassTemplate, Types... >
template<size_t SelectTypeIndex, typename TemplateClass , typename... Types>
using	nth_type_to_template_class_t = hidden::nth_type_to_template_class_t< SelectTypeIndex, TemplateClass, Types... >
template<size_t FirstN, typename TemplateClass , typename... Types>
using	first_n_types_to_template_class_t = hidden::first_n_types_to_template_class_t< FirstN, TemplateClass, Types... >
template<size_t FirstN, template< typename... > typename TemplateClass, typename... Types>
using	first_n_types_list_to_template_class_t = hidden::first_n_types_list_to_template_class_t< FirstN, TemplateClass, Types... >
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using	container_of_tuples_t = hidden::container_of_tuples_t< ContainerType, ElementTypes... >
template<typename... ElementTypes>
using	vector_of_tuples_t = hidden::vector_of_tuples_t< ElementTypes... >
template<typename... ElementTypes>
using	deque_of_tuples_t = hidden::deque_of_tuples_t< ElementTypes... >
template<typename... ElementTypes>
using	list_of_tuples_t = hidden::list_of_tuples_t< ElementTypes... >
template<typename... ElementTypes>
using	set_of_tuples_t = hidden::set_of_tuples_t< ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	map_of_tuples_t = hidden::map_of_tuples_t< KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	multimap_of_tuples_t = hidden::multimap_of_tuples_t< KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_map_of_tuples_t = hidden::unordered_map_of_tuples_t< KeyType, ElementTypes... >
template<typename KeyType , typename... ElementTypes>
using	unordered_multimap_of_tuples_t = hidden::unordered_multimap_of_tuples_t< KeyType, ElementTypes... >

Enumerations
enum class	TemplateCategory {   Unknown , NonTemplate = Unknown , Type , Type_Value ,   Value , Value_Type }

Functions
template<typename VisitorType , typename VariantType >
enable_if_variant_t< VariantType >	visit (VisitorType &&visitor, VariantType &&vt)
template<typename VisitorType , typename PairType >
enable_if_pair_of_variant_t< PairType >	visit (VisitorType &&visitor, PairType &&pair)
template<typename... VisitorTypes>
	overloaded (VisitorTypes...) -> overloaded< VisitorTypes... >
template<typename... VisitorTypes>
overloaded< remove_cv_ref_t< VisitorTypes >... >	make_overloads (VisitorTypes &&... visitors)
template<typename VisitorType , typename VariantType >
void	visit (VisitorType &&visitor, VariantType &&vt)
template<typename VisitorType , typename PairType >
enable_if_pair_t< PairType >	visit (VisitorType &&visitor, PairType &&pair)
template<typename... VisitorTypes>
overloaded< remove_cv_ref_t< VisitorTypes >... >	make_overloaded (VisitorTypes &&... visitors)
template<typename... CallbackTypes>
	any_visitors (CallbackTypes...) -> any_visitors< CallbackTypes... >
template<typename Type , typename... Types>
any< Type, Types... >	variant_to_any (const std::variant< Type, Types... > &var)
template<typename Type , typename... Types>
std::any	variant_to_std_any (const std::variant< Type, Types... > &var)
template<typename... ElementTypes>
std::string	current_type (const any< ElementTypes... > &a)
template<typename Visitors , typename AnyType , typename... ArgTypes>
void	visit_any (Visitors &&visitors, AnyType &&a, ArgTypes &&... args)
template<typename CurrentType , typename AnyType , typename Handler , typename = std::enable_if<std::is_same_v<remove_cv_ref_t<AnyType>, std::any>>>
void	if_any_type (AnyType &&a, Handler &&handler)
template<std::size_t KeyIndex, typename Type , auto Index, auto... Indices>
constexpr auto	get_nth_value (std::integer_sequence< Type, Index, Indices... >) noexcept
template<typename Type >
decltype(auto)	get_value (Type &&arg)
template<class TargetType , class _Ty >
constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, _Ty && >	smart_forward (std::remove_reference_t< _Ty > &_Arg) noexcept
template<class TargetType , class _Ty >
constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType >	smart_forward (std::remove_reference_t< _Ty > &_Arg) noexcept
template<class TargetType , class _Ty >
constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, _Ty && >	smart_forward (std::remove_reference_t< _Ty > &&_Arg) noexcept
template<class TargetType , class _Ty >
constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType >	smart_forward (std::remove_reference_t< _Ty > &&_Arg) noexcept
template<class TargetType , class _Ty >
constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, std::remove_reference_t< _Ty > && >	smart_move (_Ty &&_Arg) noexcept
template<class TargetType , class _Ty >
constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType >	smart_move (_Ty &&_Arg) noexcept
template<auto N, typename T , typename Deleter >
auto &	cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N, typename T , typename Deleter >
auto &	cast_ref (std::index_sequence< N >, std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N, typename T , typename Deleter >
auto &	cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N, typename T , typename Deleter >
auto &	cast_ref (std::index_sequence< N >, std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N1, auto N2, typename T , typename Deleter >
auto &	cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N1, auto N2, typename T , typename Deleter >
auto &	cast_ref (std::index_sequence< N1, N2 >, std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N1, auto N2, typename T , typename Deleter >
auto &	cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N1, auto N2, typename T , typename Deleter >
auto &	cast_ref (std::index_sequence< N1, N2 >, std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto &	cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto &	cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N1, auto N2, typename T , auto N, typename = std::enable_if_t<N1* N2 == N>>
auto &	cast_ref (T(&array)[N]) noexcept
template<auto N1, auto N2, typename T , auto N, typename = std::enable_if_t<N1* N2 == N>>
auto &	cast_ref (std::index_sequence< N1, N2 >, T(&array)[N]) noexcept
template<auto N1, auto N2, typename T , auto N = N1 * N2>
auto &	cast_ref (T(&array)[N1][N2]) noexcept
template<auto N1, auto N2, typename T , auto N = N1 * N2>
auto &	cast_ref (std::index_sequence< N1, N2 >, T(&array)[N1][N2]) noexcept
template<auto N1, auto N2, auto N3, typename T , auto N, typename = std::enable_if_t<N1* N2* N3 == N>>
auto &	cast_ref (T(&array)[N]) noexcept
template<auto N1, auto N2, auto N3, typename T , auto N, typename = std::enable_if_t<N1* N2* N3 == N>>
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, T(&array)[N]) noexcept
template<auto N1, auto N2, auto N3, typename T , auto N = N1 * N2* N3>
auto &	cast_ref (T(&array)[N1][N2][N3]) noexcept
template<auto N1, auto N2, auto N3, typename T , auto N = N1 * N2* N3>
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, T(&array)[N1][N2][N3]) noexcept
template<auto N, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cast_ref (T array) noexcept
template<auto N1, auto N2, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cast_ref (T array) noexcept
template<auto N1, auto N2, auto N3, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cast_ref (T array) noexcept
template<auto N, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cast_ref (std::index_sequence< N >, T array) noexcept
template<auto N1, auto N2, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cast_ref (std::index_sequence< N1, N2 >, T array) noexcept
template<auto N1, auto N2, auto N3, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, T array) noexcept
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t<N1 == N>>
auto &	cast_ref (std::array< T, N > &array) noexcept
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t<N1 == N>>
auto &	cast_ref (std::array< T, N > const &array) noexcept
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto &	cast_ref (std::array< T, N > &array) noexcept
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto &	cast_ref (std::array< T, N > const &array) noexcept
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t< N1 == N>>
auto &	cast_ref (std::index_sequence< N1 >, std::array< T, N > &array) noexcept
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t< N1 == N>>
auto &	cast_ref (std::index_sequence< N1 >, std::array< T, N > const &array) noexcept
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto &	cast_ref (std::index_sequence< N1, N2 >, std::array< T, N > &array) noexcept
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto &	cast_ref (std::index_sequence< N1, N2 >, std::array< T, N > const &array) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto &	cast_ref (std::array< T, N > &array) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto &	cast_ref (std::array< T, N > const &array) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, std::array< T, N > &array) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, std::array< T, N > const &array) noexcept
template<std::size_t N, typename T >
auto &	cast_ref (std::vector< T > &vctr) noexcept
template<std::size_t N, typename T >
auto &	cast_ref (std::vector< T > const &vctr) noexcept
template<std::size_t N, typename T >
auto &	cast_ref (std::index_sequence< N >, std::vector< T > &vctr) noexcept
template<std::size_t N, typename T >
auto &	cast_ref (std::index_sequence< N >, std::vector< T > const &vctr) noexcept
template<std::size_t N1, std::size_t N2, typename T >
auto &	cast_ref (std::vector< T > &vctr) noexcept
template<std::size_t N1, std::size_t N2, typename T >
auto &	cast_ref (std::vector< T > const &vctr) noexcept
template<std::size_t N1, std::size_t N2, typename T >
auto &	cast_ref (std::index_sequence< N1, N2 >, std::vector< T > &vctr) noexcept
template<std::size_t N1, std::size_t N2, typename T >
auto &	cast_ref (std::index_sequence< N1, N2 >, std::vector< T > const &vctr) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto &	cast_ref (std::vector< T > &vctr) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto &	cast_ref (std::vector< T > const &vctr) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, std::vector< T > &vctr) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto &	cast_ref (std::index_sequence< N1, N2, N3 >, std::vector< T > const &vctr) noexcept
template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t<N1* N2 == N>>
auto	cast_array (T(&array)[N]) noexcept
template<size_t N1, size_t N2, typename T , size_t N = N1 * N2>
auto	cast_array (T(&array)[N1][N2]) noexcept
template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t<N1* N2* N3 == N>>
auto	cast_array (T(&array)[N]) noexcept
template<size_t N1, size_t N2, size_t N3, typename T , size_t N = N1 * N2* N3>
auto	cast_array (T(&array)[N1][N2][N3]) noexcept
template<typename T , size_t N>
auto	cast_array (std::array< T, N > &array) noexcept
template<typename T , size_t N>
auto	cast_array (std::array< T, N > const &array) noexcept
template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto	cast_array (std::array< T, N > &array) noexcept
template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto	cast_array (std::array< T, N > const &array) noexcept
template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto	cast_array (std::array< T, N > &array) noexcept
template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto	cast_array (std::array< T, N > const &array) noexcept
template<auto Index, typename... ArgTypes, typename = std::enable_if_t<(Index < sizeof...(ArgTypes))>>
decltype(auto)	get_nth_argument (ArgTypes &&... args)
template<typename T , size_t Size>
auto	convert_to_tuple (const std::array< T, Size > &array)
template<template< typename... > class TemplateType>
constexpr auto	template_category ()
template<typename >
constexpr auto	template_category (...)
template<typename ElementType , size_t ElementCount>
	array_wrapper_t (ElementType(&)[ElementCount]) -> array_wrapper_t< ElementType *, size_t >
template<typename ElementType , size_t ElementSize>
auto	array_wrapper (ElementType(&array)[ElementSize]) noexcept
template<typename Type >
auto	to_ref (const Type &value)
template<typename ElementType , size_t ElementSize>
constexpr size_t	array_size (ElementType(&array)[ElementSize]) noexcept
template<typename ContainerType >
auto	reverse (ContainerType &&container)
template<typename ElementType , size_t ElementCount>
auto	reverse (ElementType(&array)[ElementCount])
template<typename Type , typename... Types>
auto	reverse (Type &&arg, Types &&... args)
template<typename Type , typename... Types>
auto	make_vector (Type &&arg, Types &&... args)
template<typename Type , typename... Types>
auto	make_container (Type &&arg, Types &&... args)
template<template< typename, std::size_t > class ContainerType, typename ArgType , typename... ArgTypes>
auto	make_container (ArgType &&arg, ArgTypes &&... args)
template<typename ContainerType , typename IndexType >
decltype(auto)	get_element (ContainerType container, IndexType index)
template<typename Type , typename... Types>
auto	make_variants (Type &&arg, Types &&... args)
template<typename Type >
decltype(auto)	decay (Type &&arg)
template<typename Type >
std::string	type_to_string ()
	Returns Type's string name. More...
template<typename Type >
std::ostream &	operator<< (std::ostream &os, range< Type > const &r)
template<typename Type >
	range (Type) -> range< Type >
template<typename Type >
	range (Type, Type) -> range< Type >
template<typename CharType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, const no_type_t &)
template<typename CharType >
std::basic_ostream< CharType > &	operator>> (std::basic_ostream< CharType > &os, const no_type_t &)
constexpr no_type_t	operator+ (no_type_t, no_type_t) noexcept
constexpr no_type_t	operator- (no_type_t, no_type_t) noexcept
constexpr no_type_t	operator* (no_type_t, no_type_t) noexcept
constexpr no_type_t	operator/ (no_type_t, no_type_t) noexcept
constexpr bool	operator== (no_type_t, no_type_t) noexcept
constexpr bool	operator!= (no_type_t, no_type_t) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, bool >	operator== (no_type_t, T &&) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, bool >	operator!= (T &&, no_type_t) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator+ (no_type_t, T &&) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator+ (T &&, no_type_t) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator- (no_type_t, T &&) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator- (T &&, no_type_t) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator* (no_type_t, T &&) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator* (T &&, no_type_t) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator/ (no_type_t, T &&) noexcept
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t >	operator/ (T &&, no_type_t) noexcept
template<auto N, typename T , T Id, T... Ids>
constexpr T	fn_seq_element (std::integer_sequence< T, Id, Ids... >)
template<typename T , T Id, T... Ids>
auto	seq_to_array (std::integer_sequence< T, Id, Ids... >)
template<typename IdType , typename IntType , std::size_t N>
std::array< IntType, N >	seq_indices (IdType i, std::array< IntType, N > const &powers)
bool	is_stack_reversed ()
bool	is_stack_in_order ()
bool	is_parameter_stack_order_reversed ()
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto)	array_indexer (ArrayType &&array)
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto)	array_indexer_row_column (ArrayType &&array)
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto)	array_writer (ArrayType &&array)
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto)	array_writer_row_column (ArrayType &&array)
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto)	array_reader (ArrayType &&array)
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto)	array_reader_row_column (ArrayType &&array)
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto)	tuple_reader (TupleType &&tuple)
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto)	tuple_reader_row_column (TupleType &&tuple)
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto)	tuple_writer (TupleType &&tuple)
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto)	tuple_writer_row_column (TupleType &&tuple)
template<size_t Count, typename WorkhorseType >
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 > > >	drive_workhorse (WorkhorseType &&workhorse)
template<auto RowCount, auto ColumnCount, typename WorkhorseType >
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 > >||std::is_invocable_v< WorkhorseType, indexer_2d_t< 0, 0 > > >	drive_workhorse (WorkhorseType &&workhorse)
template<auto HeightCount, auto RowCount, auto ColumnCount, typename WorkhorseType >
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_3d_t< 0, 0, 0 > >||std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 >, indexer_t< 0 > > >	drive_workhorse (WorkhorseType &&workhorse)
template<auto... RangeValues, typename WorkhorseType , typename dummy_sequence = make_sequence_t<StackInOrder, 1>, typename sequence_info = sequence_info_t<true, dummy_sequence>>
std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > >||std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, sequence_info > >	for_workhorse (WorkhorseType &&workhorse)
template<typename TupleType , typename WorkhorseType , typename dummy_sequence = make_sequence_t<StackInOrder, 1>, typename sequence_info = sequence_info_t<true, dummy_sequence>>
std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > &&(std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > >||std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, sequence_info >)>	for_workhorse (TupleType &&tuple, WorkhorseType &&workhorse)
template<auto... RangeValues, typename FuncType >
auto	for_tuple (FuncType &&f)
template<typename... Types>
auto	reverse_tuple (std::tuple< Types... > const &tuple)
template<typename... Types>
type_list_t< Types... >	type_to_string (Types &&... args)
template<typename FuncType , typename... ArgTypes>
types::tuple_if_all_apply_t< FuncType, ArgTypes... >	apply_tuple (FuncType &&f, ArgTypes &&... args)
template<typename FuncType , typename... ArgTypes>
types::vector_if_all_apply_t< FuncType, ArgTypes... >	apply_vector (FuncType &&f, ArgTypes &&... args)
template<typename FuncType , typename... ArgTypes>
types::array_if_all_apply_t< FuncType, ArgTypes... >	apply_array (FuncType &&f, ArgTypes &&... args)
template<auto... RangeValues, typename FuncType >
auto	for_array (FuncType &&f)
template<typename Type , std::size_t N>
auto	reverse_array (std::array< Type, N > const &array)
template<auto... RangeValues, typename FuncType >
auto	for_vector (FuncType &&f)
template<typename Type , typename... Types, auto Size = sizeof...(Types) + 1, typename common_type = std::common_type_t<Type, Types...>, typename array_type = std::array<common_type, Size>>
auto	convert_to_array (const std::tuple< Type, Types... > &tuple)
template<template< typename, typename... >class ContainerType, typename Type , typename... Types, auto Size = sizeof...(Types) + 1, typename common_type = std::common_type_t<Type, Types...>, typename container_type = ContainerType<common_type>>
auto	convert_to_container (const std::tuple< Type, Types... > &tuple)
template<typename ContainerType , typename Type , typename... Types, auto Size = sizeof...(Types) + 1>
auto	convert_to_container (const std::tuple< Type, Types... > &tuple)
template<template< typename, typename... >class ContainerType, typename Type , typename... Types, size_t Size, typename container_type = ContainerType<Type, Types...>>
auto	convert_to_container (const std::array< Type, Size > &array)
template<int ArgumentIndex, typename FuncType , typename ArgType , typename... ArgTypes, typename = std::enable_if_t< (ArgumentIndex < sizeof...(ArgTypes) + 1) >>
auto	freeze_parameter (FuncType &&func, ArgType arg, ArgTypes... args)
template<int ArgumentIndex, typename FuncType , typename ArgType , typename... ArgTypes, typename = std::enable_if_t< (ArgumentIndex < sizeof...(ArgTypes) + 1) >>
auto	freeze_parameter (FuncType &&func, const std::tuple< ArgType, ArgTypes... > &arguments)
template<int FuncIndex, int ArgumentIndex, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes, typename = std::enable_if_t< ( FuncIndex < (sizeof...(FuncTypes) + 1) ) && (ArgumentIndex < sizeof...(ArgTypes) + 1 )>>
auto	freeze_parameter (const std::tuple< FuncType, FuncTypes... > &func_tuple, ArgFirst arg, ArgTypes... args)
template<int FuncIndex, int ArgumentIndex, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes, typename = std::enable_if_t< ( FuncIndex < sizeof...(FuncTypes) + 1 ) && (ArgumentIndex < sizeof...(ArgTypes)+1)>>
auto	freeze_parameter (const std::tuple< FuncType, FuncTypes... > &func_tuple, const std::tuple< ArgFirst, ArgTypes... > &arguments)
template<template< typename, size_t > class ReturnClass, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes>
auto	evaluate_lambdas (const std::tuple< FuncType, FuncTypes... > &tuple, ArgFirst &&arg, ArgTypes &&... args)
template<template< typename, size_t > class ReturnClass, typename FuncType , typename... FuncTypes, typename ArgFirst >
auto	evaluate_lambdas (const std::tuple< FuncType, FuncTypes... > &tuple, ArgFirst &&arg)
template<template< typename, typename... > class ContainerType, typename EleType , typename... Types>
auto	erase (ContainerType< EleType, Types... > &container, size_t index)
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
auto	pop_front (ContainerType< Type, Types... > &container)
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
auto	pop_back (ContainerType< Type, Types... > &container)
template<template< typename, typename... > class ContainerType, typename EleType , typename Type , typename... Types>
void	push_front (ContainerType< Type, Types... > &container, EleType &&ele)
template<template< typename, typename... > class ContainerType, typename EleType , typename Type , typename... Types>
void	push_back (ContainerType< Type, Types... > &container, EleType &&ele)
template<template< typename, typename... > class ContainerType, typename... EleTypes, typename Type , typename... Types>
void	emplace_front (ContainerType< Type, Types... > &container, EleTypes &&... eles)
template<template< typename, typename... > class ContainerType, typename... EleTypes, typename Type , typename... Types>
void	emplace_back (ContainerType< Type, Types... > &container, EleTypes &&... eles)
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
ContainerType< Type, Types... >	reverse_order (const ContainerType< Type, Types... > &container)
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
void	reverse_order_in_place (ContainerType< Type, Types... > &container)
template<bool bReverseOrder, typename TargetContainerType , typename SourceContainerType >
void	append_to_container (TargetContainerType &target_container, SourceContainerType &&source_container)
template<bool bReverseOrder, typename TargetContainerType , typename SourceContainerType >
void	prepend_to_container (TargetContainerType &target_container, SourceContainerType &&source_container)
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
auto	make_random_access_container (Type &&arg, Types &&... args)
template<typename Type , typename... Types>
auto	make_deque (Type &&arg, Types &&... args)
template<typename ArgType , typename... ArgTypes>
auto	make_container (ArgType &&arg, ArgTypes &&... args)
	create either tuple or vector More...
template<typename ArgType , typename... ArgTypes>
auto	create_container (ArgType &&arg, ArgTypes &&... args)
	Create a container object. More...
template<typename VisitorType , typename PairType >
std::enable_if_t< is_pair_of_variant_v< remove_cv_ref_t< PairType > > >	visit_variant (VisitorType &&visit, PairType &&vpr)
template<typename VisitorType , typename VariantType >
std::enable_if_t< is_variant_v< remove_cv_ref_t< VariantType > > >	visit_variant (VisitorType &&visit, VariantType &&vt)
template<typename VisitorType , typename IteratorType , typename PairType >
std::enable_if_t< is_pair_of_variant_v< remove_cv_ref_t< PairType > > >	visit_variant (VisitorType &&visit, IteratorType &&itr, PairType &&vpr)
template<typename VisitorType , typename IteratorType , typename VariantType >
std::enable_if_t< is_variant_v< remove_cv_ref_t< VariantType > > >	visit_variant (VisitorType &&visit, IteratorType &&itr, VariantType &&vt)
template<typename... CallbackTypes>
	variant_visitors (CallbackTypes...) -> variant_visitors< CallbackTypes... >
template<typename... CallbackTypes>
variant_visitors< remove_cv_ref_t< CallbackTypes >... >	make_variant_visitors (CallbackTypes &&... visitors)

Variables
template<typename Type >
constexpr bool	is_pair_type_v = is_pair_type_st<remove_cv_ref_t<Type>>::value
template<typename Type >
constexpr bool	is_pair_of_variant_type_v = is_pair_of_variant_type_st<remove_cv_ref_t<Type>>::value
template<typename Type >
constexpr bool	is_variant_type_v = is_variant_type_st<remove_cv_ref_t<Type>>::value
template<typename T >
constexpr bool	is_constrained_any_v = hidden::st_is_constrained_any<T>::value
template<typename T >
constexpr bool	is_special_type_v = is_constrained_any_v<T> || is_variant_v<T> || types::is_tuple_v<T>
template<typename Type >
constexpr auto	type_max_v = std::numeric_limits<Type>::max()
constexpr size_t	InvalidIndex = type_max_v<size_t>
constexpr size_t	SelectAll = InvalidIndex
template<typename Type >
constexpr bool	is_tag_type_v = hidden::is_tag_type_v<remove_cvref_t<Type>>
template<typename Type >
constexpr bool	is_numbers_type_v = hidden::st_is_numbers_type_v<remove_cvref_t<Type>>::value
template<typename Type >
constexpr bool	is_vector_v = hidden::st_is_vector_v<remove_cvref_t<Type>>::value
template<typename Type >
constexpr bool	is_integer_sequence_v = hidden::is_integer_sequence_v<remove_cvref_t<Type>>
template<typename T >
constexpr bool	is_type_list_v = hidden::is_type_list_v<remove_cv_ref_t<T>>
template<typename Type >
constexpr bool	is_template_type_v = hidden::is_template_type_v<remove_cvref_t<Type>>
template<typename Type >
constexpr bool	is_array_v = std::is_array_v<remove_cv_ref_t<Type>>
template<auto FuncType, typename... ArgTypes>
constexpr auto	is_noexcept_v = noexcept(FuncType(std::declval<ArgTypes>()...))
	Test if a function is specified with the keyword noexcept. More...
template<typename Type >
constexpr bool	is_char_v = hidden::is_char_v<Type>
template<typename Type >
constexpr auto	is_variant_v = hidden::is_variant_v<Type>
template<typename Type >
constexpr auto	is_unique_ptr_v = hidden::is_variant_v<Type>
template<typename Type >
constexpr auto	is_pair_v = hidden::is_pair_v<Type>
template<typename Type >
constexpr auto	is_pair_of_variant_v = hidden::is_pair_of_variant_v<Type>
template<typename Type >
constexpr auto	is_tuple_v = hidden::is_tuple_v<remove_cvref_t<Type>>
template<typename Type >
constexpr auto	is_tuple_empty_v = hidden::is_tuple_empty_v<remove_cvref_t<Type>>
template<typename Type >
constexpr auto	tuple_size_v = hidden::tuple_size_v<remove_cvref_t<Type>>
template<typename Type >
constexpr auto	is_any_v = hidden::is_any_v<Type>
template<typename Type >
constexpr auto	is_map_or_unordered_map_v = hidden::is_map_or_unordered_map_v<Type>
template<typename Type >
constexpr auto	is_basic_string_v = hidden::is_basic_string_v<Type>
template<typename Type >
constexpr auto	is_set_or_unordered_set_v = hidden::is_set_or_unordered_set_v<Type>
template<typename Type >
constexpr bool	is_no_type_v = std::is_same_v<Type, no_type_t>
template<typename T , typename S >
constexpr bool	is_addition_valid_v
template<typename T , typename S >
constexpr bool	is_subtraction_valid_v
template<typename T , typename S >
constexpr bool	is_multiplication_valid_v
template<typename T , typename S >
constexpr bool	is_division_valid_v
template<typename T , typename S >
constexpr bool	is_arithmetic_valid_v
template<typename Type >
constexpr bool	is_valid_type_v = !is_no_type_v<Type>
template<typename Type >
constexpr bool	is_std_array_v = hidden::st_is_std_array<remove_cv_ref_t<Type>>::value
template<typename Type >
constexpr size_t	std_array_size_v = hidden::st_std_array_element<remove_cv_ref_t<Type>>::value
constexpr bool	StackInOrder = true
constexpr bool	InOrderSequence = true
constexpr bool	ReverseSequence = false
template<typename SequenceType >
constexpr auto	sequence_first_element_v = hidden::sequence_first_element_v<remove_cvref_t<SequenceType>>
template<typename SequenceType >
constexpr auto	sequence_last_element_v = hidden::sequence_last_element_v<remove_cvref_t<SequenceType>>
template<auto Nth, typename SequenceType >
constexpr auto	sequence_nth_element_v = hidden::sequence_nth_element_v<Nth, remove_cvref_t<SequenceType>>
template<typename SequenceType >
constexpr auto	sequence_element_count_v = hidden::sequence_element_count_v<remove_cvref_t<SequenceType>>
template<typename SequenceType >
constexpr auto	sequence_span_v = hidden::sequence_span_v<remove_cvref_t<SequenceType>>
template<typename T >
constexpr bool	is_iterator_type_v = hidden::is_iterator_type_v<remove_cv_ref_t<T>>
template<typename T >
constexpr bool	is_iterator_excluding_pointer_v
template<typename... Types>
constexpr auto	type_count_v = hidden::type_count_v<Types...>
template<typename Type >
constexpr auto	is_template_v = hidden::is_template_v<Type>
	Test whether the type parameter is a template type. More...
template<typename Type >
constexpr auto	template_parameter_count = hidden::template_parameter_count<Type>
template<typename Type1 , typename Type2 >
constexpr auto	is_same_template_type_v = hidden::is_same_template_type_v<Type1, Type2>
template<typename Type1 , typename Type2 >
constexpr auto	is_same_template_v = hidden::is_same_template_v<Type1, Type2>
template<typename Type >
constexpr auto	is_string_v = hidden::is_string_v<Type>
	Test is Type is of string type. More...
template<typename Type >
constexpr auto	is_reference_wrapper_v = hidden::is_reference_wrapper_v<Type>
template<typename Type , typename... Types>
constexpr auto	is_same_v = hidden::is_same_v<Type, Types...>
	Test if all types are the same. More...
template<typename Type , typename... Types>
constexpr auto	is_same_flat_v = is_same_v<flat_type_list_t<Type, Types...>>
template<typename TestType , typename... Types>
constexpr auto	is_in_list_v = hidden::is_in_list_v<TestType, Types...>
	test if TestType exists in Types... More...
template<typename Type >
constexpr auto	is_integer_v = hidden::is_integer_v<Type>
template<typename Type >
constexpr auto	is_signed_integer_v = hidden::is_signed_integer_v<Type>
template<typename Type >
constexpr auto	is_unsigned_integer_v = hidden::is_unsigned_integer_v<Type>
template<typename Type >
constexpr auto	is_integral_v = hidden::is_integral_v<Type>
template<typename Type >
constexpr auto	is_signed_integral_v = hidden::is_signed_integral_v<Type>
template<typename Type >
constexpr auto	is_unsigned_integral_v = hidden::is_unsigned_integral_v<Type>
template<typename Type >
constexpr auto	is_real_number_v = hidden::is_real_number_v<Type>
template<typename Type >
constexpr auto	is_numerical_number_v = hidden::is_numerical_number_v<Type>
template<typename TypeList , typename... TestTypes>
constexpr auto	are_all_in_list_v = hidden::are_all_in_list_v<TypeList, TestTypes...>
template<typename... Types>
constexpr auto	are_integers_v = hidden::are_integers_v<Types...>
template<typename... Types>
constexpr auto	are_signed_integers_v = hidden::are_signed_integers_v<Types...>
template<typename... Types>
constexpr auto	are_unsigned_integers_v = hidden::are_unsigned_integers_v<Types...>
template<typename... Types>
constexpr auto	are_integrals_v = hidden::are_integrals_v<Types...>
template<typename... Types>
constexpr auto	are_signed_integrals_v = hidden::are_signed_integrals_v<Types...>
template<typename... Types>
constexpr auto	are_unsigned_integrals_v = hidden::are_unsigned_integrals_v<Types...>
template<typename... Types>
constexpr auto	are_real_numbers_v = hidden::are_real_numbers_v<Types...>
template<typename... Types>
constexpr auto	are_numerical_numbers_v = hidden::are_numerical_numbers_v<Types...>
template<typename Type1 , typename Type2 >
constexpr auto	is_operable_v = hidden::is_operable_v<Type1, Type2>
template<typename... Types>
constexpr auto	common_type_v = hidden::common_type_v<Types...>
template<typename FuncType , typename TupleType >
constexpr bool	is_apply_v = !is_no_type_v<apply_return_t<FuncType, TupleType>>
template<typename FuncType , typename... TupleTypes>
constexpr bool	all_apply_v = ( is_apply_v<FuncType, TupleTypes> && ... )
template<typename FuncType , typename... TupleTypes>
constexpr bool	common_apply_v
template<typename Type >
constexpr bool	is_empty_available_v = hidden::is_empty_available_v<Type>
template<typename Type >
constexpr bool	is_capacity_available_v = hidden::is_capacity_available_v<Type>
template<typename Type >
constexpr bool	is_shrink_to_fit_available_v = hidden::is_shrink_to_fit_available_v<Type>
template<typename Type >
constexpr bool	is_index_operator_available_v = hidden::is_index_operator_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_push_front_available_v = hidden::is_push_front_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_push_back_available_v = hidden::is_push_back_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_begin_available_v = hidden::is_begin_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_end_available_v = hidden::is_end_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_rbegin_available_v = hidden::is_rbegin_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_rend_available_v = hidden::is_rend_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_erase_available_v = hidden::is_erase_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_resize_available_v = hidden::is_resize_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_reserve_available_v = hidden::is_reserve_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_size_available_v = hidden::is_size_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_insert_available_v = hidden::is_insert_available_v<Type>
template<typename Type >
constexpr bool	is_insert_iterator_available_v = hidden::is_insert_iterator_available_v<Type>
template<typename Type >
constexpr bool	is_emplace_front_available_v = hidden::is_emplace_front_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_emplace_back_available_v = hidden::is_emplace_back_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_emplace_available_v = hidden::is_emplace_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_front_available_v = hidden::is_front_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_back_available_v = hidden::is_back_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_pop_front_available_v = hidden::is_pop_front_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_pop_back_available_v = hidden::is_pop_back_available_v<remove_cv_ref_t<Type>>
template<typename Type >
constexpr bool	is_container_type_v = hidden::is_container_type_v<remove_cv_ref_t<Type>>
template<typename FuncType , typename... ArgTypes>
constexpr bool	is_callable_v = hidden::is_callable_v<FuncType, ArgTypes...>
template<typename FuncType , typename... ArgTypes>
constexpr bool	is_void_return_type_v = hidden::is_void_return_type_v<FuncType, ArgTypes...>
template<typename T , typename... Types>
constexpr bool	pairwise_common_type_v = hidden::st_pairwise_common<remove_cvref_t<T>, remove_cvref_t<Types>...>::value
template<typename T , typename S >
constexpr bool	tuple_common_type_v = hidden::st_tuple_common_type<remove_cvref_t<T>, remove_cvref_t<S>>::value
template<typename ArgType , typename... Types>
constexpr auto	is_type_in_list_v = hidden::is_type_in_list_v<ArgType, Types...>
template<typename LeftList , typename RightList >
constexpr auto	is_type_list_equivalent_v
template<typename TupleType >
constexpr bool	has_tuple_common_type_v = hidden::has_tuple_common_type_v<remove_cvref_t<TupleType>>
template<typename CallbackType , typename... Types>
constexpr bool	is_invocable_v = hidden::st_is_invocable<CallbackType, Types...>::value
template<typename CallbackType , typename... Types>
constexpr bool	is_all_callable_v = types::type_count_v<callable_list_t<CallbackType, Types...>> == types::type_count_v<Types...>
template<typename CallbackType , typename... Types>
constexpr bool	is_any_callable_v = types::type_count_v<callable_list_t<CallbackType, Types...>> != 0
template<typename Type >
constexpr auto	is_template_template_v = hidden::is_template_template_v<Type>
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool	is_type_in_the_set_v
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool	is_constructible_over_the_set_v
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool	is_assignable_to_the_set_v
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool	is_assignable_from_the_set_v

Detailed Description

Type to string name conversions are defined.

Type functions are defined.

Typedef Documentation

any_element_t

template<auto N, typename TypeAny >

using tpf::types::any_element_t = typedef select_nth_type_t<N, typename TypeAny::element_types_t>

Definition at line 61 of file tpf_any.hpp.

append_type_t

template<typename ArgType , typename RightList >

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

Definition at line 5648 of file tpf_types.hpp.

apply_return_array_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::apply_return_array_t = typedef std::array<std::common_type_t<apply_return_t<FuncType, TupleTypes>...>, sizeof...(TupleTypes)>

Definition at line 5280 of file tpf_types.hpp.

apply_return_t

template<typename FuncType , typename TupleType >

using tpf::types::apply_return_t = typedef decltype(hidden::fn_apply(std::declval<FuncType>(), std::declval<TupleType>()))

Definition at line 5257 of file tpf_types.hpp.

apply_return_tuple_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::apply_return_tuple_t = typedef std::tuple< apply_return_t<FuncType, TupleTypes> ...>

Definition at line 5277 of file tpf_types.hpp.

apply_return_vector_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::apply_return_vector_t = typedef std::vector<std::common_type_t<apply_return_t<FuncType, TupleTypes>...> >

Definition at line 5284 of file tpf_types.hpp.

arg_list_t

template<typename Heads , typename Tails >

using tpf::types::arg_list_t = typedef typename hidden::st_build_arg_types<Heads, Tails>::type

Definition at line 6155 of file tpf_types.hpp.

arg_to_type_list_t

template<typename... Types>

using tpf::types::arg_to_type_list_t = typedef typename hidden::st_arg_to_type_list<Types...>::type

Definition at line 6152 of file tpf_types.hpp.

arithmetic_number_list_t

using tpf::types::arithmetic_number_list_t = typedef type_list_t<char, short, int, long, long long, float, double, long double>

Arithmetic numbers for mathematical analysis.

Definition at line 3231 of file tpf_types.hpp.

array_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::array_if_all_apply_t = typedef enable_if_all_apply_t< apply_return_array_t<FuncType, TupleTypes...>, FuncType, TupleTypes...>

Definition at line 5295 of file tpf_types.hpp.

back_type_t

template<typename... Types>

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

Definition at line 5582 of file tpf_types.hpp.

big_integer_t

using tpf::types::big_integer_t = typedef long long

Definition at line 272 of file tpf_types.hpp.

big_unsigned_t

using tpf::types::big_unsigned_t = typedef unsigned long long

Definition at line 273 of file tpf_types.hpp.

callable_list_t

template<typename CallbackType , typename... Types>

using tpf::types::callable_list_t = typedef typename hidden::st_is_callable<CallbackType, type_list_t<>, type_list_t<>, Types...>::callables

Definition at line 6158 of file tpf_types.hpp.

character_list_t

using tpf::types::character_list_t = typedef type_list_t<char, unsigned char, wchar_t>

Type list of character types.

Definition at line 3170 of file tpf_types.hpp.

common_apply_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::common_apply_t = typedef std::common_type_t< apply_return_t<FuncType, TupleTypes>... >

Definition at line 5260 of file tpf_types.hpp.

common_signed_t

template<typename... Types>

using tpf::types::common_signed_t = typedef make_signed_t<common_type_t<Types...> >

Definition at line 5134 of file tpf_types.hpp.

common_type_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::common_type_if_all_apply_t = typedef std::enable_if_t<common_apply_v<FuncType, TupleTypes...>, std::common_type_t<apply_return_t<FuncType, TupleTypes>...> >

Definition at line 5303 of file tpf_types.hpp.

common_type_t

template<typename... Types>

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

Definition at line 5122 of file tpf_types.hpp.

common_unsigned_t

template<typename... Types>

using tpf::types::common_unsigned_t = typedef make_unsigned_t<common_type_t<Types...> >

Definition at line 5128 of file tpf_types.hpp.

concate_type_t

template<typename... Types>

using tpf::types::concate_type_t = typedef typename concate_type_st<Types...>::type

Definition at line 6225 of file tpf_types.hpp.

container_of_tuples_t

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

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

Definition at line 6998 of file tpf_types.hpp.

container_of_variants_t

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

using tpf::types::container_of_variants_t = typedef hidden::container_of_variants_t<ContainerType, ElementTypes...>

Definition at line 6618 of file tpf_types.hpp.

create_tuple_t

template<typename Type , auto Size>

using tpf::types::create_tuple_t = typedef decltype(types::convert_to_tuple(std::array<Type, Size>{}))

Definition at line 963 of file tpf_types.hpp.

decay_remove_cv_ref_type_list_t

template<typename... Types>

using tpf::types::decay_remove_cv_ref_type_list_t = typedef type_list_t<tpf::decay_remove_cv_ref_t<Types>...>

Create type_list_t by decaying and removing const, volatile, reference.

Template Parameters

Types

Definition at line 1053 of file tpf_types.hpp.

decay_remove_ref_type_list_t

template<typename... Types>

using tpf::types::decay_remove_ref_type_list_t = typedef type_list_t<tpf::decay_remove_ref_t<Types>...>

Create type_list_t by decaying and removing reference.

Template Parameters

Types

Definition at line 1061 of file tpf_types.hpp.

deque_of_tuples_t

template<typename... ElementTypes>

using tpf::types::deque_of_tuples_t = typedef hidden::deque_of_tuples_t<ElementTypes...>

Definition at line 7004 of file tpf_types.hpp.

deque_of_variants_t

template<typename... ElementTypes>

using tpf::types::deque_of_variants_t = typedef hidden::deque_of_variants_t<ElementTypes...>

Definition at line 6624 of file tpf_types.hpp.

difference_type_t

template<typename LeftList , typename RightList >

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

Definition at line 5660 of file tpf_types.hpp.

enable_if_all_apply_t

template<typename ReturnType , typename FuncType , typename... TupleTypes>

using tpf::types::enable_if_all_apply_t = typedef std::enable_if_t< all_apply_v<FuncType, TupleTypes...>, ReturnType>

Definition at line 5273 of file tpf_types.hpp.

enable_if_all_in_list_t

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

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

Definition at line 6409 of file tpf_types.hpp.

enable_if_all_the_same_flat_t

template<typename ReturnType , typename... Types>

using tpf::types::enable_if_all_the_same_flat_t = typedef std::enable_if_t< is_same_flat_v<Types...>, ReturnType>

Definition at line 5003 of file tpf_types.hpp.

enable_if_all_the_same_t

template<typename ReturnType , typename... Types>

using tpf::types::enable_if_all_the_same_t = typedef std::enable_if_t< is_same_v<Types...>, ReturnType>

Definition at line 4997 of file tpf_types.hpp.

enable_if_common_exisits_t

template<typename ReturnType , typename... ArgTypes>

using tpf::types::enable_if_common_exisits_t = typedef std::enable_if_t< common_type_v< remove_cvref_t<ArgTypes>... >, ReturnType>

Definition at line 5140 of file tpf_types.hpp.

enable_if_container_type_t

template<typename Type , typename ReturnType = void>

using tpf::types::enable_if_container_type_t = typedef hidden::enable_if_container_type_t<Type, ReturnType>

Definition at line 5564 of file tpf_types.hpp.

enable_if_in_list_t

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

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

Definition at line 6406 of file tpf_types.hpp.

enable_if_integer_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5089 of file tpf_types.hpp.

enable_if_integral_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5080 of file tpf_types.hpp.

enable_if_iterator_type_t

template<typename Type , typename ReturnType >

using tpf::types::enable_if_iterator_type_t = typedef hidden::enable_if_iterator_type_t<remove_cv_ref_t<Type>, ReturnType>

Definition at line 3155 of file tpf_types.hpp.

enable_if_not_integer_t

template<typename Type , typename ReturnType = Type>

using tpf::types::enable_if_not_integer_t = typedef hidden::enable_if_not_integer_t<Type, ReturnType>

Definition at line 5092 of file tpf_types.hpp.

enable_if_numerical_number_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5104 of file tpf_types.hpp.

enable_if_pair_of_variant_t

template<typename Type , typename ReturnType = void>

using tpf::types::enable_if_pair_of_variant_t = typedef std::enable_if_t<is_pair_of_variant_type_v<Type>, ReturnType>

Definition at line 59 of file 31-visit.cpp.

enable_if_pair_t

template<typename Type , typename ReturnType = void>

using tpf::types::enable_if_pair_t = typedef std::enable_if_t<is_pair_type_v<Type>, ReturnType>

Definition at line 56 of file 31-visit.cpp.

enable_if_real_number_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5101 of file tpf_types.hpp.

enable_if_same_flat_t

template<typename ReturnType , typename Type , typename... Types>

using tpf::types::enable_if_same_flat_t = typedef std::enable_if_t< is_same_flat_v<Type, Types...>, ReturnType>

Definition at line 5000 of file tpf_types.hpp.

enable_if_same_t

template<typename ReturnType , typename Type , typename... Types>

using tpf::types::enable_if_same_t = typedef std::enable_if_t< is_same_v<Type, Types...>, ReturnType>

Definition at line 4994 of file tpf_types.hpp.

enable_if_signed_integer_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5095 of file tpf_types.hpp.

enable_if_signed_integral_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5083 of file tpf_types.hpp.

enable_if_unsigned_integer_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5098 of file tpf_types.hpp.

enable_if_unsigned_integral_t

template<typename Type , typename ReturnType = Type>

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

Definition at line 5086 of file tpf_types.hpp.

enable_if_variant_t

template<typename Type , typename ReturnType = void>

using tpf::types::enable_if_variant_t = typedef std::enable_if_t<is_variant_type_v<Type>, ReturnType>

Definition at line 62 of file 31-visit.cpp.

enable_pairwise_common_type_t

template<typename T , typename... Types>

using tpf::types::enable_pairwise_common_type_t = typedef std::enable_if_t< pairwise_common_type_v <T, Types...> >

Definition at line 5551 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::first_n_types_list_to_template_class_t = typedef hidden::first_n_types_list_to_template_class_t<FirstN, TemplateClass, Types...>

Definition at line 6994 of file tpf_types.hpp.

first_n_types_t

template<size_t FirstN, typename... Types>

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

Definition at line 5612 of file tpf_types.hpp.

first_n_types_to_template_class_t

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

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

Definition at line 6990 of file tpf_types.hpp.

first_parameter_type_t

template<typename Type >

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

Definition at line 5591 of file tpf_types.hpp.

first_type_t

template<typename... Types>

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

Definition at line 5570 of file tpf_types.hpp.

flat_type_list_t

template<typename Type , typename... Types>

using tpf::types::flat_type_list_t = typedef tpf::types::type_list_t<decay_remove_cv_ref_t<Type>, decay_remove_cv_ref_t<Types>...>

Definition at line 4988 of file tpf_types.hpp.

floating_point_list_t

using tpf::types::floating_point_list_t = typedef real_number_list_t

The same to real_number_list_t, real numbers.

Definition at line 3237 of file tpf_types.hpp.

front_type_t

template<typename... Types>

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

Definition at line 5573 of file tpf_types.hpp.

function_return_type_t

template<typename FuncType , typename... ArgTypes>

using tpf::types::function_return_type_t = typedef hidden::function_return_type_t<FuncType, ArgTypes...>

Definition at line 5426 of file tpf_types.hpp.

index_for

template<typename ... Types>

using tpf::types::index_for = typedef std::make_index_sequence<sizeof...(Types)>

Definition at line 295 of file tpf_types.hpp.

index_t

template<auto Id, auto... Ids>

using tpf::types::index_t = typedef std::index_sequence<(std::size_t)Id, (std::size_t)Ids...>

Definition at line 289 of file tpf_types.hpp.

index_tuple_vector_t

template<std::size_t N>

using tpf::types::index_tuple_vector_t = typedef typename hidden::st_index_tuple_vector<std::make_index_sequence<N> >::type

Definition at line 1211 of file tpf_types.hpp.

indexer_2d_t

template<auto RowValue, auto ColumnValue>

using tpf::types::indexer_2d_t = typedef indexer_2d_type< remove_cvref_t<decltype(RowValue)>, RowValue, ColumnValue>

Definition at line 2251 of file tpf_types.hpp.

indexer_3d_t

template<auto HeightValue, auto RowValue, auto ColumnValue>

using tpf::types::indexer_3d_t = typedef indexer_3d_type< remove_cvref_t<decltype(RowValue)>, HeightValue, RowValue, ColumnValue>

Definition at line 2277 of file tpf_types.hpp.

indexer_t

template<auto Index>

using tpf::types::indexer_t = typedef indexer_type< remove_cvref_t<decltype(Index)>, Index>

Definition at line 2226 of file tpf_types.hpp.

integer_list_t

using tpf::types::integer_list_t = typedef type_list_t<short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>

Type list of integers EXCLUSING character type and boolean type.

Definition at line 3176 of file tpf_types.hpp.

integral_list_t

using tpf::types::integral_list_t = typedef type_list_t<char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>

Type list of integral type INCLUDING character type, but EXCLUDING boolean type.

Definition at line 3196 of file tpf_types.hpp.

intersection_type_t

template<typename LeftList , typename RightList >

using tpf::types::intersection_type_t = typedef hidden::intersection_type_t<unique_types_t<LeftList>, unique_types_t<RightList> >

Definition at line 5654 of file tpf_types.hpp.

invalid_t

using tpf::types::invalid_t = typedef no_type_t

Definition at line 2024 of file tpf_types.hpp.

last_n_types_t

template<size_t LastN, typename... Types>

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

Definition at line 5618 of file tpf_types.hpp.

last_parameter_type_t

template<typename Type >

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

Definition at line 5594 of file tpf_types.hpp.

last_type_t

template<typename... Types>

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

Definition at line 5579 of file tpf_types.hpp.

list_of_tuples_t

template<typename... ElementTypes>

using tpf::types::list_of_tuples_t = typedef hidden::list_of_tuples_t<ElementTypes...>

Definition at line 7007 of file tpf_types.hpp.

list_of_variants_t

template<typename... ElementTypes>

using tpf::types::list_of_variants_t = typedef hidden::list_of_variants_t<ElementTypes...>

Definition at line 6627 of file tpf_types.hpp.

make_common_signed_t

template<typename... Types>

using tpf::types::make_common_signed_t = typedef make_signed_t<common_type_t<Types...> >

Definition at line 5131 of file tpf_types.hpp.

make_common_unsigned_t

template<typename... Types>

using tpf::types::make_common_unsigned_t = typedef make_unsigned_t<common_type_t<Types...> >

Definition at line 5125 of file tpf_types.hpp.

make_index_t

template<auto N>

using tpf::types::make_index_t = typedef std::make_index_sequence<(std::size_t)N>

Definition at line 292 of file tpf_types.hpp.

make_sequence_t

template<bool SequenceInOrder, auto... RangeValues>

using tpf::types::make_sequence_t = typedef typename hidden::st_create_workhorse_range<SequenceInOrder, RangeValues...>::type

Definition at line 2668 of file tpf_types.hpp.

make_signed_integral_t

template<typename Type >

using tpf::types::make_signed_integral_t = typedef hidden::make_signed_integral_t<Type>

Definition at line 5116 of file tpf_types.hpp.

make_signed_t

template<typename Type >

using tpf::types::make_signed_t = typedef hidden::make_signed_t<Type>

Definition at line 5110 of file tpf_types.hpp.

make_typed_sequence_t

template<auto Size>

using tpf::types::make_typed_sequence_t = typedef std::make_integer_sequence<remove_cvref_t<decltype(Size)>, Size>

Definition at line 2284 of file tpf_types.hpp.

make_unsigned_integral_t

template<typename Type >

using tpf::types::make_unsigned_integral_t = typedef hidden::make_unsigned_integral_t<Type>

Definition at line 5113 of file tpf_types.hpp.

make_unsigned_t

template<typename Type >

using tpf::types::make_unsigned_t = typedef hidden::make_unsigned_t<Type>

Definition at line 5107 of file tpf_types.hpp.

map_of_tuples_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 7013 of file tpf_types.hpp.

map_of_variants_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 6645 of file tpf_types.hpp.

map_or_unordered_map_pair_t

template<typename Type >

using tpf::types::map_or_unordered_map_pair_t = typedef hidden::map_or_unordered_map_pair_t<Type>

Definition at line 1927 of file tpf_types.hpp.

multimap_of_tuples_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 7016 of file tpf_types.hpp.

multimap_of_variants_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 6648 of file tpf_types.hpp.

multiset_of_variants_t

template<typename... ElementTypes>

using tpf::types::multiset_of_variants_t = typedef hidden::multiset_of_variants_t<ElementTypes...>

Definition at line 6633 of file tpf_types.hpp.

no_throw_t

using tpf::types::no_throw_t = typedef no_type_t

Definition at line 2023 of file tpf_types.hpp.

non_callable_list_t

template<typename CallbackType , typename... Types>

using tpf::types::non_callable_list_t = typedef typename hidden::st_is_callable<CallbackType, type_list_t<>, type_list_t<>, Types...>::non_callables

Definition at line 6161 of file tpf_types.hpp.

non_class_wrapper_t

template<typename Type , auto Tag>

using tpf::types::non_class_wrapper_t = typedef hidden::non_class_wrapper_t<Type, Tag>

Definition at line 407 of file tpf_types.hpp.

nth_parameter_type_t

template<auto SelectIndex, typename Type >

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

Definition at line 5597 of file tpf_types.hpp.

nth_type_t

template<auto SelectIndex, typename... Types>

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

Definition at line 5588 of file tpf_types.hpp.

nth_type_to_template_class_t

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

using tpf::types::nth_type_to_template_class_t = typedef hidden::nth_type_to_template_class_t<SelectTypeIndex, TemplateClass, Types...>

Definition at line 6986 of file tpf_types.hpp.

numerical_number_list_t

using tpf::types::numerical_number_list_t = typedef type_list_t<char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, float, double, long double>

All numbers mathematical operations.

Definition at line 3224 of file tpf_types.hpp.

pop_back_type_t

template<typename... Types>

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

Definition at line 5609 of file tpf_types.hpp.

pop_front_type_t

template<typename... Types>

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

Definition at line 5606 of file tpf_types.hpp.

prepend_type_t

template<typename ArgType , typename RightList >

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

Definition at line 5645 of file tpf_types.hpp.

push_back_type_t

template<typename ArgType , typename... Types>

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

Definition at line 5603 of file tpf_types.hpp.

push_front_type_t

template<typename ArgType , typename... Types>

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

Definition at line 5600 of file tpf_types.hpp.

real_number_list_t

using tpf::types::real_number_list_t = typedef type_list_t<float, double, long double>

Type list of real numbers (floating-point numbers).

Definition at line 3218 of file tpf_types.hpp.

remove_cv_ref_type_list_t

template<typename... Types>

using tpf::types::remove_cv_ref_type_list_t = typedef type_list_t<tpf::remove_cv_ref_t<Types>...>

Create type_list_t by removing const, volatile, reference.

Template Parameters

Types

Definition at line 1045 of file tpf_types.hpp.

remove_cvref_t

template<typename Type >

using tpf::types::remove_cvref_t = typedef remove_cv_ref_t<Type>

Definition at line 298 of file tpf_types.hpp.

remove_type_t

template<typename ArgType , typename... Types>

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

Definition at line 5657 of file tpf_types.hpp.

replace_type_t

template<typename NewType , typename OldType , typename TypeList >

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

Definition at line 5663 of file tpf_types.hpp.

return_type_t

template<typename Type >

using tpf::types::return_type_t = typedef hidden::return_type_t<Type>

Definition at line 2124 of file tpf_types.hpp.

reverse_sequence_t

template<typename SequenceType >

using tpf::types::reverse_sequence_t = typedef hidden::reverse_sequence_t<remove_cvref_t<SequenceType> >

Definition at line 2519 of file tpf_types.hpp.

select_first_n_types_t

template<size_t FirstN, typename... Types>

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

Definition at line 5615 of file tpf_types.hpp.

select_first_type_t

template<typename... Types>

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

Definition at line 5567 of file tpf_types.hpp.

select_last_n_types_t

template<size_t LastN, typename... Types>

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

Definition at line 5621 of file tpf_types.hpp.

select_last_type_t

template<typename... Types>

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

Definition at line 5576 of file tpf_types.hpp.

select_nth_type_t

template<auto SelectIndex, typename... Types>

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

Definition at line 5585 of file tpf_types.hpp.

sequence_element_t

template<typename SequenceType >

using tpf::types::sequence_element_t = typedef hidden::sequence_element_t<remove_cvref_t<SequenceType> >

Definition at line 2534 of file tpf_types.hpp.

sequence_info_t

template<bool StackOrder, typename SequenceType >

using tpf::types::sequence_info_t = typedef typename hidden::sequence_info_t<StackOrder, remove_cvref_t<SequenceType> >

Definition at line 2540 of file tpf_types.hpp.

set_of_tuples_t

template<typename... ElementTypes>

using tpf::types::set_of_tuples_t = typedef hidden::set_of_tuples_t<ElementTypes...>

Definition at line 7010 of file tpf_types.hpp.

set_of_variants_t

template<typename... ElementTypes>

using tpf::types::set_of_variants_t = typedef hidden::set_of_variants_t<ElementTypes...>

Definition at line 6630 of file tpf_types.hpp.

signed_common_t

template<typename Type1 , typename Type2 , typename common_t = common_type_t<Type1, Type2>, bool is_integral_type = is_integral_v<common_t>, typename result_type = std::conditional_t< is_integral_type, make_signed_t<common_t>, common_t>>

using tpf::types::signed_common_t = typedef result_type

Definition at line 6606 of file tpf_types.hpp.

signed_integer_list_t

using tpf::types::signed_integer_list_t = typedef type_list_t<short, int, long, long long>

Signed integers EXCLUDING char and boolean.

Definition at line 3184 of file tpf_types.hpp.

signed_integral_list_t

using tpf::types::signed_integral_list_t = typedef type_list_t<char, short, int, long int, long long int>

Type list of signed integral type INCLUDING character type, but EXCLUDING boolean type.

Definition at line 3211 of file tpf_types.hpp.

std_array_element_t

template<typename Type >

using tpf::types::std_array_element_t = typedef typename hidden::st_std_array_element<remove_cv_ref_t<Type> >::type

Definition at line 2214 of file tpf_types.hpp.

template_parameter_type_list_t

template<typename Type >

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

Definition at line 3393 of file tpf_types.hpp.

to_recursive_type_list_t

template<typename T >

using tpf::types::to_recursive_type_list_t = typedef hidden::to_recursive_type_list_t<remove_cv_ref_t<T> >

Definition at line 1037 of file tpf_types.hpp.

to_tuple_t

template<typename... Types>

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

Definition at line 5639 of file tpf_types.hpp.

to_variant_t

template<typename Type , typename... Types>

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

Definition at line 5630 of file tpf_types.hpp.

tuple_common_element_t

template<typename TupleType >

using tpf::types::tuple_common_element_t = typedef hidden::tuple_common_element_t<remove_cvref_t<TupleType> >

Definition at line 5702 of file tpf_types.hpp.

tuple_common_type_t

template<typename T , typename S >

using tpf::types::tuple_common_type_t = typedef typename hidden::st_tuple_common_type<remove_cvref_t<T>, remove_cvref_t<S> >::type

Definition at line 5554 of file tpf_types.hpp.

tuple_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::tuple_if_all_apply_t = typedef enable_if_all_apply_t< apply_return_tuple_t<FuncType, TupleTypes...>, FuncType, TupleTypes...>

Definition at line 5291 of file tpf_types.hpp.

tuple_of_vectors_t

template<typename... Types>

using tpf::types::tuple_of_vectors_t = typedef typename hidden::st_type_list_to_tuple_of_vectors<Types...>::type

Definition at line 1189 of file tpf_types.hpp.

tuple_operation_valid_t

template<typename T , typename S >

using tpf::types::tuple_operation_valid_t = typedef std::enable_if_t<tuple_common_type_v<T, S>, tuple_common_type_t<T, S> >

Definition at line 5560 of file tpf_types.hpp.

tuple_to_container_of_variants_t

template<template< typename, typename... > class Container, typename TupleType >

using tpf::types::tuple_to_container_of_variants_t = typedef Container<types::to_variant_t<remove_cvref_t<TupleType> >>

Definition at line 5636 of file tpf_types.hpp.

tuple_to_std_array_t

template<typename TupleType >

using tpf::types::tuple_to_std_array_t = typedef hidden::tuple_to_std_array_t<remove_cvref_t<TupleType> >

Definition at line 5705 of file tpf_types.hpp.

tuple_to_type_list_t

template<typename TupleType >

using tpf::types::tuple_to_type_list_t = typedef hidden::tuple_to_type_list_t<remove_cvref_t<TupleType> >

Definition at line 1180 of file tpf_types.hpp.

tuple_to_variant_t

template<typename TupleType >

using tpf::types::tuple_to_variant_t = typedef hidden::to_variant_t<TupleType>

Definition at line 5633 of file tpf_types.hpp.

type_list_to_template_class_t

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

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

Definition at line 6983 of file tpf_types.hpp.

type_list_to_tuple_t

template<typename TypeList >

using tpf::types::type_list_to_tuple_t = typedef hidden::type_list_to_tuple_t<remove_cvref_t<TypeList> >

Definition at line 1183 of file tpf_types.hpp.

typed_sequence_t

template<auto... Indices>

using tpf::types::typed_sequence_t = typedef std::integer_sequence< std::common_type_t<remove_cvref_t<decltype(Indices)>...>, Indices...>

Definition at line 2280 of file tpf_types.hpp.

types_to_template_class_t

template<typename Type , typename... Types>

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

Definition at line 6980 of file tpf_types.hpp.

union_type_t

template<typename LeftList , typename RightList >

using tpf::types::union_type_t = typedef hidden::union_type_t<unique_types_t<LeftList>, unique_types_t<RightList> >

Definition at line 5651 of file tpf_types.hpp.

unique_types_t

template<typename... Types>

using tpf::types::unique_types_t = typedef hidden::unique_types_t<Types...>

Definition at line 5627 of file tpf_types.hpp.

unordered_map_of_tuples_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 7019 of file tpf_types.hpp.

unordered_map_of_variants_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 6651 of file tpf_types.hpp.

unordered_multimap_of_tuples_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 7022 of file tpf_types.hpp.

unordered_multimap_of_variants_t

template<typename KeyType , typename... ElementTypes>

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

Definition at line 6654 of file tpf_types.hpp.

unordered_multiset_of_variants_t

template<typename... ElementTypes>

using tpf::types::unordered_multiset_of_variants_t = typedef hidden::unordered_multiset_of_variants_t<ElementTypes...>

Definition at line 6639 of file tpf_types.hpp.

unordered_set_of_variants_t

template<typename... ElementTypes>

using tpf::types::unordered_set_of_variants_t = typedef hidden::unordered_set_of_variants_t<ElementTypes...>

Definition at line 6636 of file tpf_types.hpp.

unsigned_common_t

template<typename Type1 , typename Type2 , typename common_t = common_type_t<Type1, Type2>, bool is_integral_type = is_integral_v<common_t>, typename result_type = std::conditional_t< is_integral_type, make_unsigned_t<common_t>, common_t>>

using tpf::types::unsigned_common_t = typedef result_type

Definition at line 6615 of file tpf_types.hpp.

unsigned_integer_list_t

using tpf::types::unsigned_integer_list_t = typedef type_list_t<unsigned short, unsigned int, unsigned long, unsigned long long>

Unsigned integers EXCLUDING unsigned char and boolean.

Definition at line 3190 of file tpf_types.hpp.

unsigned_integral_list_t

using tpf::types::unsigned_integral_list_t = typedef type_list_t<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>

Type list of unsigned integral type INCLUDING character type, but EXCLUDING boolean type.

Definition at line 3204 of file tpf_types.hpp.

variant_to_tuple_t

template<typename VarType >

using tpf::types::variant_to_tuple_t = typedef hidden::to_tuple_t<VarType>

Definition at line 5642 of file tpf_types.hpp.

variant_to_type_list_t

template<typename VarType >

using tpf::types::variant_to_type_list_t = typedef hidden::variant_to_type_list_t<remove_cvref_t<VarType> >

Definition at line 1186 of file tpf_types.hpp.

vector_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::vector_if_all_apply_t = typedef enable_if_all_apply_t< apply_return_vector_t<FuncType, TupleTypes...>, FuncType, TupleTypes...>

Definition at line 5299 of file tpf_types.hpp.

vector_of_tuples_t

template<typename... ElementTypes>

using tpf::types::vector_of_tuples_t = typedef hidden::vector_of_tuples_t<ElementTypes...>

Definition at line 7001 of file tpf_types.hpp.

vector_of_variants_t

template<typename... ElementTypes>

using tpf::types::vector_of_variants_t = typedef hidden::vector_of_variants_t<ElementTypes...>

Definition at line 6621 of file tpf_types.hpp.

void_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

using tpf::types::void_if_all_apply_t = typedef enable_if_all_apply_t<void, FuncType, TupleTypes...>

Definition at line 5288 of file tpf_types.hpp.

void_if_all_the_same_flat_t

template<typename... Types>

using tpf::types::void_if_all_the_same_flat_t = typedef std::enable_if_t< is_same_flat_v<Types...> >

Definition at line 5016 of file tpf_types.hpp.

void_if_all_the_same_t

template<typename... Types>

using tpf::types::void_if_all_the_same_t = typedef std::enable_if_t< is_same_v<Types...> >

Definition at line 5010 of file tpf_types.hpp.

void_if_common_exisits_t

template<typename... ArgTypes>

using tpf::types::void_if_common_exisits_t = typedef std::enable_if_t< common_type_v< remove_cvref_t<ArgTypes>... > >

Definition at line 5144 of file tpf_types.hpp.

void_if_same_flat_t

template<typename Type , typename... Types>

using tpf::types::void_if_same_flat_t = typedef std::enable_if_t< is_same_flat_v<Type, Types...> >

Definition at line 5013 of file tpf_types.hpp.

void_if_same_t

template<typename Type , typename... Types>

using tpf::types::void_if_same_t = typedef std::enable_if_t< is_same_v<Type, Types...> >

Definition at line 5007 of file tpf_types.hpp.

Enumeration Type Documentation

TemplateCategory

enum class tpf::types::TemplateCategory

strong

Enumerator
Unknown
NonTemplate
Type
Type_Value
Value
Value_Type

Definition at line 1063 of file tpf_types.hpp.

Function Documentation

any_visitors()

template<typename... CallbackTypes>

tpf::types::any_visitors

(

CallbackTypes...

)

-> any_visitors< CallbackTypes... >

append_to_container()

template<bool bReverseOrder, typename TargetContainerType , typename SourceContainerType >

void tpf::types::append_to_container	(	TargetContainerType &	target_container,
		SourceContainerType &&	source_container
	)

Definition at line 7179 of file tpf_types.hpp.

apply_array()

template<typename FuncType , typename... ArgTypes>

types::array_if_all_apply_t< FuncType, ArgTypes... > tpf::types::apply_array	(	FuncType &&	f,
		ArgTypes &&...	args
	)

Definition at line 5323 of file tpf_types.hpp.

Here is the call graph for this function:

apply_tuple()

template<typename FuncType , typename... ArgTypes>

types::tuple_if_all_apply_t< FuncType, ArgTypes... > tpf::types::apply_tuple	(	FuncType &&	f,
		ArgTypes &&...	args
	)

Definition at line 5308 of file tpf_types.hpp.

Here is the call graph for this function:

apply_vector()

template<typename FuncType , typename... ArgTypes>

types::vector_if_all_apply_t< FuncType, ArgTypes... > tpf::types::apply_vector	(	FuncType &&	f,
		ArgTypes &&...	args
	)

Definition at line 5315 of file tpf_types.hpp.

Here is the call graph for this function:

array_indexer()

template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>

decltype(auto) tpf::types::array_indexer

(

ArrayType &&

array

)

Definition at line 2684 of file tpf_types.hpp.

array_indexer_row_column()

template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>

decltype(auto) tpf::types::array_indexer_row_column

(

ArrayType &&

array

)

Definition at line 2695 of file tpf_types.hpp.

array_reader()

template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>

decltype(auto) tpf::types::array_reader

(

ArrayType &&

array

)

Definition at line 2733 of file tpf_types.hpp.

array_reader_row_column()

template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>

decltype(auto) tpf::types::array_reader_row_column

(

ArrayType &&

array

)

Definition at line 2744 of file tpf_types.hpp.

array_size()

template<typename ElementType , size_t ElementSize>

constexpr size_t tpf::types::array_size ( ElementType(&)  array[ElementSize] )

constexprnoexcept

Definition at line 1240 of file tpf_types.hpp.

Here is the caller graph for this function:

array_wrapper()

template<typename ElementType , size_t ElementSize>

auto tpf::types::array_wrapper ( ElementType(&)  array[ElementSize] )

noexcept

Definition at line 1228 of file tpf_types.hpp.

Here is the caller graph for this function:

array_wrapper_t()

template<typename ElementType , size_t ElementCount>

tpf::types::array_wrapper_t

(

ElementType(&)

[ElementCount]

)

-> array_wrapper_t< ElementType *, size_t >

array_writer()

template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>

decltype(auto) tpf::types::array_writer

(

ArrayType &&

array

)

Definition at line 2707 of file tpf_types.hpp.

array_writer_row_column()

template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>

decltype(auto) tpf::types::array_writer_row_column

(

ArrayType &&

array

)

Definition at line 2720 of file tpf_types.hpp.

cast_array() [1/10]

template<typename T , size_t N>

auto tpf::types::cast_array ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 894 of file tpf_types.hpp.

cast_array() [2/10]

template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t< N1 * N2 == N>>

auto tpf::types::cast_array ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 909 of file tpf_types.hpp.

cast_array() [3/10]

template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>

auto tpf::types::cast_array ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 925 of file tpf_types.hpp.

cast_array() [4/10]

template<typename T , size_t N>

auto tpf::types::cast_array ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 901 of file tpf_types.hpp.

cast_array() [5/10]

template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t< N1 * N2 == N>>

auto tpf::types::cast_array ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 917 of file tpf_types.hpp.

cast_array() [6/10]

template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>

auto tpf::types::cast_array ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 933 of file tpf_types.hpp.

cast_array() [7/10]

template<size_t N1, size_t N2, typename T , size_t N = N1 * N2>

auto tpf::types::cast_array ( T(&)  array[N1][N2] )

inlinenoexcept

Definition at line 872 of file tpf_types.hpp.

cast_array() [8/10]

template<size_t N1, size_t N2, size_t N3, typename T , size_t N = N1 * N2* N3>

auto tpf::types::cast_array ( T(&)  array[N1][N2][N3] )

inlinenoexcept

Definition at line 887 of file tpf_types.hpp.

cast_array() [9/10]

template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t<N1* N2 == N>>

auto tpf::types::cast_array ( T(&)  array[N] )

inlinenoexcept

Definition at line 865 of file tpf_types.hpp.

cast_array() [10/10]

template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t<N1* N2* N3 == N>>

auto tpf::types::cast_array ( T(&)  array[N] )

inlinenoexcept

Definition at line 880 of file tpf_types.hpp.

cast_ref() [1/50]

template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t<N1 == N>>

auto & tpf::types::cast_ref ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 659 of file tpf_types.hpp.

cast_ref() [2/50]

template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>

auto & tpf::types::cast_ref ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 675 of file tpf_types.hpp.

cast_ref() [3/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>

auto & tpf::types::cast_ref ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 723 of file tpf_types.hpp.

cast_ref() [4/50]

template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t<N1 == N>>

auto & tpf::types::cast_ref ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 667 of file tpf_types.hpp.

cast_ref() [5/50]

template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>

auto & tpf::types::cast_ref ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 683 of file tpf_types.hpp.

cast_ref() [6/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>

auto & tpf::types::cast_ref ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 731 of file tpf_types.hpp.

cast_ref() [7/50]

template<auto N, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::index_sequence< N >  , std::unique_ptr< T[], Deleter > &  uptr  )

inlinenoexcept

Definition at line 471 of file tpf_types.hpp.

cast_ref() [8/50]

template<auto N, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::index_sequence< N >  , std::unique_ptr< T[], Deleter > const &  uptr  )

inlinenoexcept

Definition at line 483 of file tpf_types.hpp.

cast_ref() [9/50]

template<std::size_t N, typename T >

auto & tpf::types::cast_ref ( std::index_sequence< N >  , std::vector< T > &  vctr  )

inlinenoexcept

Definition at line 774 of file tpf_types.hpp.

cast_ref() [10/50]

template<std::size_t N, typename T >

auto & tpf::types::cast_ref ( std::index_sequence< N >  , std::vector< T > const &  vctr  )

inlinenoexcept

Definition at line 783 of file tpf_types.hpp.

cast_ref() [11/50]

template<auto N, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>

auto & tpf::types::cast_ref ( std::index_sequence< N >  , T  array  )

inlinenoexcept

Definition at line 631 of file tpf_types.hpp.

cast_ref() [12/50]

template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t< N1 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1 >  , std::array< T, N > &  array  )

inlinenoexcept

Definition at line 691 of file tpf_types.hpp.

cast_ref() [13/50]

template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t< N1 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1 >  , std::array< T, N > const &  array  )

inlinenoexcept

Definition at line 699 of file tpf_types.hpp.

cast_ref() [14/50]

template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , std::array< T, N > &  array  )

inlinenoexcept

Definition at line 707 of file tpf_types.hpp.

cast_ref() [15/50]

template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , std::array< T, N > const &  array  )

inlinenoexcept

Definition at line 715 of file tpf_types.hpp.

cast_ref() [16/50]

template<auto N1, auto N2, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , std::unique_ptr< T[], Deleter > &  uptr  )

inlinenoexcept

Definition at line 496 of file tpf_types.hpp.

cast_ref() [17/50]

template<auto N1, auto N2, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , std::unique_ptr< T[], Deleter > const &  uptr  )

inlinenoexcept

Definition at line 508 of file tpf_types.hpp.

cast_ref() [18/50]

template<std::size_t N1, std::size_t N2, typename T >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , std::vector< T > &  vctr  )

inlinenoexcept

Definition at line 810 of file tpf_types.hpp.

cast_ref() [19/50]

template<std::size_t N1, std::size_t N2, typename T >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , std::vector< T > const &  vctr  )

inlinenoexcept

Definition at line 819 of file tpf_types.hpp.

cast_ref() [20/50]

template<auto N1, auto N2, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , T  array  )

inlinenoexcept

Definition at line 640 of file tpf_types.hpp.

cast_ref() [21/50]

template<auto N1, auto N2, typename T , auto N = N1 * N2>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , T(&)  array[N1][N2]  )

inlinenoexcept

Definition at line 563 of file tpf_types.hpp.

cast_ref() [22/50]

template<auto N1, auto N2, typename T , auto N, typename = std::enable_if_t<N1* N2 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2 >  , T(&)  array[N]  )

inlinenoexcept

Definition at line 549 of file tpf_types.hpp.

cast_ref() [23/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::array< T, N > &  array  )

inlinenoexcept

Definition at line 739 of file tpf_types.hpp.

cast_ref() [24/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::array< T, N > const &  array  )

inlinenoexcept

Definition at line 747 of file tpf_types.hpp.

cast_ref() [25/50]

template<auto N1, auto N2, auto N3, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::unique_ptr< T[], Deleter > &  uptr  )

inlinenoexcept

Definition at line 520 of file tpf_types.hpp.

cast_ref() [26/50]

template<auto N1, auto N2, auto N3, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::unique_ptr< T[], Deleter > const &  uptr  )

inlinenoexcept

Definition at line 532 of file tpf_types.hpp.

cast_ref() [27/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::vector< T > &  vctr  )

inlinenoexcept

Definition at line 846 of file tpf_types.hpp.

cast_ref() [28/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::vector< T > const &  vctr  )

inlinenoexcept

Definition at line 855 of file tpf_types.hpp.

cast_ref() [29/50]

template<auto N1, auto N2, auto N3, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , T  array  )

inlinenoexcept

Definition at line 649 of file tpf_types.hpp.

cast_ref() [30/50]

template<auto N1, auto N2, auto N3, typename T , auto N = N1 * N2* N3>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , T(&)  array[N1][N2][N3]  )

inlinenoexcept

Definition at line 593 of file tpf_types.hpp.

cast_ref() [31/50]

template<auto N1, auto N2, auto N3, typename T , auto N, typename = std::enable_if_t<N1* N2* N3 == N>>

auto & tpf::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , T(&)  array[N]  )

inlinenoexcept

Definition at line 579 of file tpf_types.hpp.

cast_ref() [32/50]

template<auto N, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::unique_ptr< T[], Deleter > &  uptr )

inlinenoexcept

Definition at line 465 of file tpf_types.hpp.

cast_ref() [33/50]

template<auto N1, auto N2, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::unique_ptr< T[], Deleter > &  uptr )

inlinenoexcept

Definition at line 490 of file tpf_types.hpp.

cast_ref() [34/50]

template<auto N1, auto N2, auto N3, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::unique_ptr< T[], Deleter > &  uptr )

inlinenoexcept

Definition at line 514 of file tpf_types.hpp.

cast_ref() [35/50]

template<auto N, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::unique_ptr< T[], Deleter > const &  uptr )

inlinenoexcept

Definition at line 477 of file tpf_types.hpp.

cast_ref() [36/50]

template<auto N1, auto N2, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::unique_ptr< T[], Deleter > const &  uptr )

inlinenoexcept

Definition at line 502 of file tpf_types.hpp.

cast_ref() [37/50]

template<auto N1, auto N2, auto N3, typename T , typename Deleter >

auto & tpf::types::cast_ref ( std::unique_ptr< T[], Deleter > const &  uptr )

inlinenoexcept

Definition at line 526 of file tpf_types.hpp.

cast_ref() [38/50]

template<std::size_t N, typename T >

auto & tpf::types::cast_ref ( std::vector< T > &  vctr )

inlinenoexcept

Definition at line 756 of file tpf_types.hpp.

cast_ref() [39/50]

template<std::size_t N1, std::size_t N2, typename T >

auto & tpf::types::cast_ref ( std::vector< T > &  vctr )

inlinenoexcept

Definition at line 792 of file tpf_types.hpp.

cast_ref() [40/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >

auto & tpf::types::cast_ref ( std::vector< T > &  vctr )

inlinenoexcept

Definition at line 828 of file tpf_types.hpp.

cast_ref() [41/50]

template<std::size_t N, typename T >

auto & tpf::types::cast_ref ( std::vector< T > const &  vctr )

inlinenoexcept

Definition at line 765 of file tpf_types.hpp.

cast_ref() [42/50]

template<std::size_t N1, std::size_t N2, typename T >

auto & tpf::types::cast_ref ( std::vector< T > const &  vctr )

inlinenoexcept

Definition at line 801 of file tpf_types.hpp.

cast_ref() [43/50]

template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >

auto & tpf::types::cast_ref ( std::vector< T > const &  vctr )

inlinenoexcept

Definition at line 837 of file tpf_types.hpp.

cast_ref() [44/50]

template<auto N, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>

auto & tpf::types::cast_ref ( T  array )

inlinenoexcept

Definition at line 601 of file tpf_types.hpp.

cast_ref() [45/50]

template<auto N1, auto N2, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>

auto & tpf::types::cast_ref ( T  array )

inlinenoexcept

Definition at line 611 of file tpf_types.hpp.

cast_ref() [46/50]

template<auto N1, auto N2, auto N3, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>

auto & tpf::types::cast_ref ( T  array )

inlinenoexcept

Definition at line 621 of file tpf_types.hpp.

cast_ref() [47/50]

template<auto N1, auto N2, typename T , auto N = N1 * N2>

auto & tpf::types::cast_ref ( T(&)  array[N1][N2] )

inlinenoexcept

Definition at line 556 of file tpf_types.hpp.

cast_ref() [48/50]

template<auto N1, auto N2, auto N3, typename T , auto N = N1 * N2* N3>

auto & tpf::types::cast_ref ( T(&)  array[N1][N2][N3] )

inlinenoexcept

Definition at line 586 of file tpf_types.hpp.

cast_ref() [49/50]

template<auto N1, auto N2, typename T , auto N, typename = std::enable_if_t<N1* N2 == N>>

auto & tpf::types::cast_ref ( T(&)  array[N] )

inlinenoexcept

Definition at line 541 of file tpf_types.hpp.

cast_ref() [50/50]

template<auto N1, auto N2, auto N3, typename T , auto N, typename = std::enable_if_t<N1* N2* N3 == N>>

auto & tpf::types::cast_ref ( T(&)  array[N] )

inlinenoexcept

Definition at line 571 of file tpf_types.hpp.

convert_to_array()

template<typename Type , typename... Types, auto Size = sizeof...(Types) + 1, typename common_type = std::common_type_t<Type, Types...>, typename array_type = std::array<common_type, Size>>

auto tpf::types::convert_to_array

(

const std::tuple< Type, Types... > &

tuple

)

Definition at line 5835 of file tpf_types.hpp.

Here is the caller graph for this function:

convert_to_container() [1/3]

template<template< typename, typename... >class ContainerType, typename Type , typename... Types, size_t Size, typename container_type = ContainerType<Type, Types...>>

auto tpf::types::convert_to_container

(

const std::array< Type, Size > &

array

)

Definition at line 5861 of file tpf_types.hpp.

convert_to_container() [2/3]

template<template< typename, typename... >class ContainerType, typename Type , typename... Types, auto Size = sizeof...(Types) + 1, typename common_type = std::common_type_t<Type, Types...>, typename container_type = ContainerType<common_type>>

auto tpf::types::convert_to_container

(

const std::tuple< Type, Types... > &

tuple

)

Definition at line 5845 of file tpf_types.hpp.

convert_to_container() [3/3]

template<typename ContainerType , typename Type , typename... Types, auto Size = sizeof...(Types) + 1>

auto tpf::types::convert_to_container

(

const std::tuple< Type, Types... > &

tuple

)

Definition at line 5853 of file tpf_types.hpp.

convert_to_tuple()

template<typename T , size_t Size>

auto tpf::types::convert_to_tuple

(

const std::array< T, Size > &

array

)

Definition at line 5883 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

create_container()

template<typename ArgType , typename... ArgTypes>

auto tpf::types::create_container	(	ArgType &&	arg,
		ArgTypes &&...	args
	)

Create a container object.

Template Parameters

ArgType
ArgTypes

Parameters

arg
args

Returns

if common type exisits, returns std::array

Definition at line 7458 of file tpf_types.hpp.

Here is the caller graph for this function:

current_type()

template<typename... ElementTypes>

std::string tpf::types::current_type

(

const any< ElementTypes... > &

a

)

Definition at line 561 of file tpf_any.hpp.

Here is the call graph for this function:

decay()

template<typename Type >

decltype(auto) tpf::types::decay

(

Type &&

arg

)

Definition at line 1267 of file tpf_types.hpp.

drive_workhorse() [1/3]

template<size_t Count, typename WorkhorseType >

std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 > > > tpf::types::drive_workhorse

(

WorkhorseType &&

workhorse

)

Definition at line 2946 of file tpf_types.hpp.

Here is the call graph for this function:

drive_workhorse() [2/3]

template<auto RowCount, auto ColumnCount, typename WorkhorseType >

std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 > >||std::is_invocable_v< WorkhorseType, indexer_2d_t< 0, 0 > > > tpf::types::drive_workhorse

(

WorkhorseType &&

workhorse

)

Definition at line 2962 of file tpf_types.hpp.

Here is the call graph for this function:

drive_workhorse() [3/3]

template<auto HeightCount, auto RowCount, auto ColumnCount, typename WorkhorseType >

std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_3d_t< 0, 0, 0 > >||std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 >, indexer_t< 0 > > > tpf::types::drive_workhorse

(

WorkhorseType &&

workhorse

)

Definition at line 2978 of file tpf_types.hpp.

Here is the call graph for this function:

emplace_back()

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

void tpf::types::emplace_back	(	ContainerType< Type, Types... > &	container,
		EleTypes &&...	eles
	)

Definition at line 7150 of file tpf_types.hpp.

Here is the caller graph for this function:

emplace_front()

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

void tpf::types::emplace_front	(	ContainerType< Type, Types... > &	container,
		EleTypes &&...	eles
	)

Definition at line 7132 of file tpf_types.hpp.

erase()

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

auto tpf::types::erase	(	ContainerType< EleType, Types... > &	container,
		size_t	index
	)

Definition at line 7026 of file tpf_types.hpp.

Here is the caller graph for this function:

evaluate_lambdas() [1/2]

template<template< typename, size_t > class ReturnClass, typename FuncType , typename... FuncTypes, typename ArgFirst >

auto tpf::types::evaluate_lambdas	(	const std::tuple< FuncType, FuncTypes... > &	tuple,
		ArgFirst &&	arg
	)

Definition at line 5997 of file tpf_types.hpp.

evaluate_lambdas() [2/2]

template<template< typename, size_t > class ReturnClass, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes>

auto tpf::types::evaluate_lambdas	(	const std::tuple< FuncType, FuncTypes... > &	tuple,
		ArgFirst &&	arg,
		ArgTypes &&...	args
	)

Definition at line 5977 of file tpf_types.hpp.

fn_seq_element()

template<auto N, typename T , T Id, T... Ids>

constexpr T tpf::types::fn_seq_element ( std::integer_sequence< T, Id, Ids... >  )

constexpr

Definition at line 2289 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

for_array()

template<auto... RangeValues, typename FuncType >

auto tpf::types::for_array

(

FuncType &&

f

)

Definition at line 5730 of file tpf_types.hpp.

Here is the call graph for this function:

for_tuple()

template<auto... RangeValues, typename FuncType >

auto tpf::types::for_tuple

(

FuncType &&

f

)

Definition at line 3060 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

for_vector()

template<auto... RangeValues, typename FuncType >

auto tpf::types::for_vector

(

FuncType &&

f

)

Definition at line 5768 of file tpf_types.hpp.

Here is the call graph for this function:

for_workhorse() [1/2]

template<typename TupleType , typename WorkhorseType , typename dummy_sequence = make_sequence_t<StackInOrder, 1>, typename sequence_info = sequence_info_t<true, dummy_sequence>>

std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > &&( std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > >|| std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, sequence_info >)> tpf::types::for_workhorse	(	TupleType &&	tuple,
		WorkhorseType &&	workhorse
	)

Definition at line 3037 of file tpf_types.hpp.

Here is the call graph for this function:

for_workhorse() [2/2]

template<auto... RangeValues, typename WorkhorseType , typename dummy_sequence = make_sequence_t<StackInOrder, 1>, typename sequence_info = sequence_info_t<true, dummy_sequence>>

std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > >|| std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, sequence_info > > tpf::types::for_workhorse

(

WorkhorseType &&

workhorse

)

Definition at line 3026 of file tpf_types.hpp.

Here is the call graph for this function:

freeze_parameter() [1/4]

template<int FuncIndex, int ArgumentIndex, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes, typename = std::enable_if_t< ( FuncIndex < (sizeof...(FuncTypes) + 1) ) && (ArgumentIndex < sizeof...(ArgTypes) + 1 )>>

auto tpf::types::freeze_parameter	(	const std::tuple< FuncType, FuncTypes... > &	func_tuple,
		ArgFirst	arg,
		ArgTypes...	args
	)

Definition at line 5916 of file tpf_types.hpp.

freeze_parameter() [2/4]

template<int FuncIndex, int ArgumentIndex, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes, typename = std::enable_if_t< ( FuncIndex < sizeof...(FuncTypes) + 1 ) && (ArgumentIndex < sizeof...(ArgTypes)+1)>>

auto tpf::types::freeze_parameter	(	const std::tuple< FuncType, FuncTypes... > &	func_tuple,
		const std::tuple< ArgFirst, ArgTypes... > &	arguments
	)

Definition at line 5931 of file tpf_types.hpp.

freeze_parameter() [3/4]

template<int ArgumentIndex, typename FuncType , typename ArgType , typename... ArgTypes, typename = std::enable_if_t< (ArgumentIndex < sizeof...(ArgTypes) + 1) >>

auto tpf::types::freeze_parameter	(	FuncType &&	func,
		ArgType	arg,
		ArgTypes...	args
	)

Definition at line 5890 of file tpf_types.hpp.

Here is the call graph for this function:

freeze_parameter() [4/4]

template<int ArgumentIndex, typename FuncType , typename ArgType , typename... ArgTypes, typename = std::enable_if_t< (ArgumentIndex < sizeof...(ArgTypes) + 1) >>

auto tpf::types::freeze_parameter	(	FuncType &&	func,
		const std::tuple< ArgType, ArgTypes... > &	arguments
	)

Definition at line 5902 of file tpf_types.hpp.

Here is the call graph for this function:

get_element()

template<typename ContainerType , typename IndexType >

decltype(auto) tpf::types::get_element	(	ContainerType	container,
		IndexType	index
	)

Definition at line 7617 of file tpf_types.hpp.

get_nth_argument()

template<auto Index, typename... ArgTypes, typename = std::enable_if_t<(Index < sizeof...(ArgTypes))>>

decltype(auto) tpf::types::get_nth_argument

(

ArgTypes &&...

args

)

Definition at line 942 of file tpf_types.hpp.

get_nth_value()

template<std::size_t KeyIndex, typename Type , auto Index, auto... Indices>

constexpr auto tpf::types::get_nth_value ( std::integer_sequence< Type, Index, Indices... >  )

constexprnoexcept

Definition at line 276 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

get_value()

template<typename Type >

decltype(auto) tpf::types::get_value

(

Type &&

arg

)

Definition at line 371 of file tpf_types.hpp.

if_any_type()

template<typename CurrentType , typename AnyType , typename Handler , typename = std::enable_if<std::is_same_v<remove_cv_ref_t<AnyType>, std::any>>>

void tpf::types::if_any_type	(	AnyType &&	a,
		Handler &&	handler
	)

Definition at line 583 of file tpf_any.hpp.

is_parameter_stack_order_reversed()

bool tpf::types::is_parameter_stack_order_reversed ( )

inline

Definition at line 2670 of file tpf_types.hpp.

Here is the caller graph for this function:

is_stack_in_order()

bool tpf::types::is_stack_in_order ( )

inline

Definition at line 2329 of file tpf_types.hpp.

Here is the call graph for this function:

is_stack_reversed()

bool tpf::types::is_stack_reversed ( )

inline

Definition at line 2319 of file tpf_types.hpp.

Here is the caller graph for this function:

make_container() [1/3]

template<typename ArgType , typename... ArgTypes>

auto tpf::types::make_container	(	ArgType &&	arg,
		ArgTypes &&...	args
	)

create either tuple or vector

Template Parameters

ArgType
ArgTypes

Parameters

arg
args

Returns

if common type exisits, returns std::vector

Definition at line 7390 of file tpf_types.hpp.

make_container() [2/3]

template<template< typename, std::size_t > class ContainerType, typename ArgType , typename... ArgTypes>

auto tpf::types::make_container	(	ArgType &&	arg,
		ArgTypes &&...	args
	)

Definition at line 7410 of file tpf_types.hpp.

make_container() [3/3]

template<typename Type , typename... Types>

auto tpf::types::make_container	(	Type &&	arg,
		Types &&...	args
	)

Here is the caller graph for this function:

make_deque()

template<typename Type , typename... Types>

auto tpf::types::make_deque	(	Type &&	arg,
		Types &&...	args
	)

Definition at line 7337 of file tpf_types.hpp.

Here is the caller graph for this function:

make_overloaded()

template<typename... VisitorTypes>

overloaded< remove_cv_ref_t< VisitorTypes >... > tpf::types::make_overloaded

(

VisitorTypes &&...

visitors

)

Definition at line 186 of file 31-visit.cpp.

Here is the caller graph for this function:

make_overloads()

template<typename... VisitorTypes>

overloaded< remove_cv_ref_t< VisitorTypes >... > tpf::types::make_overloads

(

VisitorTypes &&...

visitors

)

Definition at line 187 of file 31-visit.cpp.

Here is the caller graph for this function:

make_random_access_container()

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

auto tpf::types::make_random_access_container	(	Type &&	arg,
		Types &&...	args
	)

Definition at line 7249 of file tpf_types.hpp.

make_variant_visitors()

template<typename... CallbackTypes>

variant_visitors< remove_cv_ref_t< CallbackTypes >... > tpf::types::make_variant_visitors

(

CallbackTypes &&...

visitors

)

Definition at line 7891 of file tpf_types.hpp.

Here is the caller graph for this function:

make_variants()

template<typename Type , typename... Types>

auto tpf::types::make_variants	(	Type &&	arg,
		Types &&...	args
	)

Definition at line 7479 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_vector()

template<typename Type , typename... Types>

auto tpf::types::make_vector	(	Type &&	arg,
		Types &&...	args
	)

Definition at line 7293 of file tpf_types.hpp.

Here is the caller graph for this function:

operator!=() [1/2]

constexpr bool tpf::types::operator!= ( no_type_t  , no_type_t    )

inlineconstexprnoexcept

Definition at line 2135 of file tpf_types.hpp.

operator!=() [2/2]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, bool > tpf::types::operator!= ( T &&  , no_type_t    )

constexprnoexcept

Definition at line 2143 of file tpf_types.hpp.

operator*() [1/3]

constexpr no_type_t tpf::types::operator* ( no_type_t  , no_type_t    )

inlineconstexprnoexcept

Definition at line 2131 of file tpf_types.hpp.

operator*() [2/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator* ( no_type_t  , T &&    )

constexprnoexcept

Definition at line 2163 of file tpf_types.hpp.

operator*() [3/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator* ( T &&  , no_type_t    )

constexprnoexcept

Definition at line 2167 of file tpf_types.hpp.

operator+() [1/3]

constexpr no_type_t tpf::types::operator+ ( no_type_t  , no_type_t    )

inlineconstexprnoexcept

Definition at line 2129 of file tpf_types.hpp.

operator+() [2/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator+ ( no_type_t  , T &&    )

constexprnoexcept

Definition at line 2147 of file tpf_types.hpp.

operator+() [3/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator+ ( T &&  , no_type_t    )

constexprnoexcept

Definition at line 2151 of file tpf_types.hpp.

operator-() [1/3]

constexpr no_type_t tpf::types::operator- ( no_type_t  , no_type_t    )

inlineconstexprnoexcept

Definition at line 2130 of file tpf_types.hpp.

operator-() [2/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator- ( no_type_t  , T &&    )

constexprnoexcept

Definition at line 2155 of file tpf_types.hpp.

operator-() [3/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator- ( T &&  , no_type_t    )

constexprnoexcept

Definition at line 2159 of file tpf_types.hpp.

operator/() [1/3]

constexpr no_type_t tpf::types::operator/ ( no_type_t  , no_type_t    )

inlineconstexprnoexcept

Definition at line 2132 of file tpf_types.hpp.

operator/() [2/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator/ ( no_type_t  , T &&    )

constexprnoexcept

Definition at line 2171 of file tpf_types.hpp.

operator/() [3/3]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_t > tpf::types::operator/ ( T &&  , no_type_t    )

constexprnoexcept

Definition at line 2175 of file tpf_types.hpp.

operator<<() [1/2]

template<typename CharType >

std::basic_ostream< CharType > & tpf::types::operator<<	(	std::basic_ostream< CharType > &	os,
		const no_type_t &
	)

Definition at line 2027 of file tpf_types.hpp.

operator<<() [2/2]

template<typename Type >

std::ostream & tpf::types::operator<<	(	std::ostream &	os,
		range< Type > const &	r
	)

Definition at line 1450 of file tpf_types.hpp.

operator==() [1/2]

constexpr bool tpf::types::operator== ( no_type_t  , no_type_t    )

inlineconstexprnoexcept

Definition at line 2134 of file tpf_types.hpp.

operator==() [2/2]

template<typename T >

constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, bool > tpf::types::operator== ( no_type_t  , T &&    )

constexprnoexcept

Definition at line 2139 of file tpf_types.hpp.

operator>>()

template<typename CharType >

std::basic_ostream< CharType > & tpf::types::operator>>	(	std::basic_ostream< CharType > &	os,
		const no_type_t &
	)

Definition at line 2038 of file tpf_types.hpp.

overloaded()

template<typename... VisitorTypes>

tpf::types::overloaded

(

VisitorTypes...

)

-> overloaded< VisitorTypes... >

pop_back()

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

auto tpf::types::pop_back

(

ContainerType< Type, Types... > &

container

)

Definition at line 7074 of file tpf_types.hpp.

Here is the caller graph for this function:

pop_front()

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

auto tpf::types::pop_front

(

ContainerType< Type, Types... > &

container

)

Definition at line 7034 of file tpf_types.hpp.

Here is the caller graph for this function:

prepend_to_container()

template<bool bReverseOrder, typename TargetContainerType , typename SourceContainerType >

void tpf::types::prepend_to_container	(	TargetContainerType &	target_container,
		SourceContainerType &&	source_container
	)

Definition at line 7214 of file tpf_types.hpp.

push_back()

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

void tpf::types::push_back	(	ContainerType< Type, Types... > &	container,
		EleType &&	ele
	)

Definition at line 7110 of file tpf_types.hpp.

Here is the caller graph for this function:

push_front()

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

void tpf::types::push_front	(	ContainerType< Type, Types... > &	container,
		EleType &&	ele
	)

Definition at line 7088 of file tpf_types.hpp.

range() [1/2]

template<typename Type >

tpf::types::range

(

Type

)

-> range< Type >

range() [2/2]

template<typename Type >

tpf::types::range	(	Type	,
		Type
	)		-> range< Type >

reverse() [1/3]

template<typename ContainerType >

auto tpf::types::reverse

(

ContainerType &&

container

)

Definition at line 7587 of file tpf_types.hpp.

Here is the caller graph for this function:

reverse() [2/3]

template<typename ElementType , size_t ElementCount>

auto tpf::types::reverse

(

ElementType(&)

array[ElementCount]

)

Definition at line 7595 of file tpf_types.hpp.

reverse() [3/3]

template<typename Type , typename... Types>

auto tpf::types::reverse	(	Type &&	arg,
		Types &&...	args
	)

Definition at line 7605 of file tpf_types.hpp.

Here is the call graph for this function:

reverse_array()

template<typename Type , std::size_t N>

auto tpf::types::reverse_array

(

std::array< Type, N > const &

array

)

Definition at line 5736 of file tpf_types.hpp.

Here is the call graph for this function:

reverse_order()

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

ContainerType< Type, Types... > tpf::types::reverse_order

(

const ContainerType< Type, Types... > &

container

)

Definition at line 7167 of file tpf_types.hpp.

reverse_order_in_place()

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

void tpf::types::reverse_order_in_place

(

ContainerType< Type, Types... > &

container

)

Definition at line 7173 of file tpf_types.hpp.

Here is the caller graph for this function:

reverse_tuple()

template<typename... Types>

auto tpf::types::reverse_tuple

(

std::tuple< Types... > const &

tuple

)

Definition at line 3066 of file tpf_types.hpp.

Here is the call graph for this function:

seq_indices()

template<typename IdType , typename IntType , std::size_t N>

std::array< IntType, N > tpf::types::seq_indices	(	IdType	i,
		std::array< IntType, N > const &	powers
	)

Definition at line 2305 of file tpf_types.hpp.

seq_to_array()

template<typename T , T Id, T... Ids>

auto tpf::types::seq_to_array

(

std::integer_sequence< T, Id, Ids... >

)

Definition at line 2298 of file tpf_types.hpp.

smart_forward() [1/4]

template<class TargetType , class _Ty >

constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, _Ty && > tpf::types::smart_forward ( std::remove_reference_t< _Ty > &&  _Arg )

constexprnoexcept

Definition at line 430 of file tpf_types.hpp.

smart_forward() [2/4]

template<class TargetType , class _Ty >

constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType > tpf::types::smart_forward ( std::remove_reference_t< _Ty > &&  _Arg )

constexprnoexcept

Definition at line 440 of file tpf_types.hpp.

smart_forward() [3/4]

template<class TargetType , class _Ty >

constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, _Ty && > tpf::types::smart_forward ( std::remove_reference_t< _Ty > &  _Arg )

constexprnoexcept

Definition at line 412 of file tpf_types.hpp.

smart_forward() [4/4]

template<class TargetType , class _Ty >

constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType > tpf::types::smart_forward ( std::remove_reference_t< _Ty > &  _Arg )

constexprnoexcept

Definition at line 421 of file tpf_types.hpp.

smart_move() [1/2]

template<class TargetType , class _Ty >

constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, std::remove_reference_t< _Ty > && > tpf::types::smart_move ( _Ty &&  _Arg )

constexprnoexcept

Definition at line 449 of file tpf_types.hpp.

smart_move() [2/2]

template<class TargetType , class _Ty >

constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType > tpf::types::smart_move ( _Ty &&  _Arg )

constexprnoexcept

Definition at line 458 of file tpf_types.hpp.

template_category() [1/2]

template<template< typename... > class TemplateType>

constexpr auto tpf::types::template_category ( )

constexpr

Definition at line 1066 of file tpf_types.hpp.

template_category() [2/2]

template<typename >

constexpr auto tpf::types::template_category (   ... )

constexpr

Definition at line 1078 of file tpf_types.hpp.

to_ref()

template<typename Type >

auto tpf::types::to_ref

(

const Type &

value

)

Definition at line 1234 of file tpf_types.hpp.

Here is the call graph for this function:

tuple_reader()

template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>

decltype(auto) tpf::types::tuple_reader

(

TupleType &&

tuple

)

Definition at line 2755 of file tpf_types.hpp.

tuple_reader_row_column()

template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>

decltype(auto) tpf::types::tuple_reader_row_column

(

TupleType &&

tuple

)

Definition at line 2768 of file tpf_types.hpp.

tuple_writer()

template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>

decltype(auto) tpf::types::tuple_writer

(

TupleType &&

tuple

)

Definition at line 2781 of file tpf_types.hpp.

tuple_writer_row_column()

template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>

decltype(auto) tpf::types::tuple_writer_row_column

(

TupleType &&

tuple

)

Definition at line 2794 of file tpf_types.hpp.

type_to_string() [1/2]

template<typename Type >

std::string tpf::types::type_to_string

(

)

Returns Type's string name.

Template Parameters

Type	— Constraints: NONE

Returns

std::string — if fails, DOES NOT FAIL

See also

001-type_to_string.cpp

Definition at line 1291 of file tpf_types.hpp.

type_to_string() [2/2]

template<typename... Types>

type_list_t< Types... > tpf::types::type_to_string

(

Types &&...

args

)

Definition at line 3161 of file tpf_types.hpp.

variant_to_any()

template<typename Type , typename... Types>

any< Type, Types... > tpf::types::variant_to_any

(

const std::variant< Type, Types... > &

var

)

Definition at line 485 of file tpf_any.hpp.

Here is the call graph for this function:

variant_to_std_any()

template<typename Type , typename... Types>

std::any tpf::types::variant_to_std_any

(

const std::variant< Type, Types... > &

var

)

Definition at line 494 of file tpf_any.hpp.

Here is the call graph for this function:

variant_visitors()

template<typename... CallbackTypes>

tpf::types::variant_visitors

(

CallbackTypes...

)

-> variant_visitors< CallbackTypes... >

visit() [1/4]

template<typename VisitorType , typename PairType >

enable_if_pair_of_variant_t< PairType > tpf::types::visit	(	VisitorType &&	visitor,
		PairType &&	pair
	)

Definition at line 132 of file 31-visit.cpp.

Here is the call graph for this function:

visit() [2/4]

template<typename VisitorType , typename PairType >

enable_if_pair_t< PairType > tpf::types::visit	(	VisitorType &&	visitor,
		PairType &&	pair
	)

Definition at line 112 of file 30-visit.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

visit() [3/4]

template<typename VisitorType , typename VariantType >

enable_if_variant_t< VariantType > tpf::types::visit	(	VisitorType &&	visitor,
		VariantType &&	vt
	)

Definition at line 118 of file 31-visit.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

visit() [4/4]

template<typename VisitorType , typename VariantType >

void tpf::types::visit	(	VisitorType &&	visitor,
		VariantType &&	vt
	)

Definition at line 33 of file 28-visit.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

visit_any()

template<typename Visitors , typename AnyType , typename... ArgTypes>

void tpf::types::visit_any	(	Visitors &&	visitors,
		AnyType &&	a,
		ArgTypes &&...	args
	)

Definition at line 573 of file tpf_any.hpp.

Here is the caller graph for this function:

visit_variant() [1/4]

template<typename VisitorType , typename IteratorType , typename PairType >

std::enable_if_t< is_pair_of_variant_v< remove_cv_ref_t< PairType > > > tpf::types::visit_variant	(	VisitorType &&	visit,
		IteratorType &&	itr,
		PairType &&	vpr
	)

Definition at line 7762 of file tpf_types.hpp.

Here is the call graph for this function:

visit_variant() [2/4]

template<typename VisitorType , typename IteratorType , typename VariantType >

std::enable_if_t< is_variant_v< remove_cv_ref_t< VariantType > > > tpf::types::visit_variant	(	VisitorType &&	visit,
		IteratorType &&	itr,
		VariantType &&	vt
	)

Definition at line 7774 of file tpf_types.hpp.

Here is the call graph for this function:

visit_variant() [3/4]

template<typename VisitorType , typename PairType >

std::enable_if_t< is_pair_of_variant_v< remove_cv_ref_t< PairType > > > tpf::types::visit_variant	(	VisitorType &&	visit,
		PairType &&	vpr
	)

Definition at line 7740 of file tpf_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

visit_variant() [4/4]

template<typename VisitorType , typename VariantType >

std::enable_if_t< is_variant_v< remove_cv_ref_t< VariantType > > > tpf::types::visit_variant	(	VisitorType &&	visit,
		VariantType &&	vt
	)

Definition at line 7751 of file tpf_types.hpp.

Here is the call graph for this function:

Variable Documentation

all_apply_v

template<typename FuncType , typename... TupleTypes>

constexpr bool tpf::types::all_apply_v = ( is_apply_v<FuncType, TupleTypes> && ... )

constexpr

Definition at line 5266 of file tpf_types.hpp.

are_all_in_list_v

template<typename TypeList , typename... TestTypes>

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

constexpr

Definition at line 5053 of file tpf_types.hpp.

are_integers_v

template<typename... Types>

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

constexpr

Definition at line 5056 of file tpf_types.hpp.

are_integrals_v

template<typename... Types>

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

constexpr

Definition at line 5065 of file tpf_types.hpp.

are_numerical_numbers_v

template<typename... Types>

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

constexpr

Definition at line 5077 of file tpf_types.hpp.

are_real_numbers_v

template<typename... Types>

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

constexpr

Definition at line 5074 of file tpf_types.hpp.

are_signed_integers_v

template<typename... Types>

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

constexpr

Definition at line 5059 of file tpf_types.hpp.

are_signed_integrals_v

template<typename... Types>

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

constexpr

Definition at line 5068 of file tpf_types.hpp.

are_unsigned_integers_v

template<typename... Types>

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

constexpr

Definition at line 5062 of file tpf_types.hpp.

are_unsigned_integrals_v

template<typename... Types>

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

constexpr

Definition at line 5071 of file tpf_types.hpp.

common_apply_v

template<typename FuncType , typename... TupleTypes>

constexpr bool tpf::types::common_apply_v

constexpr

Initial value:

= all_apply_v<FuncType, TupleTypes...> &&
                        common_type_v<apply_return_t<FuncType, TupleTypes>...>

Definition at line 5269 of file tpf_types.hpp.

common_type_v

template<typename... Types>

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

constexpr

Definition at line 5137 of file tpf_types.hpp.

has_tuple_common_type_v

template<typename TupleType >

constexpr bool tpf::types::has_tuple_common_type_v = hidden::has_tuple_common_type_v<remove_cvref_t<TupleType>>

constexpr

Definition at line 5699 of file tpf_types.hpp.

InOrderSequence

constexpr bool tpf::types::InOrderSequence = true

inlineconstexpr

Definition at line 2336 of file tpf_types.hpp.

InvalidIndex

constexpr size_t tpf::types::InvalidIndex = type_max_v<size_t>

inlineconstexpr

Definition at line 269 of file tpf_types.hpp.

is_addition_valid_v

template<typename T , typename S >

constexpr bool tpf::types::is_addition_valid_v

constexpr

Initial value:

= 
                hidden::is_addition_valid_v<remove_cvref_t<T>, remove_cvref_t<S>>

Definition at line 2084 of file tpf_types.hpp.

is_all_callable_v

template<typename CallbackType , typename... Types>

constexpr bool tpf::types::is_all_callable_v = types::type_count_v<callable_list_t<CallbackType, Types...>> == types::type_count_v<Types...>

constexpr

Definition at line 6164 of file tpf_types.hpp.

is_any_callable_v

template<typename CallbackType , typename... Types>

constexpr bool tpf::types::is_any_callable_v = types::type_count_v<callable_list_t<CallbackType, Types...>> != 0

constexpr

Definition at line 6167 of file tpf_types.hpp.

is_any_v

template<typename Type >

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

constexpr

Definition at line 1921 of file tpf_types.hpp.

is_apply_v

template<typename FuncType , typename TupleType >

constexpr bool tpf::types::is_apply_v = !is_no_type_v<apply_return_t<FuncType, TupleType>>

constexpr

Definition at line 5263 of file tpf_types.hpp.

is_arithmetic_valid_v

template<typename T , typename S >

constexpr bool tpf::types::is_arithmetic_valid_v

constexpr

Initial value:

= 
                hidden::is_arithmetic_valid_v<remove_cvref_t<T>, remove_cvref_t<S>>

Definition at line 2100 of file tpf_types.hpp.

is_array_v

template<typename Type >

constexpr bool tpf::types::is_array_v = std::is_array_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 1237 of file tpf_types.hpp.

is_assignable_from_the_set_v

template<typename Type , typename ListHead , typename... ListTails>

constexpr bool tpf::types::is_assignable_from_the_set_v

constexpr

Initial value:

= type_opr_over_set_st<boolean::Or, boolean::Left,
            std::add_lvalue_reference_t<Type>, std::is_assignable, ListHead, ListTails...>::value

Definition at line 6402 of file tpf_types.hpp.

is_assignable_to_the_set_v

template<typename Type , typename ListHead , typename... ListTails>

constexpr bool tpf::types::is_assignable_to_the_set_v

constexpr

Initial value:

= type_opr_over_set_st<boolean::Or, boolean::Right,
            std::add_lvalue_reference_t<Type>, std::is_assignable, ListHead, ListTails...>::value

Definition at line 6397 of file tpf_types.hpp.

is_back_available_v

template<typename Type >

constexpr bool tpf::types::is_back_available_v = hidden::is_back_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5392 of file tpf_types.hpp.

is_basic_string_v

template<typename Type >

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

constexpr

Definition at line 1930 of file tpf_types.hpp.

is_begin_available_v

template<typename Type >

constexpr bool tpf::types::is_begin_available_v = hidden::is_begin_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5350 of file tpf_types.hpp.

is_callable_v

template<typename FuncType , typename... ArgTypes>

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

constexpr

Definition at line 5423 of file tpf_types.hpp.

is_capacity_available_v

template<typename Type >

constexpr bool tpf::types::is_capacity_available_v = hidden::is_capacity_available_v<Type>

constexpr

Definition at line 5335 of file tpf_types.hpp.

is_char_v

template<typename Type >

constexpr bool tpf::types::is_char_v = hidden::is_char_v<Type>

constexpr

Definition at line 1878 of file tpf_types.hpp.

is_constrained_any_v

template<typename T >

constexpr bool tpf::types::is_constrained_any_v = hidden::st_is_constrained_any<T>::value

constexpr

Definition at line 55 of file tpf_any.hpp.

is_constructible_over_the_set_v

template<typename Type , typename ListHead , typename... ListTails>

constexpr bool tpf::types::is_constructible_over_the_set_v

constexpr

Initial value:

= type_opr_over_set_st<boolean::Or, boolean::Right,
            Type, std::is_constructible, ListHead, ListTails...>::value

Definition at line 6392 of file tpf_types.hpp.

is_container_type_v

template<typename Type >

constexpr bool tpf::types::is_container_type_v = hidden::is_container_type_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5401 of file tpf_types.hpp.

is_division_valid_v

template<typename T , typename S >

constexpr bool tpf::types::is_division_valid_v

constexpr

Initial value:

= 
                hidden::is_division_valid_v<remove_cvref_t<T>, remove_cvref_t<S>>

Definition at line 2096 of file tpf_types.hpp.

is_emplace_available_v

template<typename Type >

constexpr bool tpf::types::is_emplace_available_v = hidden::is_emplace_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5386 of file tpf_types.hpp.

is_emplace_back_available_v

template<typename Type >

constexpr bool tpf::types::is_emplace_back_available_v = hidden::is_emplace_back_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5383 of file tpf_types.hpp.

is_emplace_front_available_v

template<typename Type >

constexpr bool tpf::types::is_emplace_front_available_v = hidden::is_emplace_front_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5380 of file tpf_types.hpp.

is_empty_available_v

template<typename Type >

constexpr bool tpf::types::is_empty_available_v = hidden::is_empty_available_v<Type>

constexpr

Definition at line 5332 of file tpf_types.hpp.

is_end_available_v

template<typename Type >

constexpr bool tpf::types::is_end_available_v = hidden::is_end_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5353 of file tpf_types.hpp.

is_erase_available_v

template<typename Type >

constexpr bool tpf::types::is_erase_available_v = hidden::is_erase_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5362 of file tpf_types.hpp.

is_front_available_v

template<typename Type >

constexpr bool tpf::types::is_front_available_v = hidden::is_front_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5389 of file tpf_types.hpp.

is_in_list_v

template<typename TestType , typename... Types>

constexpr auto tpf::types::is_in_list_v = hidden::is_in_list_v<TestType, Types...>

constexpr

test if TestType exists in Types...

Template Parameters

TestType	for type to test its existance
Types	for type list to test against

Definition at line 5026 of file tpf_types.hpp.

is_index_operator_available_v

template<typename Type >

constexpr bool tpf::types::is_index_operator_available_v = hidden::is_index_operator_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5341 of file tpf_types.hpp.

is_insert_available_v

template<typename Type >

constexpr bool tpf::types::is_insert_available_v = hidden::is_insert_available_v<Type>

constexpr

Definition at line 5374 of file tpf_types.hpp.

is_insert_iterator_available_v

template<typename Type >

constexpr bool tpf::types::is_insert_iterator_available_v = hidden::is_insert_iterator_available_v<Type>

constexpr

Definition at line 5377 of file tpf_types.hpp.

is_integer_sequence_v

template<typename Type >

constexpr bool tpf::types::is_integer_sequence_v = hidden::is_integer_sequence_v<remove_cvref_t<Type>>

constexpr

Definition at line 1031 of file tpf_types.hpp.

is_integer_v

template<typename Type >

constexpr auto tpf::types::is_integer_v = hidden::is_integer_v<Type>

constexpr

Definition at line 5029 of file tpf_types.hpp.

is_integral_v

template<typename Type >

constexpr auto tpf::types::is_integral_v = hidden::is_integral_v<Type>

constexpr

Definition at line 5038 of file tpf_types.hpp.

is_invocable_v

template<typename CallbackType , typename... Types>

constexpr bool tpf::types::is_invocable_v = hidden::st_is_invocable<CallbackType, Types...>::value

constexpr

Definition at line 6063 of file tpf_types.hpp.

is_iterator_excluding_pointer_v

template<typename T >

constexpr bool tpf::types::is_iterator_excluding_pointer_v

constexpr

Initial value:

= 
            hidden::is_iterator_excluding_pointer_v<remove_cv_ref_t<T>>

Definition at line 3151 of file tpf_types.hpp.

is_iterator_type_v

template<typename T >

constexpr bool tpf::types::is_iterator_type_v = hidden::is_iterator_type_v<remove_cv_ref_t<T>>

constexpr

Definition at line 3148 of file tpf_types.hpp.

is_map_or_unordered_map_v

template<typename Type >

constexpr auto tpf::types::is_map_or_unordered_map_v = hidden::is_map_or_unordered_map_v<Type>

constexpr

Definition at line 1924 of file tpf_types.hpp.

is_multiplication_valid_v

template<typename T , typename S >

constexpr bool tpf::types::is_multiplication_valid_v

constexpr

Initial value:

= 
                hidden::is_multiplication_valid_v<remove_cvref_t<T>, remove_cvref_t<S>>

Definition at line 2092 of file tpf_types.hpp.

is_no_type_v

template<typename Type >

constexpr bool tpf::types::is_no_type_v = std::is_same_v<Type, no_type_t>

constexpr

Definition at line 2027 of file tpf_types.hpp.

is_noexcept_v

template<auto FuncType, typename... ArgTypes>

constexpr auto tpf::types::is_noexcept_v = noexcept(FuncType(std::declval<ArgTypes>()...))

constexpr

Test if a function is specified with the keyword noexcept.

Template Parameters

FuncType
ArgTypes

Definition at line 1673 of file tpf_types.hpp.

is_numbers_type_v

template<typename Type >

constexpr bool tpf::types::is_numbers_type_v = hidden::st_is_numbers_type_v<remove_cvref_t<Type>>::value

constexpr

Definition at line 368 of file tpf_types.hpp.

is_numerical_number_v

template<typename Type >

constexpr auto tpf::types::is_numerical_number_v = hidden::is_numerical_number_v<Type>

constexpr

Definition at line 5050 of file tpf_types.hpp.

is_operable_v

template<typename Type1 , typename Type2 >

constexpr auto tpf::types::is_operable_v = hidden::is_operable_v<Type1, Type2>

constexpr

Definition at line 5119 of file tpf_types.hpp.

is_pair_of_variant_type_v

template<typename Type >

constexpr bool tpf::types::is_pair_of_variant_type_v = is_pair_of_variant_type_st<remove_cv_ref_t<Type>>::value

constexpr

Definition at line 37 of file 31-visit.cpp.

is_pair_of_variant_v

template<typename Type >

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

constexpr

Definition at line 1890 of file tpf_types.hpp.

is_pair_type_v

template<typename Type >

constexpr bool tpf::types::is_pair_type_v = is_pair_type_st<remove_cv_ref_t<Type>>::value

constexpr

Definition at line 21 of file 31-visit.cpp.

is_pair_v

template<typename Type >

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

constexpr

Definition at line 1887 of file tpf_types.hpp.

is_pop_back_available_v

template<typename Type >

constexpr bool tpf::types::is_pop_back_available_v = hidden::is_pop_back_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5398 of file tpf_types.hpp.

is_pop_front_available_v

template<typename Type >

constexpr bool tpf::types::is_pop_front_available_v = hidden::is_pop_front_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5395 of file tpf_types.hpp.

is_push_back_available_v

template<typename Type >

constexpr bool tpf::types::is_push_back_available_v = hidden::is_push_back_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5347 of file tpf_types.hpp.

is_push_front_available_v

template<typename Type >

constexpr bool tpf::types::is_push_front_available_v = hidden::is_push_front_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5344 of file tpf_types.hpp.

is_rbegin_available_v

template<typename Type >

constexpr bool tpf::types::is_rbegin_available_v = hidden::is_rbegin_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5356 of file tpf_types.hpp.

is_real_number_v

template<typename Type >

constexpr auto tpf::types::is_real_number_v = hidden::is_real_number_v<Type>

constexpr

Definition at line 5047 of file tpf_types.hpp.

is_reference_wrapper_v

template<typename Type >

constexpr auto tpf::types::is_reference_wrapper_v = hidden::is_reference_wrapper_v<Type>

constexpr

Definition at line 4975 of file tpf_types.hpp.

is_rend_available_v

template<typename Type >

constexpr bool tpf::types::is_rend_available_v = hidden::is_rend_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5359 of file tpf_types.hpp.

is_reserve_available_v

template<typename Type >

constexpr bool tpf::types::is_reserve_available_v = hidden::is_reserve_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5368 of file tpf_types.hpp.

is_resize_available_v

template<typename Type >

constexpr bool tpf::types::is_resize_available_v = hidden::is_resize_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5365 of file tpf_types.hpp.

is_same_flat_v

template<typename Type , typename... Types>

constexpr auto tpf::types::is_same_flat_v = is_same_v<flat_type_list_t<Type, Types...>>

constexpr

Definition at line 4991 of file tpf_types.hpp.

is_same_template_type_v

template<typename Type1 , typename Type2 >

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

constexpr

Definition at line 3396 of file tpf_types.hpp.

is_same_template_v

template<typename Type1 , typename Type2 >

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

constexpr

Definition at line 3399 of file tpf_types.hpp.

is_same_v

template<typename Type , typename... Types>

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

constexpr

Test if all types are the same.

Template Parameters

Type	for the first type
Types	for the rest of types

Definition at line 4985 of file tpf_types.hpp.

is_set_or_unordered_set_v

template<typename Type >

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

constexpr

Definition at line 1933 of file tpf_types.hpp.

is_shrink_to_fit_available_v

template<typename Type >

constexpr bool tpf::types::is_shrink_to_fit_available_v = hidden::is_shrink_to_fit_available_v<Type>

constexpr

Definition at line 5338 of file tpf_types.hpp.

is_signed_integer_v

template<typename Type >

constexpr auto tpf::types::is_signed_integer_v = hidden::is_signed_integer_v<Type>

constexpr

Definition at line 5032 of file tpf_types.hpp.

is_signed_integral_v

template<typename Type >

constexpr auto tpf::types::is_signed_integral_v = hidden::is_signed_integral_v<Type>

constexpr

Definition at line 5041 of file tpf_types.hpp.

is_size_available_v

template<typename Type >

constexpr bool tpf::types::is_size_available_v = hidden::is_size_available_v<remove_cv_ref_t<Type>>

constexpr

Definition at line 5371 of file tpf_types.hpp.

is_special_type_v

template<typename T >

constexpr bool tpf::types::is_special_type_v = is_constrained_any_v<T> || is_variant_v<T> || types::is_tuple_v<T>

constexpr

Definition at line 58 of file tpf_any.hpp.

is_std_array_v

template<typename Type >

constexpr bool tpf::types::is_std_array_v = hidden::st_is_std_array<remove_cv_ref_t<Type>>::value

constexpr

Definition at line 2208 of file tpf_types.hpp.

is_string_v

template<typename Type >

constexpr auto tpf::types::is_string_v = hidden::is_string_v<Type>

constexpr

Test is Type is of string type.

If Type is one of const char*, const wchar_t*, std::string, std::wstring, Type is_string_v<Type> returns true, otherwise false.

Template Parameters

Type	to test if it is of string category.

Definition at line 3446 of file tpf_types.hpp.

is_subtraction_valid_v

template<typename T , typename S >

constexpr bool tpf::types::is_subtraction_valid_v

constexpr

Initial value:

= 
                hidden::is_subtraction_valid_v<remove_cvref_t<T>, remove_cvref_t<S>>

Definition at line 2088 of file tpf_types.hpp.

is_tag_type_v

template<typename Type >

constexpr bool tpf::types::is_tag_type_v = hidden::is_tag_type_v<remove_cvref_t<Type>>

constexpr

Definition at line 365 of file tpf_types.hpp.

is_template_template_v

template<typename Type >

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

constexpr

Definition at line 6228 of file tpf_types.hpp.

is_template_type_v

template<typename Type >

constexpr bool tpf::types::is_template_type_v = hidden::is_template_type_v<remove_cvref_t<Type>>

constexpr

Definition at line 1118 of file tpf_types.hpp.

is_template_v

template<typename Type >

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

constexpr

Test whether the type parameter is a template type.

Template Parameters

Type	for test whether the type is a template type.

Definition at line 3387 of file tpf_types.hpp.

is_tuple_empty_v

template<typename Type >

constexpr auto tpf::types::is_tuple_empty_v = hidden::is_tuple_empty_v<remove_cvref_t<Type>>

constexpr

Definition at line 1896 of file tpf_types.hpp.

is_tuple_v

template<typename Type >

constexpr auto tpf::types::is_tuple_v = hidden::is_tuple_v<remove_cvref_t<Type>>

constexpr

Definition at line 1893 of file tpf_types.hpp.

is_type_in_list_v

template<typename ArgType , typename... Types>

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

constexpr

Definition at line 5624 of file tpf_types.hpp.

is_type_in_the_set_v

template<typename Type , typename ListHead , typename... ListTails>

constexpr bool tpf::types::is_type_in_the_set_v

constexpr

Initial value:

= type_opr_over_set_st<boolean::Or, boolean::Left,
            Type, std::is_same, ListHead, ListTails...>::value

Definition at line 6387 of file tpf_types.hpp.

is_type_list_equivalent_v

template<typename LeftList , typename RightList >

constexpr auto tpf::types::is_type_list_equivalent_v

constexpr

Initial value:

= 
            hidden::is_type_list_equivalent_v<unique_types_t<LeftList>, unique_types_t<RightList>>

Definition at line 5666 of file tpf_types.hpp.

is_type_list_v

template<typename T >

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

constexpr

Definition at line 1034 of file tpf_types.hpp.

is_unique_ptr_v

template<typename Type >

constexpr auto tpf::types::is_unique_ptr_v = hidden::is_variant_v<Type>

constexpr

Definition at line 1884 of file tpf_types.hpp.

is_unsigned_integer_v

template<typename Type >

constexpr auto tpf::types::is_unsigned_integer_v = hidden::is_unsigned_integer_v<Type>

constexpr

Definition at line 5035 of file tpf_types.hpp.

is_unsigned_integral_v

template<typename Type >

constexpr auto tpf::types::is_unsigned_integral_v = hidden::is_unsigned_integral_v<Type>

constexpr

Definition at line 5044 of file tpf_types.hpp.

is_valid_type_v

template<typename Type >

constexpr bool tpf::types::is_valid_type_v = !is_no_type_v<Type>

constexpr

Definition at line 2127 of file tpf_types.hpp.

is_variant_type_v

template<typename Type >

constexpr bool tpf::types::is_variant_type_v = is_variant_type_st<remove_cv_ref_t<Type>>::value

constexpr

Definition at line 53 of file 31-visit.cpp.

is_variant_v

template<typename Type >

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

constexpr

Definition at line 1881 of file tpf_types.hpp.

is_vector_v

template<typename Type >

constexpr bool tpf::types::is_vector_v = hidden::st_is_vector_v<remove_cvref_t<Type>>::value

constexpr

Definition at line 1028 of file tpf_types.hpp.

is_void_return_type_v

template<typename FuncType , typename... ArgTypes>

constexpr bool tpf::types::is_void_return_type_v = hidden::is_void_return_type_v<FuncType, ArgTypes...>

constexpr

Definition at line 5429 of file tpf_types.hpp.

pairwise_common_type_v

template<typename T , typename... Types>

constexpr bool tpf::types::pairwise_common_type_v = hidden::st_pairwise_common<remove_cvref_t<T>, remove_cvref_t<Types>...>::value

constexpr

Definition at line 5548 of file tpf_types.hpp.

ReverseSequence

constexpr bool tpf::types::ReverseSequence = false

inlineconstexpr

Definition at line 2337 of file tpf_types.hpp.

SelectAll

constexpr size_t tpf::types::SelectAll = InvalidIndex

inlineconstexpr

Definition at line 270 of file tpf_types.hpp.

sequence_element_count_v

template<typename SequenceType >

constexpr auto tpf::types::sequence_element_count_v = hidden::sequence_element_count_v<remove_cvref_t<SequenceType>>

constexpr

Definition at line 2531 of file tpf_types.hpp.

sequence_first_element_v

template<typename SequenceType >

constexpr auto tpf::types::sequence_first_element_v = hidden::sequence_first_element_v<remove_cvref_t<SequenceType>>

constexpr

Definition at line 2522 of file tpf_types.hpp.

sequence_last_element_v

template<typename SequenceType >

constexpr auto tpf::types::sequence_last_element_v = hidden::sequence_last_element_v<remove_cvref_t<SequenceType>>

constexpr

Definition at line 2525 of file tpf_types.hpp.

sequence_nth_element_v

template<auto Nth, typename SequenceType >

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

constexpr

Definition at line 2528 of file tpf_types.hpp.

sequence_span_v

template<typename SequenceType >

constexpr auto tpf::types::sequence_span_v = hidden::sequence_span_v<remove_cvref_t<SequenceType>>

constexpr

Definition at line 2537 of file tpf_types.hpp.

StackInOrder

constexpr bool tpf::types::StackInOrder = true

inlineconstexpr

Definition at line 2334 of file tpf_types.hpp.

std_array_size_v

template<typename Type >

constexpr size_t tpf::types::std_array_size_v = hidden::st_std_array_element<remove_cv_ref_t<Type>>::value

constexpr

Definition at line 2211 of file tpf_types.hpp.

template_parameter_count

template<typename Type >

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

constexpr

Definition at line 3390 of file tpf_types.hpp.

tuple_common_type_v

template<typename T , typename S >

constexpr bool tpf::types::tuple_common_type_v = hidden::st_tuple_common_type<remove_cvref_t<T>, remove_cvref_t<S>>::value

constexpr

Definition at line 5557 of file tpf_types.hpp.

tuple_size_v

template<typename Type >

constexpr auto tpf::types::tuple_size_v = hidden::tuple_size_v<remove_cvref_t<Type>>

constexpr

Definition at line 1918 of file tpf_types.hpp.

type_count_v

template<typename... Types>

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

constexpr

Definition at line 3158 of file tpf_types.hpp.

type_max_v

template<typename Type >

constexpr auto tpf::types::type_max_v = std::numeric_limits<Type>::max()

inlineconstexpr

Definition at line 267 of file tpf_types.hpp.