cpg::types::hidden Namespace Reference

Classes
struct	st_all_same
struct	st_all_same< P, Types... >
struct	st_all_same<>
struct	st_common_container
struct	st_common_container< ContainerTmpl< S, M >, ContainerTmpl< T, N > >
struct	st_common_container< ContainerTmpl< S, N >, ContainerTmpl< T, N > >
struct	st_common_container< ContainerTmpl< S, S_tail... >, ContainerTmpl< T, T_tail... > >
struct	st_common_container< std::tuple< Ss... >, std::tuple< Ts... > >
struct	st_common_vector
struct	st_common_vector< A, B >
struct	st_common_vector< A, std::vector< B > >
struct	st_common_vector< A, std::vector< std::array< B, N > > >
struct	st_common_vector< std::array< A, N >, std::vector< std::array< B, N > > >
struct	st_common_vector< std::vector< A >, B >
struct	st_common_vector< std::vector< A >, std::vector< B > >
struct	st_common_vector< std::vector< std::array< A, N > >, B >
struct	st_common_vector< std::vector< std::array< A, N > >, std::array< B, N > >
struct	st_common_vector< std::vector< std::array< A, N > >, std::vector< std::array< B, N > > >
struct	st_const_chars
struct	st_const_chars< const char * >
struct	st_const_chars< const char16_t * >
struct	st_const_chars< const char16_t[N]>
struct	st_const_chars< const char32_t * >
struct	st_const_chars< const char32_t[N]>
struct	st_const_chars< const char8_t * >
struct	st_const_chars< const char8_t[N]>
struct	st_const_chars< const char[N]>
struct	st_const_chars< const wchar_t * >
struct	st_const_chars< const wchar_t[N]>
struct	st_create_sequence
struct	st_create_sequence< END >
struct	st_create_sequence< START, END >
struct	st_create_sequence< START, END, STEP >
struct	st_create_sequence<>
struct	st_first_element
struct	st_first_element< ContainerType< T, N > >
struct	st_first_element< ContainerType< T, Types... > >
struct	st_first_element< ContainerType< T, Values... > >
struct	st_height_row_column_value
struct	st_height_row_column_value< height_row_column_value< T, Height, Row, Column, Index > >
struct	st_is_c_array
struct	st_is_c_array< T[N]>
struct	st_is_pair
struct	st_is_pair< std::pair< T, S > >
struct	st_is_span
struct	st_is_span< std::span< T, N > >
struct	st_is_std_array
struct	st_is_std_array< std::array< T, N > >
struct	st_is_tuple
struct	st_is_tuple< std::tuple< Types... > >
struct	st_is_type_container
struct	st_is_type_container< type_container< Types... > >
struct	st_is_variant
struct	st_is_variant< std::variant< Types... > >
struct	st_is_vector
struct	st_is_vector< std::vector< T > >
struct	st_make_unique_types
struct	st_make_unique_types< Type, Types... >
struct	st_make_unique_types< type_container< LeftTypes... >, type_container< First, Second, Tails... > >
struct	st_make_unique_types< type_container< LeftTypes... >, type_container< Head > >
struct	st_make_unique_types< type_container< Types... > >
struct	st_make_unique_types<>
struct	st_non_const_chars
struct	st_non_const_chars< char * >
struct	st_non_const_chars< char16_t * >
struct	st_non_const_chars< char16_t[N]>
struct	st_non_const_chars< char32_t * >
struct	st_non_const_chars< char32_t[N]>
struct	st_non_const_chars< char8_t * >
struct	st_non_const_chars< char8_t[N]>
struct	st_non_const_chars< char[N]>
struct	st_non_const_chars< wchar_t * >
struct	st_non_const_chars< wchar_t[N]>
struct	st_nontype_container
struct	st_nontype_container< nontype_container< args... > >
struct	st_pop_back_t
struct	st_pop_back_t< Type, Types... >
struct	st_pop_back_t< type_container< Types... > >
struct	st_pop_back_t<>
struct	st_pop_front_t
struct	st_pop_front_t< Type, Types... >
struct	st_pop_front_t< type_container< Types... > >
struct	st_pop_front_t<>
struct	st_row_column_value
struct	st_row_column_value< row_column_value< T, Row, Column, Index > >
struct	st_safe_cast_operation
struct	st_safe_cast_operation< safe_cast_operation< T > >
struct	st_safe_integral_operation
struct	st_safe_integral_operation< safe_integral_operation< T > >
struct	st_safe_numerical_operation
struct	st_safe_numerical_operation< safe_numerical_operation< T > >
struct	st_same_container
struct	st_same_container< ContainerType< T1, Tails... >, ContainerType< T2, Tails... > >
struct	st_signed_type
struct	st_signed_type< T >
struct	st_std_common_array
struct	st_std_common_array< A, B >
struct	st_std_common_array< A, std::array< B, N > >
struct	st_std_common_array< std::array< A, M >, std::array< B, N > >
struct	st_std_common_array< std::array< A, N >, B >
struct	st_std_common_array< std::array< A, N >, std::array< B, N > >
struct	st_std_map_container
struct	st_std_map_container< std::map< KeyType, ValueType, Types... > >
struct	st_std_map_container< std::unordered_map< KeyType, ValueType, Types... > >
struct	st_stl_container
struct	st_stl_container< ContainerTemplate< Type, Types... > >
struct	st_tbb_map_container
struct	st_tbb_map_container< tbb::concurrent_map< KeyType, ValueType, Types... > >
struct	st_tbb_map_container< tbb::concurrent_unordered_map< KeyType, ValueType, Types... > >
struct	st_type_in_container
struct	st_type_in_container< P >
struct	st_type_in_container< P, Type, Tails... >
struct	st_type_in_container< P, type_container< Types... >, Tails... >
struct	st_unsigned_type
struct	st_unsigned_type< T >

Concepts
concept	partial_different_c

Functions
template<typename = void>
std::wstring	ascii_conversion (std::string const &str)
template<typename = void>
std::string	ascii_conversion (std::wstring const &str)
template<std::size_t N, typename FuncType , typename Type , typename... Types>
constexpr auto	fn_return_type (FuncType func, type_container< Type, Types... >)
template<std::size_t N, typename FuncType , typename Type , typename... Types>
constexpr auto	argument_count (FuncType func, type_container< Type, Types... >)
template<typename FuncType , typename... ArgTypes>
auto	safe_apply (FuncType &&f, std::tuple< ArgTypes... > const &args) -> decltype(f(std::declval< ArgTypes >()...))
template<typename FuncType , typename ArgType , std::size_t N, std::size_t... Ints>
auto	array_apply (FuncType &&f, std::array< ArgType, N > const &args, std::index_sequence< Ints... >) -> decltype(f(std::get< Ints >(args)...))
template<typename FuncType , typename ArgType , std::size_t N>
auto	safe_apply (FuncType &&f, std::array< ArgType, N > const &args) -> decltype(array_apply(f, args, std::make_index_sequence< N >{}))
template<typename FuncType , typename TupleType >
auto	fn_apply (FuncType &&f, TupleType &&args) -> decltype(safe_apply(f, args))
template<typename P , typename... Types>
consteval bool	fn_all_different ()
template<typename CharType , typename Type , typename... Types>
std::basic_ostream< CharType > &	print_type_container (std::basic_ostream< CharType > &os, const type_container< Type, Types... > &tc)
template<typename... LeftTypes>
constexpr auto	fn_pop_back (type_container< LeftTypes... > left, type_container< > right)
template<typename... LeftTypes, typename Head >
constexpr auto	fn_pop_back (type_container< LeftTypes... > left, type_container< Head > right)
template<typename... LeftTypes, typename First , typename Second , typename... Tails>
constexpr auto	fn_pop_back (type_container< LeftTypes... > left, type_container< First, Second, Tails... > right)
template<typename... Types>
consteval auto	fn_type_container_to_variant (types::type_container< Types... >)
template<typename... Types>
consteval auto	fn_make_unique_variant (std::variant< Types... >)
template<typename T , T START, T END, T STEP, T... Indices>
constexpr auto	fn_make_sequence (std::integer_sequence< T, Indices... > seq)
template<typename T , T START, T END, T STEP>
consteval T	compute_last_index ()
template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes> requires requires { work(item_index<T, START, END, STEP, START>{}, std::forward<ArgTypes>(args)...); }
void	for_workhorse (WorkType &&work, std::integer_sequence< T, Indices... >, ArgTypes &&... args)
template<typename T , T START, T END, T STEP, typename ContainerType , typename WorkType , T... Indices, typename... ArgTypes> requires requires { work( item_index<T, START, END, STEP, START>{}, std::get<START>(std::forward<ContainerType>(container)), std::forward<ArgTypes>(args)...); }
void	for_workhorse (ContainerType &&container, WorkType &&work, std::integer_sequence< T, Indices... >, ArgTypes &&... args)
template<typename T , T START, T END, T STEP, typename ContainerType , typename WorkType , T... Indices, typename... ArgTypes> requires requires { work( std::get<0>(std::forward<ContainerType>(container)), std::forward<ArgTypes>(args)...); }
void	for_workhorse (ContainerType &&container, WorkType &&work, std::integer_sequence< T, Indices... >, ArgTypes &&... args)
template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes> requires requires { work(item_index<T, START, END, STEP, START>{}, sequence<Indices...>{}, std::forward<ArgTypes>(args)...); }
constexpr decltype(auto)	for_stallion (WorkType &&work, std::integer_sequence< T, Indices... >, ArgTypes &&... args)
template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes> requires requires { work(sequence<Indices...>{}, item_index<T, START, END, STEP, START>{}, std::forward<ArgTypes>(args)...); }
constexpr decltype(auto)	for_stallion (WorkType &&work, std::integer_sequence< T, Indices... >, ArgTypes &&... args)
template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes> requires requires { work(sequence<Indices...>{}, std::forward<ArgTypes>(args)...); }
constexpr decltype(auto)	for_stallion (WorkType &&work, std::integer_sequence< T, Indices... >, ArgTypes &&... args)
template<typename T , T Rows, T Columns>
constexpr auto	generate_row_column_value ()
template<typename T , T Heights, T Rows, T Columns>
constexpr auto	generate_height_row_column_value ()
template<typename... Ls, typename... Rs, auto... Li, auto... Ri>
constexpr auto	tuple_append (std::tuple< Ls... > const &A, sequence< Li... >, std::tuple< Rs... > const &B, sequence< Ri... >) noexcept
template<typename... Ls, typename R , auto... Li, std::size_t N, auto... Ri>
constexpr auto	tuple_append (std::tuple< Ls... > const &A, sequence< Li... >, std::array< R, N > const &B, sequence< Ri... >) noexcept
template<typename L , std::size_t N, typename... Rs, auto... Li, auto... Ri>
constexpr auto	tuple_append (std::array< L, N > const &A, sequence< Li... >, std::tuple< Rs... > const &B, sequence< Ri... >) noexcept
template<typename L , std::size_t N1, typename R , std::size_t N2, auto... Li, auto... Ri>
constexpr auto	tuple_append (std::array< L, N1 > const &A, sequence< Li... >, std::array< R, N2 > const &B, sequence< Ri... >) noexcept
template<typename WorkType , typename ... Indices, typename... ArgTypes> requires requires { work(indices, std::forward<ArgTypes>(args)...); }
constexpr decltype(auto)	for_stallion_tuple (WorkType &&work, std::tuple< Indices... > indices, ArgTypes &&... args)

Variables
no_type	array_apply (...)
no_type	safe_apply (...)
no_type	fn_apply (...)

Function Documentation

argument_count()

template<std::size_t N, typename FuncType , typename Type , typename... Types>

constexpr auto cpg::types::hidden::argument_count ( FuncType  func, type_container< Type, Types... >    )

constexpr

Definition at line 844 of file cpg_types.hpp.

array_apply()

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

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

ascii_conversion() [1/2]

template<typename = void>

std::wstring cpg::types::hidden::ascii_conversion

(

std::string const &

str

)

Definition at line 262 of file cpg_types.hpp.

Here is the caller graph for this function:

ascii_conversion() [2/2]

template<typename = void>

std::string cpg::types::hidden::ascii_conversion

(

std::wstring const &

str

)

Definition at line 274 of file cpg_types.hpp.

compute_last_index()

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

consteval T cpg::types::hidden::compute_last_index

(

)

Definition at line 3597 of file cpg_types.hpp.

fn_all_different()

template<typename P , typename... Types>

consteval bool cpg::types::hidden::fn_all_different

(

)

Definition at line 2588 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

fn_apply()

template<typename FuncType , typename TupleType >

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

fn_make_sequence()

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

constexpr auto cpg::types::hidden::fn_make_sequence ( std::integer_sequence< T, Indices... >  seq )

constexpr

Definition at line 3258 of file cpg_types.hpp.

fn_make_unique_variant()

template<typename... Types>

consteval auto cpg::types::hidden::fn_make_unique_variant

(

std::variant< Types... >

)

Definition at line 3185 of file cpg_types.hpp.

Here is the call graph for this function:

fn_pop_back() [1/3]

template<typename... LeftTypes>

constexpr auto cpg::types::hidden::fn_pop_back ( type_container< LeftTypes... >  left, type_container< >  right  )

constexpr

Definition at line 2962 of file cpg_types.hpp.

Here is the caller graph for this function:

fn_pop_back() [2/3]

template<typename... LeftTypes, typename First , typename Second , typename... Tails>

constexpr auto cpg::types::hidden::fn_pop_back ( type_container< LeftTypes... >  left, type_container< First, Second, Tails... >  right  )

constexpr

Definition at line 2979 of file cpg_types.hpp.

Here is the call graph for this function:

fn_pop_back() [3/3]

template<typename... LeftTypes, typename Head >

constexpr auto cpg::types::hidden::fn_pop_back ( type_container< LeftTypes... >  left, type_container< Head >  right  )

constexpr

Definition at line 2970 of file cpg_types.hpp.

fn_return_type()

template<std::size_t N, typename FuncType , typename Type , typename... Types>

constexpr auto cpg::types::hidden::fn_return_type ( FuncType  func, type_container< Type, Types... >    )

constexpr

Definition at line 833 of file cpg_types.hpp.

fn_type_container_to_variant()

template<typename... Types>

consteval auto cpg::types::hidden::fn_type_container_to_variant

(

types::type_container< Types... >

)

Definition at line 3179 of file cpg_types.hpp.

Here is the caller graph for this function:

for_stallion() [1/3]

template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes>
requires requires { work(item_index<T, START, END, STEP, START>{}, sequence<Indices...>{}, std::forward<ArgTypes>(args)...); }

constexpr decltype(auto) cpg::types::hidden::for_stallion ( WorkType &&  work, std::integer_sequence< T, Indices... >  , ArgTypes &&...  args  )

constexpr

Definition at line 3858 of file cpg_types.hpp.

Here is the caller graph for this function:

for_stallion() [2/3]

template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes>
requires requires { work(sequence<Indices...>{}, item_index<T, START, END, STEP, START>{}, std::forward<ArgTypes>(args)...); }

constexpr decltype(auto) cpg::types::hidden::for_stallion ( WorkType &&  work, std::integer_sequence< T, Indices... >  , ArgTypes &&...  args  )

constexpr

Definition at line 3872 of file cpg_types.hpp.

for_stallion() [3/3]

template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes>
requires requires { work(sequence<Indices...>{}, std::forward<ArgTypes>(args)...); }

constexpr decltype(auto) cpg::types::hidden::for_stallion ( WorkType &&  work, std::integer_sequence< T, Indices... >  , ArgTypes &&...  args  )

constexpr

Definition at line 3886 of file cpg_types.hpp.

for_stallion_tuple()

template<typename WorkType , typename ... Indices, typename... ArgTypes>
requires requires { work(indices, std::forward<ArgTypes>(args)...); }

constexpr decltype(auto) cpg::types::hidden::for_stallion_tuple ( WorkType &&  work, std::tuple< Indices... >  indices, ArgTypes &&...  args  )

constexpr

Definition at line 4282 of file cpg_types.hpp.

Here is the caller graph for this function:

for_workhorse() [1/3]

template<typename T , T START, T END, T STEP, typename ContainerType , typename WorkType , T... Indices, typename... ArgTypes>
requires requires { work( item_index<T, START, END, STEP, START>{}, std::get<START>(std::forward<ContainerType>(container)), std::forward<ArgTypes>(args)...); }

void cpg::types::hidden::for_workhorse	(	ContainerType &&	container,
		WorkType &&	work,
		std::integer_sequence< T, Indices... >	,
		ArgTypes &&...	args
	)

Definition at line 3826 of file cpg_types.hpp.

for_workhorse() [2/3]

template<typename T , T START, T END, T STEP, typename ContainerType , typename WorkType , T... Indices, typename... ArgTypes>
requires requires { work( std::get<0>(std::forward<ContainerType>(container)), std::forward<ArgTypes>(args)...); }

void cpg::types::hidden::for_workhorse	(	ContainerType &&	container,
		WorkType &&	work,
		std::integer_sequence< T, Indices... >	,
		ArgTypes &&...	args
	)

Definition at line 3842 of file cpg_types.hpp.

for_workhorse() [3/3]

template<typename T , T START, T END, T STEP, typename WorkType , T... Indices, typename... ArgTypes>
requires requires { work(item_index<T, START, END, STEP, START>{}, std::forward<ArgTypes>(args)...); }

void cpg::types::hidden::for_workhorse	(	WorkType &&	work,
		std::integer_sequence< T, Indices... >	,
		ArgTypes &&...	args
	)

Definition at line 3814 of file cpg_types.hpp.

Here is the caller graph for this function:

generate_height_row_column_value()

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

constexpr auto cpg::types::hidden::generate_height_row_column_value ( )

constexpr

Definition at line 3907 of file cpg_types.hpp.

Here is the call graph for this function:

generate_row_column_value()

template<typename T , T Rows, T Columns>

constexpr auto cpg::types::hidden::generate_row_column_value ( )

constexpr

Definition at line 3897 of file cpg_types.hpp.

Here is the call graph for this function:

print_type_container()

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

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

Definition at line 2840 of file cpg_types.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

safe_apply() [1/2]

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

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

safe_apply() [2/2]

template<typename FuncType , typename... ArgTypes>

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

tuple_append() [1/4]

template<typename L , std::size_t N, typename... Rs, auto... Li, auto... Ri>

constexpr auto cpg::types::hidden::tuple_append ( std::array< L, N > const &  A, sequence< Li... >  , std::tuple< Rs... > const &  B, sequence< Ri... >    )

constexprnoexcept

Definition at line 3957 of file cpg_types.hpp.

tuple_append() [2/4]

template<typename L , std::size_t N1, typename R , std::size_t N2, auto... Li, auto... Ri>

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

constexprnoexcept

Definition at line 3967 of file cpg_types.hpp.

tuple_append() [3/4]

template<typename... Ls, typename R , auto... Li, std::size_t N, auto... Ri>

constexpr auto cpg::types::hidden::tuple_append ( std::tuple< Ls... > const &  A, sequence< Li... >  , std::array< R, N > const &  B, sequence< Ri... >    )

constexprnoexcept

Definition at line 3947 of file cpg_types.hpp.

tuple_append() [4/4]

template<typename... Ls, typename... Rs, auto... Li, auto... Ri>

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

constexprnoexcept

Definition at line 3937 of file cpg_types.hpp.

Here is the caller graph for this function:

Variable Documentation

array_apply

no_type cpg::types::hidden::array_apply(...)

(

...

)

fn_apply

no_type cpg::types::hidden::fn_apply(...)

(

...

)

safe_apply

no_type cpg::types::hidden::safe_apply(...)

(

...

)