cpg::types Namespace Reference

Namespaces
namespace	array_tuple_hidden
namespace	hidden

Classes
struct	cHarsTR
class	exit_workhorse
class	fold_visitor
class	fold_visitor< OperationType >
class	fold_visitor< OperationType, DelimiterOpen, DelimiterType, DelimiterClose >
class	fold_visitor< OperationType, DelimiterType >
struct	height_row_column_value
struct	indexer_type
struct	item_index
struct	no_type
struct	nontype_container
struct	range
struct	row_column_value
struct	safe_cast_operation
struct	safe_cast_operation< T >
struct	safe_integral_operation
struct	safe_integral_operation< T >
struct	safe_numerical_operation
struct	safe_numerical_operation< T >
struct	type_container

Concepts
concept	nontype_container_c
concept	numerical_c
concept	arithmetic_c
concept	pointer_c
concept	pointer_callable_c
concept	no_type_c
concept	valid_type_c
concept	resize_available_c
concept	push_back_available_c
concept	common_type_exists_c
concept	same_flat_c
concept	all_same_c
concept	safe_co_c
concept	non_safe_co_c
concept	safe_io_c
concept	non_safe_io_c
concept	safe_no_c
concept	non_safe_no_c
concept	all_the_same_c
concept	all_same_flat_c
concept	all_the_same_flat_c
concept	vector_c
concept	same_container_c
concept	all_different_c
concept	all_different_flat_c
concept	partially_different_c
concept	partially_different_flat_c
concept	type_container_c
concept	non_type_container_c
concept	non_common_vector_c
concept	common_vector_c
concept	is_in_type_container_c
concept	iterator_available_c
concept	reverse_iterator_available_c
concept	view_c
concept	view_flat_c
concept	stl_container_c
concept	std_map_c
concept	tbb_map_c
concept	map_c
concept	stream_undefined_container_c
concept	stream_undefined_container_flat_c
concept	ostream_operator_available_c
concept	const_chars_c
concept	non_const_chars_c
concept	chars_c
concept	non_chars_c
concept	variant_c
concept	variant_flat_c
concept	tuple_c
concept	tuple_flat_c
concept	non_tuple_c
concept	std_array_c
concept	std_array_flat_c
concept	non_std_array_c
concept	either_array_or_tuple_c
concept	either_array_or_tuple_flat_c
concept	neither_array_nor_tuple_c
concept	neither_array_nor_tuple_flat_c
concept	span_c
concept	span_flat_c
concept	non_span_c
concept	std_array_span_c
concept	non_std_array_span_c
concept	c_array_c
concept	c_array_flat_c
concept	pair_c
concept	pair_flat_c
concept	common_std_array_c
concept	row_column_value_c
concept	height_row_column_value_c

Typedefs
template<typename FuncType , typename Type >
using	return_type_t = decltype(return_type(std::declval< FuncType >(), Type{}))
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<auto Index>
using	indexer_t = indexer_type< std::remove_cvref_t< decltype(Index)>, Index >
template<typename T >
using	make_signed_t = typename hidden::st_signed_type< std::remove_cvref_t< T > >::type
template<typename T >
using	make_unsigned_t = typename hidden::st_unsigned_type< std::remove_cvref_t< T > >::type
template<typename... Types>
using	common_signed_t = make_signed_t< std::common_type_t< std::remove_cvref_t< Types >... > >
template<typename... Types>
using	common_unsigned_t = make_unsigned_t< std::common_type_t< std::remove_cvref_t< Types >... > >
template<typename S , typename T >
using	common_container_t = typename hidden::st_common_container< S, T >::type
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 T >
using	first_type_t = typename hidden::st_first_element< std::remove_cvref_t< T > >::type
template<auto... Indices>
using	sequence = std::integer_sequence< std::common_type_t< std::remove_cvref_t< decltype(Indices)>... >, Indices... >
template<typename Type >
using	const_ptr_t = std::add_pointer_t< std::add_const_t< Type > >
template<typename A , typename B >
using	common_vector_t = typename hidden::st_common_vector< std::remove_cvref_t< A >, std::remove_cvref_t< B > >::type
template<typename... Types>
using	pop_front_t = typename hidden::st_pop_front_t< Types... >::type
template<typename... Types>
using	pop_back_t = typename hidden::st_pop_back_t< Types... >::type
using	string_containers = types::type_container< std::string, std::wstring, std::u8string, std::u16string, std::u32string, std::string_view, std::u8string_view, std::u16string_view, std::u32string_view, std::wstring_view >
template<typename... Types>
using	make_unique_types_t = typename hidden::st_make_unique_types< Types... >::type
template<typename VariantType >
using	make_unique_variant_t = decltype(hidden::fn_make_unique_variant(VariantType{}))
template<typename T , T START, T END, T STEP>
using	make_sequence = decltype(hidden::fn_make_sequence< T, START, END, STEP >(std::integer_sequence< T >{}))
template<typename A , typename B >
using	common_std_array_t = typename hidden::st_std_common_array< std::remove_cvref_t< A >, std::remove_cvref_t< B > >::type
template<auto... Indices>
using	create_sequence = typename hidden::st_create_sequence< Indices... >::type
template<auto Row, auto Column, auto Index>
using	row_column_index = row_column_value< decltype(Row), Row, Column, Index >
template<auto Height, auto Row, auto Column, auto Index>
using	height_row_column_index = height_row_column_value< decltype(Height), Height, Row, Column, Index >
template<typename T , T Rows, T Columns>
using	generate_row_column_value = decltype(hidden::generate_row_column_value< T, Rows, Columns >())
template<auto Rows, auto Columns>
using	create_row_column_value_t = decltype(hidden::generate_row_column_value< decltype(Rows), Rows, Columns >())
template<typename T , T Heights, T Rows, T Columns>
using	generate_height_row_column_value = decltype(hidden::generate_height_row_column_value< T, Heights, Rows, Columns >())
template<auto Heights, auto Rows, auto Columns>
using	create_height_row_column_value_t = decltype(generate_height_row_column_value< decltype(Heights), Heights, Rows, Columns >())

Functions
template<typename Type >
constexpr auto	not_a_number () noexcept
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 CharType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, cpg::types::cHarsTR const &charstr)
template<typename OperationType >
	fold_visitor (OperationType) -> fold_visitor< OperationType >
template<typename OperationType , typename DelimiterType >
	fold_visitor (auto, OperationType, DelimiterType) -> fold_visitor< OperationType, DelimiterType >
template<typename OperationType , typename DelimiterOpen , typename DelimiterType , typename DelimiterClose >
	fold_visitor (auto arg_count, OperationType opr, DelimiterOpen d_open, DelimiterType del, DelimiterClose d_close) -> fold_visitor< OperationType, DelimiterOpen, DelimiterType, DelimiterClose >
void	print_args_inorder (auto &&... args)
void	print_args_reverse (auto &&... args)
template<typename Type >
std::string	type_tO_sTring ()
template<typename CharType >
void	display_nontypes (std::basic_ostream< CharType > &os, nontype_container<>) noexcept
template<typename CharType , auto arg, auto... args>
void	display_nontypes (std::basic_ostream< CharType > &os, nontype_container< arg, args... >) noexcept
template<typename CharType , auto... args>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, nontype_container< args... >) noexcept
template<typename CharType , auto... args>
std::basic_ostream< CharType > &	operator>> (std::basic_ostream< CharType > &os, nontype_container< args... > nc) noexcept
template<std::size_t Index, auto arg, auto... args>
constexpr auto	get (nontype_container< arg, args... >) noexcept
template<typename FuncType , typename Type >
constexpr auto	return_type (FuncType func, Type)
template<typename FuncType , typename Type >
constexpr auto	argument_count (FuncType func, Type)
template<typename CharType , typename Type >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, range< Type > const &r)
template<typename Type >
	range (Type) -> range< Type >
template<typename Type >
	range (Type, Type) -> range< Type >
template<pointer_c PointerType, pointer_callable_c< PointerType > FuncType>
auto	raii_create_object (PointerType object_ptr, FuncType func)
template<typename CharType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, no_type const &oh_no)
constexpr auto	difference_absolute (arithmetic_c auto a, arithmetic_c auto b) noexcept
template<std::floating_point T, std::integral S>
constexpr decltype(auto)	numeric_cast (S s)
template<std::signed_integral T, std::unsigned_integral U>
constexpr decltype(auto)	numeric_cast (U u)
template<typename EleType , typename S >
void	truncation_test (S &&s)
template<numerical_c... ArgTypes>
constexpr decltype(auto)	signed_cast (ArgTypes... args)
template<numerical_c... ArgTypes>
constexpr decltype(auto)	unsigned_cast (ArgTypes... args)
template<typename T >
constexpr auto	check_operation_validity (T &&target)
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 > > &&std::common_with< TargetType, _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 > > &&std::common_with< TargetType, _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<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<typename L , typename R >
constexpr auto	operator+ (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<typename L , typename R >
constexpr auto	operator- (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<typename L , typename R >
constexpr auto	operator* (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<typename L , typename R >
constexpr auto	operator/ (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<non_safe_co_c L, typename R >
constexpr auto	operator+ (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	operator+ (safe_cast_operation< L > const &a, R &&b)
template<non_safe_co_c L, typename R >
constexpr auto	operator- (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	operator- (safe_cast_operation< L > const &a, R &&b)
template<non_safe_co_c L, typename R >
constexpr auto	operator* (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	operator* (safe_cast_operation< L > const &a, R &&b)
template<non_safe_co_c L, typename R >
constexpr auto	operator/ (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	operator/ (safe_cast_operation< L > const &a, R &&b)
template<typename L , typename R >
constexpr auto	operator+ (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<typename L , typename R >
constexpr auto	operator- (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<typename L , typename R >
constexpr auto	operator* (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<typename L , typename R >
constexpr auto	operator/ (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<non_safe_io_c L, typename R >
constexpr auto	operator+ (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	operator+ (safe_integral_operation< L > const &a, R &&b)
template<non_safe_io_c L, typename R >
constexpr auto	operator- (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	operator- (safe_integral_operation< L > const &a, R &&b)
template<non_safe_io_c L, typename R >
constexpr auto	operator* (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	operator* (safe_integral_operation< L > const &a, R &&b)
template<non_safe_io_c L, typename R >
constexpr auto	operator/ (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	operator/ (safe_integral_operation< L > const &a, R &&b)
template<typename L , typename R >
constexpr auto	operator+ (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<typename L , typename R >
constexpr auto	operator- (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<typename L , typename R >
constexpr auto	operator* (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<typename L , typename R >
constexpr auto	operator/ (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<non_safe_no_c L, typename R >
constexpr auto	operator+ (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	operator+ (safe_numerical_operation< L > const &a, R &&b)
template<non_safe_no_c L, typename R >
constexpr auto	operator- (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	operator- (safe_numerical_operation< L > const &a, R &&b)
template<non_safe_no_c L, typename R >
constexpr auto	operator* (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	operator* (safe_numerical_operation< L > const &a, R &&b)
template<non_safe_no_c L, typename R >
constexpr auto	operator/ (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	operator/ (safe_numerical_operation< L > const &a, R &&b)
template<long long DebugMode = 2, typename T = int>
constexpr auto	sbo (T &&value) noexcept(!cpg::bDetectOverFlow)
template<typename T >
constexpr decltype(auto)	decay_value (T &&value) noexcept
template<template< typename... > class ContainerType, typename... ArgTypes>
constexpr auto	create_container (ArgTypes &&... args) noexcept
template<all_the_same_flat_c... ArgTypes>
constexpr auto	make_array (ArgTypes &&... args) noexcept
template<typename... ArgTypes>
constexpr auto	make_tuple (ArgTypes &&... args) noexcept
template<typename CharType , typename... Types>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, const type_container< Types... > &tc)
template<typename... Types>
auto	make_vector_of_variants (Types... args)
template<vector_c... ContainerTypes, auto N = sizeof...(ContainerTypes)> requires (N > 0)
constexpr auto	element_counts_are_the_same (ContainerTypes &&... containers)
template<std_array_flat_c... ContainerTypes, auto N = sizeof...(ContainerTypes)> requires (N > 0)
constexpr auto	element_counts_are_the_same (ContainerTypes... containers)
template<std::size_t N, vector_c VectorType>
constexpr decltype(auto)	make_span (VectorType &&v)
template<std_array_flat_c ArrayType>
constexpr decltype(auto)	make_span (ArrayType &&array)
template<typename T , std::size_t N>
constexpr decltype(auto)	make_span (T(&array)[N])
template<typename T , T START, T END, T STEP, T Index>
std::ostream &	operator<< (std::ostream &os, item_index< T, START, END, STEP, Index > const &item)
template<typename CharType , typename T , T Row, T Column, T Index>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, row_column_value< T, Row, Column, Index > const &idx)
template<typename CharType , typename T , T Height, T Row, T Column, T Index>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, height_row_column_value< T, Height, Row, Column, Index > const &idx)
template<std::size_t... Ints, typename FuncType >
auto	for_tuple (FuncType &&f, std::index_sequence< Ints... >)
template<std::size_t... Ints, typename FuncType >
auto	for_tuple (std::index_sequence< Ints... >, FuncType &&f)
template<std::size_t N, typename FuncType >
auto	for_tuple (FuncType &&f)
template<std::size_t... Ints, typename FuncType >
auto	for_array (FuncType &&f, std::index_sequence< Ints... >)
template<std::size_t... Ints, typename FuncType >
auto	for_array (std::index_sequence< Ints... >, FuncType &&f)
template<std::size_t N, typename FuncType >
auto	for_array (FuncType &&f)
template<std::size_t... Ints, typename FuncType >
auto	for_vector (FuncType &&f, std::index_sequence< Ints... >)
template<std::size_t... Ints, typename FuncType >
auto	for_vector (std::index_sequence< Ints... >, FuncType &&f)
template<std::size_t N, typename FuncType >
auto	for_vector (FuncType &&f)
template<typename... Ls, typename... Rs>
constexpr auto	tuple_append (std::tuple< Ls... > const &A, std::tuple< Rs... > const &B) noexcept
template<typename... Ls, typename R , std::size_t N2>
constexpr auto	tuple_append (std::tuple< Ls... > const &A, std::array< R, N2 > const &B) noexcept
template<typename L , std::size_t N1, typename... Rs>
constexpr auto	tuple_append (std::array< L, N1 > const &A, std::tuple< Rs... > const &B) noexcept
template<typename L , std::size_t N1, typename R , std::size_t N2>
constexpr auto	tuple_append (std::array< L, N1 > const &A, std::array< R, N2 > const &B) noexcept
template<typename... Ls, neither_array_nor_tuple_c... ArgTypes>
constexpr auto	tuple_append (std::tuple< Ls... > const &A, ArgTypes &&... args) noexcept
template<typename L , std::size_t N, neither_array_nor_tuple_c... ArgTypes>
constexpr auto	tuple_append (std::array< L, N > const &A, ArgTypes &&... args) noexcept
template<neither_array_nor_tuple_c... Types>
constexpr auto	tuple_append (Types &&... args) noexcept
template<typename ContainerType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename WorkType = std::tuple<>, typename... ArgTypes> requires (tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>) requires { hidden::for_workhorse<long long, 0ll, END, 1ll>(std::forward<ContainerType>(container), std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }
void	for_workhorse (ContainerType &&container, WorkType &&work, ArgTypes &&... args)
template<typename ContainerType = std::tuple<>, typename WorkType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename... ArgTypes> requires (variant_flat_c<ContainerType>|| tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>|| c_array_flat_c<ContainerType>|| pair_flat_c<ContainerType>) requires { hidden::for_workhorse<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }
void	for_workhorse (WorkType &&work, ArgTypes &&... args)
template<int END, typename WorkType , typename... ArgTypes> requires requires { hidden::for_workhorse<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }
void	for_workhorse (WorkType &&work, ArgTypes &&... args)
template<long long START, long long END, typename WorkType , typename... ArgTypes> requires requires { hidden::for_workhorse<long long, START, END, START < END ? 1ll : -1ll>(std::forward<WorkType>(work), make_sequence<long long, START, END, START < END ? 1ll : -1ll>{}, std::forward<ArgTypes>(args)... ); }
void	for_workhorse (WorkType &&work, ArgTypes &&... args)
template<long long START, long long END, long long STEP, typename WorkType , typename... ArgTypes> requires requires { hidden::for_workhorse<long long, START, END, STEP>(std::forward<WorkType>(work), make_sequence<long long, START, END, STEP>{}, std::forward<ArgTypes>(args)... ); }
void	for_workhorse (WorkType &&work, ArgTypes &&... args)
template<typename ContainerType , typename WorkType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename... ArgTypes> requires (variant_flat_c<ContainerType>|| tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>|| c_array_flat_c<ContainerType>|| pair_flat_c<ContainerType>) requires { hidden::for_stallion<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }
constexpr decltype(auto)	for_stallion (WorkType &&work, ArgTypes &&... args)
template<typename ContainerType , typename WorkType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename... ArgTypes> requires (variant_flat_c<ContainerType>|| tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>|| c_array_flat_c<ContainerType>|| pair_flat_c<ContainerType>) requires { hidden::for_stallion<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }
constexpr decltype(auto)	for_stallion (ContainerType &&container, WorkType &&work, ArgTypes &&... args)
template<long long END, typename WorkType , typename... ArgTypes> requires requires { hidden::for_stallion<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }
constexpr decltype(auto)	for_stallion (WorkType &&work, ArgTypes &&... args)
template<long long START, long long END, typename WorkType , typename... ArgTypes> requires requires { hidden::for_stallion<long long, START, END, START < END ? 1ll: -1ll>(std::forward<WorkType>(work), make_sequence<long long, START, END, START < END ? 1ll: -1ll>{}, std::forward<ArgTypes>(args)... ); }
constexpr decltype(auto)	for_stallion (WorkType &&work, ArgTypes &&... args)
template<long long START, long long END, long long STEP, typename WorkType , typename... ArgTypes> requires requires { hidden::for_stallion<long long, START, END, STEP>(std::forward<WorkType>(work), make_sequence<long long, START, END, STEP>{}, std::forward<ArgTypes>(args)... ); }
constexpr decltype(auto)	for_stallion (WorkType &&work, ArgTypes &&... args)
template<auto head, auto... tails>
constexpr auto	drop_head (sequence< head, tails... >)
template<auto left, auto... lefts, auto head, auto... tails>
constexpr auto	compute_multipliers (sequence< left, lefts... > result, sequence< head, tails... >)
template<auto head, auto... tails>
constexpr auto	get_total (sequence< head, tails... >)
template<auto ii, auto head, auto... tails>
constexpr auto	get (sequence< head, tails... >)
template<auto... ms, auto... rs>
constexpr auto	reverse (sequence< ms... > mm, sequence< rs... >)
template<auto kk, auto ii = 0, auto... ms, auto head, auto... indices>
constexpr auto	get_index (sequence< head, indices... > index, sequence< ms... > mm)
template<typename T , T... args>
constexpr auto	create_tuple_sequence (std::integer_sequence< T, args... > dimensions)
template<long long... Ns, typename WorkType , typename... ArgTypes> requires requires { hidden::for_stallion_tuple(std::forward<WorkType>(work), create_tuple_sequence(sequence<Ns...>{}), std::forward<ArgTypes>(args)... ); }
constexpr decltype(auto)	for_stallion_tuple (WorkType &&work, ArgTypes &&... args)
template<tuple_flat_c TupleType>
constexpr decltype(auto)	tuple_to_array (TupleType &&tuple)
template<tuple_flat_c TupleType>
constexpr decltype(auto)	tuple_to_array_recursive (TupleType &&tuple)
template<typename... Types>
auto	reverse_tuple (std::tuple< Types... > const &tuple)
template<typename Type , std::size_t N>
auto	reverse_array (std::array< Type, N > const &array)

Variables
template<typename FuncType , typename TupleType >
constexpr bool	is_apply_v = !no_type_c<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

Typedef Documentation

apply_return_array_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1858 of file cpg_types.hpp.

apply_return_t

template<typename FuncType , typename TupleType >

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

Definition at line 1835 of file cpg_types.hpp.

apply_return_tuple_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1855 of file cpg_types.hpp.

apply_return_vector_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1862 of file cpg_types.hpp.

array_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1873 of file cpg_types.hpp.

common_apply_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1838 of file cpg_types.hpp.

common_container_t

template<typename S , typename T >

using cpg::types::common_container_t = typedef typename hidden::st_common_container<S, T>::type

Definition at line 1808 of file cpg_types.hpp.

common_signed_t

template<typename... Types>

using cpg::types::common_signed_t = typedef make_signed_t< std::common_type_t< std::remove_cvref_t <Types>...> >

Definition at line 1011 of file cpg_types.hpp.

common_std_array_t

template<typename A , typename B >

using cpg::types::common_std_array_t = typedef typename hidden::st_std_common_array<std::remove_cvref_t<A>, std::remove_cvref_t<B> >::type

Definition at line 3561 of file cpg_types.hpp.

common_type_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

using cpg::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 1881 of file cpg_types.hpp.

common_unsigned_t

template<typename... Types>

using cpg::types::common_unsigned_t = typedef make_unsigned_t< std::common_type_t< std::remove_cvref_t <Types>...> >

Definition at line 1015 of file cpg_types.hpp.

common_vector_t

template<typename A , typename B >

using cpg::types::common_vector_t = typedef typename hidden::st_common_vector<std::remove_cvref_t<A>, std::remove_cvref_t<B> >::type

Definition at line 2807 of file cpg_types.hpp.

const_ptr_t

template<typename Type >

using cpg::types::const_ptr_t = typedef std::add_pointer_t<std::add_const_t<Type> >

Definition at line 2668 of file cpg_types.hpp.

create_height_row_column_value_t

template<auto Heights, auto Rows, auto Columns>

using cpg::types::create_height_row_column_value_t = typedef decltype(generate_height_row_column_value<decltype(Heights), Heights, Rows, Columns>())

Definition at line 3931 of file cpg_types.hpp.

create_row_column_value_t

template<auto Rows, auto Columns>

using cpg::types::create_row_column_value_t = typedef decltype(hidden::generate_row_column_value<decltype(Rows), Rows, Columns>())

Definition at line 3923 of file cpg_types.hpp.

create_sequence

template<auto... Indices>

using cpg::types::create_sequence = typedef typename hidden::st_create_sequence<Indices...>::type

Initial value:

{
                requires sizeof...(Indices) == 2

Definition at line 3681 of file cpg_types.hpp.

enable_if_all_apply_t

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

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

Definition at line 1851 of file cpg_types.hpp.

first_type_t

template<typename T >

using cpg::types::first_type_t = typedef typename hidden::st_first_element< std::remove_cvref_t<T> >::type

Definition at line 2643 of file cpg_types.hpp.

generate_height_row_column_value

template<typename T , T Heights, T Rows, T Columns>

using cpg::types::generate_height_row_column_value = typedef decltype(hidden::generate_height_row_column_value<T, Heights, Rows, Columns>())

Definition at line 3927 of file cpg_types.hpp.

generate_row_column_value

template<typename T , T Rows, T Columns>

using cpg::types::generate_row_column_value = typedef decltype(hidden::generate_row_column_value<T, Rows, Columns>())

Definition at line 3920 of file cpg_types.hpp.

height_row_column_index

template<auto Height, auto Row, auto Column, auto Index>

using cpg::types::height_row_column_index = typedef height_row_column_value<decltype(Height), Height, Row, Column, Index>

Definition at line 3708 of file cpg_types.hpp.

index_for

template<typename ... Types>

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

Definition at line 913 of file cpg_types.hpp.

index_t

template<auto Id, auto... Ids>

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

Definition at line 907 of file cpg_types.hpp.

indexer_t

template<auto Index>

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

Definition at line 924 of file cpg_types.hpp.

make_index_t

template<auto N>

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

Definition at line 910 of file cpg_types.hpp.

make_sequence

template<typename T , T START, T END, T STEP>

using cpg::types::make_sequence = typedef decltype( hidden::fn_make_sequence<T, START, END, STEP>( std::integer_sequence<T>{} ) )

Definition at line 3358 of file cpg_types.hpp.

make_signed_t

template<typename T >

using cpg::types::make_signed_t = typedef typename hidden::st_signed_type<std::remove_cvref_t<T> >::type

Definition at line 1005 of file cpg_types.hpp.

make_unique_types_t

template<typename... Types>

using cpg::types::make_unique_types_t = typedef typename hidden::st_make_unique_types<Types...>::type

Definition at line 3166 of file cpg_types.hpp.

make_unique_variant_t

template<typename VariantType >

using cpg::types::make_unique_variant_t = typedef decltype(hidden::fn_make_unique_variant(VariantType{}))

Definition at line 3204 of file cpg_types.hpp.

make_unsigned_t

template<typename T >

using cpg::types::make_unsigned_t = typedef typename hidden::st_unsigned_type<std::remove_cvref_t<T> >::type

Definition at line 1008 of file cpg_types.hpp.

pop_back_t

template<typename... Types>

using cpg::types::pop_back_t = typedef typename hidden::st_pop_back_t<Types...>::type

Definition at line 3008 of file cpg_types.hpp.

pop_front_t

template<typename... Types>

using cpg::types::pop_front_t = typedef typename hidden::st_pop_front_t<Types...>::type

Definition at line 2957 of file cpg_types.hpp.

return_type_t

template<typename FuncType , typename Type >

using cpg::types::return_type_t = typedef decltype(return_type( std::declval<FuncType>(), Type{}))

Definition at line 864 of file cpg_types.hpp.

row_column_index

template<auto Row, auto Column, auto Index>

using cpg::types::row_column_index = typedef row_column_value<decltype(Row), Row, Column, Index>

Definition at line 3695 of file cpg_types.hpp.

sequence

template<auto... Indices>

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

Definition at line 2664 of file cpg_types.hpp.

string_containers

using cpg::types::string_containers = typedef types::type_container<std::string, std::wstring, std::u8string, std::u16string, std::u32string, std::string_view, std::u8string_view, std::u16string_view, std::u32string_view, std::wstring_view>

Definition at line 3093 of file cpg_types.hpp.

tuple_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1869 of file cpg_types.hpp.

vector_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1877 of file cpg_types.hpp.

void_if_all_apply_t

template<typename FuncType , typename... TupleTypes>

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

Definition at line 1866 of file cpg_types.hpp.

Function Documentation

apply_array()

template<typename FuncType , typename... ArgTypes>

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

Definition at line 1901 of file cpg_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... > cpg::types::apply_tuple	(	FuncType &&	f,
		ArgTypes &&...	args
	)

Definition at line 1886 of file cpg_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... > cpg::types::apply_vector	(	FuncType &&	f,
		ArgTypes &&...	args
	)

Definition at line 1893 of file cpg_types.hpp.

Here is the call graph for this function:

argument_count()

template<typename FuncType , typename Type >

constexpr auto cpg::types::argument_count ( FuncType  func, Type    )

constexpr

Definition at line 867 of file cpg_types.hpp.

cast_array() [1/10]

template<typename T , size_t N>

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

inlinenoexcept

Definition at line 1714 of file cpg_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 cpg::types::cast_array ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 1729 of file cpg_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 cpg::types::cast_array ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 1745 of file cpg_types.hpp.

cast_array() [4/10]

template<typename T , size_t N>

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

inlinenoexcept

Definition at line 1721 of file cpg_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 cpg::types::cast_array ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 1737 of file cpg_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 cpg::types::cast_array ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 1753 of file cpg_types.hpp.

cast_array() [7/10]

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

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

inlinenoexcept

Definition at line 1692 of file cpg_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 cpg::types::cast_array ( T(&)  array[N1][N2][N3] )

inlinenoexcept

Definition at line 1707 of file cpg_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 cpg::types::cast_array ( T(&)  array[N] )

inlinenoexcept

Definition at line 1685 of file cpg_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 cpg::types::cast_array ( T(&)  array[N] )

inlinenoexcept

Definition at line 1700 of file cpg_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 & cpg::types::cast_ref ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 1481 of file cpg_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 & cpg::types::cast_ref ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 1497 of file cpg_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 & cpg::types::cast_ref ( std::array< T, N > &  array )

inlinenoexcept

Definition at line 1545 of file cpg_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 & cpg::types::cast_ref ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 1489 of file cpg_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 & cpg::types::cast_ref ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 1505 of file cpg_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 & cpg::types::cast_ref ( std::array< T, N > const &  array )

inlinenoexcept

Definition at line 1553 of file cpg_types.hpp.

cast_ref() [7/50]

template<auto N, typename T , typename Deleter >

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

inlinenoexcept

Definition at line 1296 of file cpg_types.hpp.

cast_ref() [8/50]

template<auto N, typename T , typename Deleter >

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

inlinenoexcept

Definition at line 1308 of file cpg_types.hpp.

cast_ref() [9/50]

template<std::size_t N, typename T >

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

inlinenoexcept

Definition at line 1594 of file cpg_types.hpp.

cast_ref() [10/50]

template<std::size_t N, typename T >

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

inlinenoexcept

Definition at line 1603 of file cpg_types.hpp.

cast_ref() [11/50]

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

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

inlinenoexcept

Definition at line 1453 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1 >  , std::array< T, N > &  array  )

inlinenoexcept

Definition at line 1513 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1 >  , std::array< T, N > const &  array  )

inlinenoexcept

Definition at line 1521 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1, N2 >  , std::array< T, N > &  array  )

inlinenoexcept

Definition at line 1529 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1, N2 >  , std::array< T, N > const &  array  )

inlinenoexcept

Definition at line 1537 of file cpg_types.hpp.

cast_ref() [16/50]

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

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

inlinenoexcept

Definition at line 1320 of file cpg_types.hpp.

cast_ref() [17/50]

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

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

inlinenoexcept

Definition at line 1332 of file cpg_types.hpp.

cast_ref() [18/50]

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

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

inlinenoexcept

Definition at line 1630 of file cpg_types.hpp.

cast_ref() [19/50]

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

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

inlinenoexcept

Definition at line 1639 of file cpg_types.hpp.

cast_ref() [20/50]

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

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

inlinenoexcept

Definition at line 1462 of file cpg_types.hpp.

cast_ref() [21/50]

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

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

inlinenoexcept

Definition at line 1385 of file cpg_types.hpp.

cast_ref() [22/50]

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

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

inlinenoexcept

Definition at line 1371 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::array< T, N > &  array  )

inlinenoexcept

Definition at line 1561 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , std::array< T, N > const &  array  )

inlinenoexcept

Definition at line 1569 of file cpg_types.hpp.

cast_ref() [25/50]

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

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

inlinenoexcept

Definition at line 1344 of file cpg_types.hpp.

cast_ref() [26/50]

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

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

inlinenoexcept

Definition at line 1356 of file cpg_types.hpp.

cast_ref() [27/50]

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

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

inlinenoexcept

Definition at line 1666 of file cpg_types.hpp.

cast_ref() [28/50]

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

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

inlinenoexcept

Definition at line 1675 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , T  array  )

inlinenoexcept

Definition at line 1471 of file cpg_types.hpp.

cast_ref() [30/50]

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

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

inlinenoexcept

Definition at line 1415 of file cpg_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 & cpg::types::cast_ref ( std::index_sequence< N1, N2, N3 >  , T(&)  array[N]  )

inlinenoexcept

Definition at line 1401 of file cpg_types.hpp.

cast_ref() [32/50]

template<auto N, typename T , typename Deleter >

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

inlinenoexcept

Definition at line 1290 of file cpg_types.hpp.

cast_ref() [33/50]

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

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

inlinenoexcept

Definition at line 1314 of file cpg_types.hpp.

cast_ref() [34/50]

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

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

inlinenoexcept

Definition at line 1338 of file cpg_types.hpp.

cast_ref() [35/50]

template<auto N, typename T , typename Deleter >

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

inlinenoexcept

Definition at line 1302 of file cpg_types.hpp.

cast_ref() [36/50]

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

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

inlinenoexcept

Definition at line 1326 of file cpg_types.hpp.

cast_ref() [37/50]

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

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

inlinenoexcept

Definition at line 1350 of file cpg_types.hpp.

cast_ref() [38/50]

template<std::size_t N, typename T >

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

inlinenoexcept

Definition at line 1576 of file cpg_types.hpp.

cast_ref() [39/50]

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

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

inlinenoexcept

Definition at line 1612 of file cpg_types.hpp.

cast_ref() [40/50]

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

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

inlinenoexcept

Definition at line 1648 of file cpg_types.hpp.

cast_ref() [41/50]

template<std::size_t N, typename T >

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

inlinenoexcept

Definition at line 1585 of file cpg_types.hpp.

cast_ref() [42/50]

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

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

inlinenoexcept

Definition at line 1621 of file cpg_types.hpp.

cast_ref() [43/50]

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

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

inlinenoexcept

Definition at line 1657 of file cpg_types.hpp.

cast_ref() [44/50]

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

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

inlinenoexcept

Definition at line 1423 of file cpg_types.hpp.

cast_ref() [45/50]

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

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

inlinenoexcept

Definition at line 1433 of file cpg_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 & cpg::types::cast_ref ( T  array )

inlinenoexcept

Definition at line 1443 of file cpg_types.hpp.

cast_ref() [47/50]

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

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

inlinenoexcept

Definition at line 1378 of file cpg_types.hpp.

cast_ref() [48/50]

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

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

inlinenoexcept

Definition at line 1408 of file cpg_types.hpp.

cast_ref() [49/50]

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

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

inlinenoexcept

Definition at line 1363 of file cpg_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 & cpg::types::cast_ref ( T(&)  array[N] )

inlinenoexcept

Definition at line 1393 of file cpg_types.hpp.

check_operation_validity()

template<typename T >

constexpr auto cpg::types::check_operation_validity ( T &&  target )

constexpr

Definition at line 1217 of file cpg_types.hpp.

Here is the caller graph for this function:

compute_multipliers()

template<auto left, auto... lefts, auto head, auto... tails>

constexpr auto cpg::types::compute_multipliers ( sequence< left, lefts... >  result, sequence< head, tails... >    )

constexpr

Definition at line 4221 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

create_container()

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

constexpr auto cpg::types::create_container ( ArgTypes &&...  args )

constexprnoexcept

Definition at line 2685 of file cpg_types.hpp.

Here is the call graph for this function:

create_tuple_sequence()

template<typename T , T... args>

constexpr auto cpg::types::create_tuple_sequence ( std::integer_sequence< T, args... >  dimensions )

constexpr

Definition at line 4266 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

decay_value()

template<typename T >

constexpr decltype(auto) cpg::types::decay_value ( T &&  value )

constexprnoexcept

Definition at line 2671 of file cpg_types.hpp.

Here is the caller graph for this function:

difference_absolute()

constexpr auto cpg::types::difference_absolute ( arithmetic_c auto  a, arithmetic_c auto  b  )

inlineconstexprnoexcept

Definition at line 1018 of file cpg_types.hpp.

display_nontypes() [1/2]

template<typename CharType , auto arg, auto... args>

void cpg::types::display_nontypes ( std::basic_ostream< CharType > &  os, nontype_container< arg, args... >    )

noexcept

Definition at line 781 of file cpg_types.hpp.

Here is the call graph for this function:

display_nontypes() [2/2]

template<typename CharType >

void cpg::types::display_nontypes ( std::basic_ostream< CharType > &  os, nontype_container<>    )

noexcept

Definition at line 777 of file cpg_types.hpp.

Here is the caller graph for this function:

drop_head()

template<auto head, auto... tails>

constexpr auto cpg::types::drop_head ( sequence< head, tails... >  )

constexpr

Definition at line 4215 of file cpg_types.hpp.

Here is the caller graph for this function:

element_counts_are_the_same() [1/2]

template<vector_c... ContainerTypes, auto N = sizeof...(ContainerTypes)>
requires (N > 0)

constexpr auto cpg::types::element_counts_are_the_same ( ContainerTypes &&...  containers )

constexpr

Definition at line 3427 of file cpg_types.hpp.

Here is the caller graph for this function:

element_counts_are_the_same() [2/2]

template<std_array_flat_c... ContainerTypes, auto N = sizeof...(ContainerTypes)>
requires (N > 0)

constexpr auto cpg::types::element_counts_are_the_same ( ContainerTypes...  containers )

constexpr

Definition at line 3441 of file cpg_types.hpp.

fold_visitor() [1/3]

template<typename OperationType , typename DelimiterOpen , typename DelimiterType , typename DelimiterClose >

cpg::types::fold_visitor	(	auto	arg_count,
		OperationType	opr,
		DelimiterOpen	d_open,
		DelimiterType	del,
		DelimiterClose	d_close
	)		-> fold_visitor< OperationType, DelimiterOpen, DelimiterType, DelimiterClose >

fold_visitor() [2/3]

template<typename OperationType , typename DelimiterType >

cpg::types::fold_visitor	(	auto	,
		OperationType	,
		DelimiterType
	)		-> fold_visitor< OperationType, DelimiterType >

fold_visitor() [3/3]

template<typename OperationType >

cpg::types::fold_visitor

(

OperationType

)

-> fold_visitor< OperationType >

for_array() [1/3]

template<std::size_t N, typename FuncType >

auto cpg::types::for_array

(

FuncType &&

f

)

Definition at line 3787 of file cpg_types.hpp.

Here is the call graph for this function:

for_array() [2/3]

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

auto cpg::types::for_array	(	FuncType &&	f,
		std::index_sequence< Ints... >
	)

Definition at line 3775 of file cpg_types.hpp.

Here is the caller graph for this function:

for_array() [3/3]

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

auto cpg::types::for_array	(	std::index_sequence< Ints... >	,
		FuncType &&	f
	)

Definition at line 3781 of file cpg_types.hpp.

for_stallion() [1/5]

template<typename ContainerType , typename WorkType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename... ArgTypes>
requires (variant_flat_c<ContainerType>|| tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>|| c_array_flat_c<ContainerType>|| pair_flat_c<ContainerType>) requires { hidden::for_stallion<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }

constexpr decltype(auto) cpg::types::for_stallion ( ContainerType &&  container, WorkType &&  work, ArgTypes &&...  args  )

constexpr

Definition at line 4162 of file cpg_types.hpp.

for_stallion() [2/5]

template<typename ContainerType , typename WorkType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename... ArgTypes>
requires (variant_flat_c<ContainerType>|| tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>|| c_array_flat_c<ContainerType>|| pair_flat_c<ContainerType>) requires { hidden::for_stallion<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }

constexpr decltype(auto) cpg::types::for_stallion ( WorkType &&  work, ArgTypes &&...  args  )

constexpr

Definition at line 4143 of file cpg_types.hpp.

Here is the caller graph for this function:

for_stallion() [3/5]

template<long long END, typename WorkType , typename... ArgTypes>
requires requires { hidden::for_stallion<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }

constexpr decltype(auto) cpg::types::for_stallion ( WorkType &&  work, ArgTypes &&...  args  )

constexpr

Definition at line 4175 of file cpg_types.hpp.

for_stallion() [4/5]

template<long long START, long long END, typename WorkType , typename... ArgTypes>
requires requires { hidden::for_stallion<long long, START, END, START < END ? 1ll: -1ll>(std::forward<WorkType>(work), make_sequence<long long, START, END, START < END ? 1ll: -1ll>{}, std::forward<ArgTypes>(args)... ); }

constexpr decltype(auto) cpg::types::for_stallion ( WorkType &&  work, ArgTypes &&...  args  )

constexpr

Definition at line 4187 of file cpg_types.hpp.

Here is the call graph for this function:

for_stallion() [5/5]

template<long long START, long long END, long long STEP, typename WorkType , typename... ArgTypes>
requires requires { hidden::for_stallion<long long, START, END, STEP>(std::forward<WorkType>(work), make_sequence<long long, START, END, STEP>{}, std::forward<ArgTypes>(args)... ); }

constexpr decltype(auto) cpg::types::for_stallion ( WorkType &&  work, ArgTypes &&...  args  )

constexpr

Definition at line 4203 of file cpg_types.hpp.

for_stallion_tuple()

template<long long... Ns, typename WorkType , typename... ArgTypes>
requires requires { hidden::for_stallion_tuple(std::forward<WorkType>(work), create_tuple_sequence(sequence<Ns...>{}), std::forward<ArgTypes>(args)... ); }

constexpr decltype(auto) cpg::types::for_stallion_tuple ( WorkType &&  work, ArgTypes &&...  args  )

constexpr

Definition at line 4293 of file cpg_types.hpp.

Here is the call graph for this function:

for_tuple() [1/3]

template<std::size_t N, typename FuncType >

auto cpg::types::for_tuple

(

FuncType &&

f

)

Definition at line 3769 of file cpg_types.hpp.

Here is the call graph for this function:

for_tuple() [2/3]

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

auto cpg::types::for_tuple	(	FuncType &&	f,
		std::index_sequence< Ints... >
	)

Definition at line 3757 of file cpg_types.hpp.

Here is the caller graph for this function:

for_tuple() [3/3]

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

auto cpg::types::for_tuple	(	std::index_sequence< Ints... >	,
		FuncType &&	f
	)

Definition at line 3763 of file cpg_types.hpp.

for_vector() [1/3]

template<std::size_t N, typename FuncType >

auto cpg::types::for_vector

(

FuncType &&

f

)

Definition at line 3805 of file cpg_types.hpp.

Here is the call graph for this function:

for_vector() [2/3]

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

auto cpg::types::for_vector	(	FuncType &&	f,
		std::index_sequence< Ints... >
	)

Definition at line 3793 of file cpg_types.hpp.

Here is the caller graph for this function:

for_vector() [3/3]

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

auto cpg::types::for_vector	(	std::index_sequence< Ints... >	,
		FuncType &&	f
	)

Definition at line 3799 of file cpg_types.hpp.

for_workhorse() [1/5]

template<typename ContainerType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename WorkType = std::tuple<>, typename... ArgTypes>
requires (tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>) requires { hidden::for_workhorse<long long, 0ll, END, 1ll>(std::forward<ContainerType>(container), std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }

void cpg::types::for_workhorse	(	ContainerType &&	container,
		WorkType &&	work,
		ArgTypes &&...	args
	)

Definition at line 4045 of file cpg_types.hpp.

for_workhorse() [2/5]

template<typename ContainerType = std::tuple<>, typename WorkType = std::tuple<>, long long END = std::tuple_size_v<std::remove_cvref_t<ContainerType>>, typename... ArgTypes>
requires (variant_flat_c<ContainerType>|| tuple_flat_c<ContainerType> || std_array_flat_c<ContainerType>|| c_array_flat_c<ContainerType>|| pair_flat_c<ContainerType>) requires { hidden::for_workhorse<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }

void cpg::types::for_workhorse	(	WorkType &&	work,
		ArgTypes &&...	args
	)

Definition at line 4068 of file cpg_types.hpp.

for_workhorse() [3/5]

template<int END, typename WorkType , typename... ArgTypes>
requires requires { hidden::for_workhorse<long long, 0ll, END, 1ll>(std::forward<WorkType>(work), make_sequence<long long, 0ll, END, 1ll>{}, std::forward<ArgTypes>(args)... ); }

void cpg::types::for_workhorse	(	WorkType &&	work,
		ArgTypes &&...	args
	)

Definition at line 4085 of file cpg_types.hpp.

for_workhorse() [4/5]

template<long long START, long long END, typename WorkType , typename... ArgTypes>
requires requires { hidden::for_workhorse<long long, START, END, START < END ? 1ll : -1ll>(std::forward<WorkType>(work), make_sequence<long long, START, END, START < END ? 1ll : -1ll>{}, std::forward<ArgTypes>(args)... ); }

void cpg::types::for_workhorse	(	WorkType &&	work,
		ArgTypes &&...	args
	)

Definition at line 4102 of file cpg_types.hpp.

Here is the call graph for this function:

for_workhorse() [5/5]

template<long long START, long long END, long long STEP, typename WorkType , typename... ArgTypes>
requires requires { hidden::for_workhorse<long long, START, END, STEP>(std::forward<WorkType>(work), make_sequence<long long, START, END, STEP>{}, std::forward<ArgTypes>(args)... ); }

void cpg::types::for_workhorse	(	WorkType &&	work,
		ArgTypes &&...	args
	)

Definition at line 4120 of file cpg_types.hpp.

get() [1/2]

template<std::size_t Index, auto arg, auto... args>

constexpr auto cpg::types::get ( nontype_container< arg, args... >  )

constexprnoexcept

Definition at line 813 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

get() [2/2]

template<auto ii, auto head, auto... tails>

constexpr auto cpg::types::get ( sequence< head, tails... >  )

constexpr

Definition at line 4239 of file cpg_types.hpp.

Here is the call graph for this function:

get_index()

template<auto kk, auto ii = 0, auto... ms, auto head, auto... indices>

constexpr auto cpg::types::get_index ( sequence< head, indices... >  index, sequence< ms... >  mm  )

constexpr

Definition at line 4254 of file cpg_types.hpp.

get_nth_value()

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

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

constexprnoexcept

Definition at line 241 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

get_total()

template<auto head, auto... tails>

constexpr auto cpg::types::get_total ( sequence< head, tails... >  )

constexpr

Definition at line 4230 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_array()

template<all_the_same_flat_c... ArgTypes>

constexpr auto cpg::types::make_array ( ArgTypes &&...  args )

constexprnoexcept

Definition at line 2698 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_span() [1/3]

template<std_array_flat_c ArrayType>

constexpr decltype(auto) cpg::types::make_span ( ArrayType &&  array )

constexpr

Definition at line 3464 of file cpg_types.hpp.

make_span() [2/3]

template<typename T , std::size_t N>

constexpr decltype(auto) cpg::types::make_span ( T(&)  array[N] )

constexpr

Definition at line 3470 of file cpg_types.hpp.

make_span() [3/3]

template<std::size_t N, vector_c VectorType>

constexpr decltype(auto) cpg::types::make_span ( VectorType &&  v )

constexpr

Definition at line 3457 of file cpg_types.hpp.

make_tuple()

template<typename... ArgTypes>

constexpr auto cpg::types::make_tuple ( ArgTypes &&...  args )

constexprnoexcept

Definition at line 2704 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

make_vector_of_variants()

template<typename... Types>

auto cpg::types::make_vector_of_variants

(

Types...

args

)

Definition at line 3207 of file cpg_types.hpp.

not_a_number()

template<typename Type >

constexpr auto cpg::types::not_a_number ( )

inlineconstexprnoexcept

Definition at line 228 of file cpg_types.hpp.

numeric_cast() [1/2]

template<std::floating_point T, std::integral S>

constexpr decltype(auto) cpg::types::numeric_cast ( S  s )

constexpr

Definition at line 1053 of file cpg_types.hpp.

numeric_cast() [2/2]

template<std::signed_integral T, std::unsigned_integral U>

constexpr decltype(auto) cpg::types::numeric_cast ( U  u )

constexpr

Definition at line 1101 of file cpg_types.hpp.

operator*() [1/9]

template<non_safe_co_c L, typename R >

constexpr auto cpg::types::operator* ( L &&  a, safe_cast_operation< R > const &  b  )

constexpr

Definition at line 2066 of file cpg_types.hpp.

operator*() [2/9]

template<non_safe_io_c L, typename R >

constexpr auto cpg::types::operator* ( L &&  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2299 of file cpg_types.hpp.

operator*() [3/9]

template<non_safe_no_c L, typename R >

constexpr auto cpg::types::operator* ( L &&  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2522 of file cpg_types.hpp.

operator*() [4/9]

template<typename L , non_safe_co_c R>

constexpr auto cpg::types::operator* ( safe_cast_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2072 of file cpg_types.hpp.

operator*() [5/9]

template<typename L , typename R >

constexpr auto cpg::types::operator* ( safe_cast_operation< L > const &  a, safe_cast_operation< R > const &  b  )

constexprnoexcept

Definition at line 1990 of file cpg_types.hpp.

operator*() [6/9]

template<typename L , non_safe_io_c R>

constexpr auto cpg::types::operator* ( safe_integral_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2305 of file cpg_types.hpp.

operator*() [7/9]

template<typename L , typename R >

constexpr auto cpg::types::operator* ( safe_integral_operation< L > const &  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2199 of file cpg_types.hpp.

operator*() [8/9]

template<typename L , non_safe_no_c R>

constexpr auto cpg::types::operator* ( safe_numerical_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2528 of file cpg_types.hpp.

operator*() [9/9]

template<typename L , typename R >

constexpr auto cpg::types::operator* ( safe_numerical_operation< L > const &  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2424 of file cpg_types.hpp.

Here is the call graph for this function:

operator+() [1/9]

template<non_safe_co_c L, typename R >

constexpr auto cpg::types::operator+ ( L &&  a, safe_cast_operation< R > const &  b  )

constexpr

Definition at line 2042 of file cpg_types.hpp.

operator+() [2/9]

template<non_safe_io_c L, typename R >

constexpr auto cpg::types::operator+ ( L &&  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2275 of file cpg_types.hpp.

operator+() [3/9]

template<non_safe_no_c L, typename R >

constexpr auto cpg::types::operator+ ( L &&  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2498 of file cpg_types.hpp.

operator+() [4/9]

template<typename L , non_safe_co_c R>

constexpr auto cpg::types::operator+ ( safe_cast_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2048 of file cpg_types.hpp.

operator+() [5/9]

template<typename L , typename R >

constexpr auto cpg::types::operator+ ( safe_cast_operation< L > const &  a, safe_cast_operation< R > const &  b  )

constexprnoexcept

Definition at line 1938 of file cpg_types.hpp.

operator+() [6/9]

template<typename L , non_safe_io_c R>

constexpr auto cpg::types::operator+ ( safe_integral_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2281 of file cpg_types.hpp.

operator+() [7/9]

template<typename L , typename R >

constexpr auto cpg::types::operator+ ( safe_integral_operation< L > const &  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2120 of file cpg_types.hpp.

Here is the call graph for this function:

operator+() [8/9]

template<typename L , non_safe_no_c R>

constexpr auto cpg::types::operator+ ( safe_numerical_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2504 of file cpg_types.hpp.

operator+() [9/9]

template<typename L , typename R >

constexpr auto cpg::types::operator+ ( safe_numerical_operation< L > const &  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2351 of file cpg_types.hpp.

Here is the call graph for this function:

operator-() [1/9]

template<non_safe_co_c L, typename R >

constexpr auto cpg::types::operator- ( L &&  a, safe_cast_operation< R > const &  b  )

constexpr

Definition at line 2054 of file cpg_types.hpp.

operator-() [2/9]

template<non_safe_io_c L, typename R >

constexpr auto cpg::types::operator- ( L &&  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2287 of file cpg_types.hpp.

operator-() [3/9]

template<non_safe_no_c L, typename R >

constexpr auto cpg::types::operator- ( L &&  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2510 of file cpg_types.hpp.

operator-() [4/9]

template<typename L , non_safe_co_c R>

constexpr auto cpg::types::operator- ( safe_cast_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2060 of file cpg_types.hpp.

operator-() [5/9]

template<typename L , typename R >

constexpr auto cpg::types::operator- ( safe_cast_operation< L > const &  a, safe_cast_operation< R > const &  b  )

constexprnoexcept

Definition at line 1964 of file cpg_types.hpp.

operator-() [6/9]

template<typename L , non_safe_io_c R>

constexpr auto cpg::types::operator- ( safe_integral_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2293 of file cpg_types.hpp.

operator-() [7/9]

template<typename L , typename R >

constexpr auto cpg::types::operator- ( safe_integral_operation< L > const &  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2160 of file cpg_types.hpp.

operator-() [8/9]

template<typename L , non_safe_no_c R>

constexpr auto cpg::types::operator- ( safe_numerical_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2516 of file cpg_types.hpp.

operator-() [9/9]

template<typename L , typename R >

constexpr auto cpg::types::operator- ( safe_numerical_operation< L > const &  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2388 of file cpg_types.hpp.

Here is the call graph for this function:

operator/() [1/9]

template<non_safe_co_c L, typename R >

constexpr auto cpg::types::operator/ ( L &&  a, safe_cast_operation< R > const &  b  )

constexpr

Definition at line 2078 of file cpg_types.hpp.

operator/() [2/9]

template<non_safe_io_c L, typename R >

constexpr auto cpg::types::operator/ ( L &&  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2311 of file cpg_types.hpp.

operator/() [3/9]

template<non_safe_no_c L, typename R >

constexpr auto cpg::types::operator/ ( L &&  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2534 of file cpg_types.hpp.

operator/() [4/9]

template<typename L , non_safe_co_c R>

constexpr auto cpg::types::operator/ ( safe_cast_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2084 of file cpg_types.hpp.

operator/() [5/9]

template<typename L , typename R >

constexpr auto cpg::types::operator/ ( safe_cast_operation< L > const &  a, safe_cast_operation< R > const &  b  )

constexprnoexcept

Definition at line 2016 of file cpg_types.hpp.

operator/() [6/9]

template<typename L , non_safe_io_c R>

constexpr auto cpg::types::operator/ ( safe_integral_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2317 of file cpg_types.hpp.

operator/() [7/9]

template<typename L , typename R >

constexpr auto cpg::types::operator/ ( safe_integral_operation< L > const &  a, safe_integral_operation< R > const &  b  )

constexpr

Definition at line 2238 of file cpg_types.hpp.

operator/() [8/9]

template<typename L , non_safe_no_c R>

constexpr auto cpg::types::operator/ ( safe_numerical_operation< L > const &  a, R &&  b  )

constexpr

Definition at line 2540 of file cpg_types.hpp.

operator/() [9/9]

template<typename L , typename R >

constexpr auto cpg::types::operator/ ( safe_numerical_operation< L > const &  a, safe_numerical_operation< R > const &  b  )

constexpr

Definition at line 2462 of file cpg_types.hpp.

Here is the call graph for this function:

operator<<() [1/8]

template<typename CharType , typename... Types>

std::basic_ostream< CharType > & cpg::types::operator<<	(	std::basic_ostream< CharType > &	os,
		const type_container< Types... > &	tc
	)

Definition at line 2704 of file cpg_types.hpp.

operator<<() [2/8]

template<typename CharType >

std::basic_ostream< CharType > & cpg::types::operator<<	(	std::basic_ostream< CharType > &	os,
		cpg::types::cHarsTR const &	charstr
	)

Definition at line 241 of file cpg_types.hpp.

operator<<() [3/8]

template<typename CharType , typename T , T Height, T Row, T Column, T Index>

std::basic_ostream< CharType > & cpg::types::operator<<	(	std::basic_ostream< CharType > &	os,
		height_row_column_value< T, Height, Row, Column, Index > const &	idx
	)

Definition at line 3630 of file cpg_types.hpp.

operator<<() [4/8]

template<typename CharType >

std::basic_ostream< CharType > & cpg::types::operator<<	(	std::basic_ostream< CharType > &	os,
		no_type const &	oh_no
	)

Definition at line 934 of file cpg_types.hpp.

operator<<() [5/8]

template<typename CharType , auto... args>

std::basic_ostream< CharType > & cpg::types::operator<< ( std::basic_ostream< CharType > &  os, nontype_container< args... >    )

noexcept

Definition at line 781 of file cpg_types.hpp.

operator<<() [6/8]

template<typename CharType , typename Type >

std::basic_ostream< CharType > & cpg::types::operator<<	(	std::basic_ostream< CharType > &	os,
		range< Type > const &	r
	)

Definition at line 867 of file cpg_types.hpp.

operator<<() [7/8]

template<typename CharType , typename T , T Row, T Column, T Index>

std::basic_ostream< CharType > & cpg::types::operator<<	(	std::basic_ostream< CharType > &	os,
		row_column_value< T, Row, Column, Index > const &	idx
	)

Definition at line 3630 of file cpg_types.hpp.

operator<<() [8/8]

template<typename T , T START, T END, T STEP, T Index>

std::ostream & cpg::types::operator<<	(	std::ostream &	os,
		item_index< T, START, END, STEP, Index > const &	item
	)

Definition at line 3630 of file cpg_types.hpp.

operator>>()

template<typename CharType , auto... args>

std::basic_ostream< CharType > & cpg::types::operator>> ( std::basic_ostream< CharType > &  os, nontype_container< args... >  nc  )

noexcept

Definition at line 806 of file cpg_types.hpp.

print_args_inorder()

void cpg::types::print_args_inorder

(

auto &&...

args

)

Definition at line 544 of file cpg_types.hpp.

Here is the call graph for this function:

print_args_reverse()

void cpg::types::print_args_reverse

(

auto &&...

args

)

Definition at line 562 of file cpg_types.hpp.

Here is the call graph for this function:

raii_create_object()

template<pointer_c PointerType, pointer_callable_c< PointerType > FuncType>

auto cpg::types::raii_create_object	(	PointerType	object_ptr,
		FuncType	func
	)

Definition at line 934 of file cpg_types.hpp.

Here is the caller graph for this function:

range() [1/2]

template<typename Type >

cpg::types::range

(

Type

)

-> range< Type >

range() [2/2]

template<typename Type >

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

return_type()

template<typename FuncType , typename Type >

constexpr auto cpg::types::return_type ( FuncType  func, Type    )

constexpr

Definition at line 858 of file cpg_types.hpp.

reverse()

template<auto... ms, auto... rs>

constexpr auto cpg::types::reverse ( sequence< ms... >  mm, sequence< rs... >    )

constexpr

Definition at line 4248 of file cpg_types.hpp.

Here is the caller graph for this function:

reverse_array()

template<typename Type , std::size_t N>

auto cpg::types::reverse_array

(

std::array< Type, N > const &

array

)

Definition at line 4417 of file cpg_types.hpp.

Here is the call graph for this function:

reverse_tuple()

template<typename... Types>

auto cpg::types::reverse_tuple

(

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

tuple

)

Definition at line 4404 of file cpg_types.hpp.

Here is the call graph for this function:

sbo()

template<long long DebugMode = 2, typename T = int>

constexpr auto cpg::types::sbo ( T &&  value )

constexprnoexcept

Definition at line 2549 of file cpg_types.hpp.

Here is the caller graph for this function:

signed_cast()

template<numerical_c... ArgTypes>

constexpr decltype(auto) cpg::types::signed_cast ( ArgTypes...  args )

constexpr

Definition at line 1201 of file cpg_types.hpp.

Here is the caller graph for this function:

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 && > cpg::types::smart_forward ( std::remove_reference_t< _Ty > &&  _Arg )

constexprnoexcept

Definition at line 1255 of file cpg_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 > > &&std::common_with< TargetType, _Ty >, TargetType > cpg::types::smart_forward ( std::remove_reference_t< _Ty > &&  _Arg )

constexprnoexcept

Definition at line 1265 of file cpg_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 && > cpg::types::smart_forward ( std::remove_reference_t< _Ty > &  _Arg )

constexprnoexcept

Definition at line 1237 of file cpg_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 > > &&std::common_with< TargetType, _Ty >, TargetType > cpg::types::smart_forward ( std::remove_reference_t< _Ty > &  _Arg )

constexprnoexcept

Definition at line 1246 of file cpg_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 > && > cpg::types::smart_move ( _Ty &&  _Arg )

constexprnoexcept

Definition at line 1274 of file cpg_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 > cpg::types::smart_move ( _Ty &&  _Arg )

constexprnoexcept

Definition at line 1283 of file cpg_types.hpp.

truncation_test()

template<typename EleType , typename S >

void cpg::types::truncation_test

(

S &&

s

)

Definition at line 1171 of file cpg_types.hpp.

tuple_append() [1/7]

template<typename L , std::size_t N, neither_array_nor_tuple_c... ArgTypes>

constexpr auto cpg::types::tuple_append ( std::array< L, N > const &  A, ArgTypes &&...  args  )

constexprnoexcept

Definition at line 4018 of file cpg_types.hpp.

tuple_append() [2/7]

template<typename L , std::size_t N1, typename R , std::size_t N2>

constexpr auto cpg::types::tuple_append ( std::array< L, N1 > const &  A, std::array< R, N2 > const &  B  )

constexprnoexcept

Definition at line 4000 of file cpg_types.hpp.

Here is the call graph for this function:

tuple_append() [3/7]

template<typename L , std::size_t N1, typename... Rs>

constexpr auto cpg::types::tuple_append ( std::array< L, N1 > const &  A, std::tuple< Rs... > const &  B  )

constexprnoexcept

Definition at line 3993 of file cpg_types.hpp.

Here is the call graph for this function:

tuple_append() [4/7]

template<typename... Ls, neither_array_nor_tuple_c... ArgTypes>

constexpr auto cpg::types::tuple_append ( std::tuple< Ls... > const &  A, ArgTypes &&...  args  )

constexprnoexcept

Definition at line 4006 of file cpg_types.hpp.

Here is the call graph for this function:

tuple_append() [5/7]

template<typename... Ls, typename R , std::size_t N2>

constexpr auto cpg::types::tuple_append ( std::tuple< Ls... > const &  A, std::array< R, N2 > const &  B  )

constexprnoexcept

Definition at line 3986 of file cpg_types.hpp.

Here is the call graph for this function:

tuple_append() [6/7]

template<typename... Ls, typename... Rs>

constexpr auto cpg::types::tuple_append ( std::tuple< Ls... > const &  A, std::tuple< Rs... > const &  B  )

constexprnoexcept

Definition at line 3979 of file cpg_types.hpp.

Here is the call graph for this function:

tuple_append() [7/7]

template<neither_array_nor_tuple_c... Types>

constexpr auto cpg::types::tuple_append ( Types &&...  args )

constexprnoexcept

Definition at line 4030 of file cpg_types.hpp.

tuple_to_array()

template<tuple_flat_c TupleType>

constexpr decltype(auto) cpg::types::tuple_to_array ( TupleType &&  tuple )

constexpr

Definition at line 4392 of file cpg_types.hpp.

Here is the call graph for this function:

tuple_to_array_recursive()

template<tuple_flat_c TupleType>

constexpr decltype(auto) cpg::types::tuple_to_array_recursive ( TupleType &&  tuple )

constexpr

Definition at line 4398 of file cpg_types.hpp.

Here is the call graph for this function:

type_tO_sTring()

template<typename Type >

std::string cpg::types::type_tO_sTring

(

)

Definition at line 618 of file cpg_types.hpp.

unsigned_cast()

template<numerical_c... ArgTypes>

constexpr decltype(auto) cpg::types::unsigned_cast ( ArgTypes...  args )

constexpr

Definition at line 1209 of file cpg_types.hpp.

Variable Documentation

all_apply_v

template<typename FuncType , typename... TupleTypes>

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

constexpr

Definition at line 1844 of file cpg_types.hpp.

common_apply_v

template<typename FuncType , typename... TupleTypes>

constexpr bool cpg::types::common_apply_v

constexpr

Initial value:

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

Definition at line 1847 of file cpg_types.hpp.

is_apply_v

template<typename FuncType , typename TupleType >

constexpr bool cpg::types::is_apply_v = !no_type_c<apply_return_t<FuncType, TupleType>>

constexpr

Definition at line 1841 of file cpg_types.hpp.