cpg_types.hpp File Reference

#include <iostream>
#include <memory>
#include <ranges>
#include <algorithm>
#include <concepts>
#include <type_traits>
#include <variant>
#include <vector>
#include <set>
#include <map>
#include <array>
#include <memory_resource>
#include <deque>
#include <unordered_set>
#include <unordered_map>
#include <tuple>
#include <list>
#include <string>
#include <string_view>
#include <cstring>
#include <optional>
#include <thread>
#include <mutex>
#include <execution>
#include <sstream>
#include <cstddef>
#include <span>
#include <numbers>
#include <cassert>
#include <tbb/tbb.h>

Include dependency graph for cpg_types.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	std::tuple_size< T[N] >
struct	std::tuple_size< const T[N] >
struct	std::tuple_size< T(&)[N] >
struct	std::tuple_size< const T(&)[N] >
struct	std::tuple_size< T(&&)[N] >
struct	std::tuple_size< const T(&&)[N] >
struct	std::tuple_size< std::variant< Ts... > >
struct	std::tuple_size< const std::variant< Ts... > >
struct	std::tuple_size< std::variant< Ts... > & >
struct	std::tuple_size< const std::variant< Ts... > & >
struct	std::tuple_size< std::variant< Ts... > && >
struct	std::tuple_size< const std::variant< Ts... > && >
struct	cpg::hidden::flush
struct	cpg::hidden::clear
struct	cpg::hidden::endl
struct	cpg::hidden::endL
struct	cpg::types::cHarsTR
class	cpg::types::fold_visitor< OperationType, DelimiterType >
class	cpg::types::fold_visitor< OperationType, DelimiterOpen, DelimiterType, DelimiterClose >
class	cpg::types::fold_visitor< OperationType >
class	cpg::debug_exception
struct	cpg::types::nontype_container< args >
struct	cpg::types::hidden::st_nontype_container< Type >
struct	cpg::types::hidden::st_nontype_container< nontype_container< args... > >
struct	cpg::types::no_type
struct	cpg::types::type_container< Types >
struct	cpg::types::range< Type >
struct	cpg::types::indexer_type< T, Value >
struct	cpg::types::hidden::st_signed_type< T >
struct	cpg::types::hidden::st_unsigned_type< T >
struct	cpg::types::hidden::st_common_container< S, T >
struct	cpg::types::hidden::st_common_container< ContainerTmpl< S, S_tail... >, ContainerTmpl< T, T_tail... > >
struct	cpg::types::hidden::st_common_container< ContainerTmpl< S, M >, ContainerTmpl< T, N > >
struct	cpg::types::hidden::st_common_container< ContainerTmpl< S, N >, ContainerTmpl< T, N > >
struct	cpg::types::hidden::st_common_container< std::tuple< Ss... >, std::tuple< Ts... > >
struct	cpg::types::safe_cast_operation< T >
struct	cpg::types::safe_cast_operation< T >
struct	cpg::types::hidden::st_safe_cast_operation< T >
struct	cpg::types::hidden::st_safe_cast_operation< safe_cast_operation< T > >
struct	cpg::types::safe_integral_operation< T >
struct	cpg::types::safe_integral_operation< T >
struct	cpg::types::hidden::st_safe_integral_operation< T >
struct	cpg::types::hidden::st_safe_integral_operation< safe_integral_operation< T > >
struct	cpg::types::safe_numerical_operation< T >
struct	cpg::types::safe_numerical_operation< T >
struct	cpg::types::hidden::st_safe_numerical_operation< T >
struct	cpg::types::hidden::st_safe_numerical_operation< safe_numerical_operation< T > >
struct	cpg::types::hidden::st_all_same<>
struct	cpg::types::hidden::st_all_same< P, Types... >
struct	cpg::types::hidden::st_same_container< T, S >
struct	cpg::types::hidden::st_same_container< ContainerType< T1, Tails... >, ContainerType< T2, Tails... > >
struct	cpg::types::hidden::st_is_vector< T >
struct	cpg::types::hidden::st_is_vector< std::vector< T > >
struct	cpg::types::hidden::st_first_element< T >
struct	cpg::types::hidden::st_first_element< ContainerType< T, Types... > >
struct	cpg::types::hidden::st_first_element< ContainerType< T, Values... > >
struct	cpg::types::hidden::st_first_element< ContainerType< T, N > >
struct	cpg::types::hidden::st_is_type_container< typename >
struct	cpg::types::hidden::st_is_type_container< type_container< Types... > >
struct	cpg::types::hidden::st_common_vector< A, B >
struct	cpg::types::hidden::st_common_vector< A, B >
struct	cpg::types::hidden::st_common_vector< std::vector< A >, std::vector< B > >
struct	cpg::types::hidden::st_common_vector< std::vector< A >, B >
struct	cpg::types::hidden::st_common_vector< A, std::vector< B > >
struct	cpg::types::hidden::st_common_vector< std::vector< std::array< A, N > >, std::vector< std::array< B, N > > >
struct	cpg::types::hidden::st_common_vector< A, std::vector< std::array< B, N > > >
struct	cpg::types::hidden::st_common_vector< std::vector< std::array< A, N > >, B >
struct	cpg::types::hidden::st_common_vector< std::vector< std::array< A, N > >, std::array< B, N > >
struct	cpg::types::hidden::st_common_vector< std::array< A, N >, std::vector< std::array< B, N > > >
struct	cpg::types::hidden::st_type_in_container< P >
struct	cpg::types::hidden::st_type_in_container< P, Type, Tails... >
struct	cpg::types::hidden::st_type_in_container< P, type_container< Types... >, Tails... >
struct	cpg::types::hidden::st_pop_front_t<>
struct	cpg::types::hidden::st_pop_front_t< Type, Types... >
struct	cpg::types::hidden::st_pop_front_t< type_container< Types... > >
struct	cpg::types::hidden::st_pop_back_t<>
struct	cpg::types::hidden::st_pop_back_t< Type, Types... >
struct	cpg::types::hidden::st_pop_back_t< type_container< Types... > >
struct	cpg::types::hidden::st_stl_container< T >
struct	cpg::types::hidden::st_stl_container< ContainerTemplate< Type, Types... > >
struct	cpg::types::hidden::st_std_map_container< T >
struct	cpg::types::hidden::st_std_map_container< std::map< KeyType, ValueType, Types... > >
struct	cpg::types::hidden::st_std_map_container< std::unordered_map< KeyType, ValueType, Types... > >
struct	cpg::types::hidden::st_tbb_map_container< T >
struct	cpg::types::hidden::st_tbb_map_container< tbb::concurrent_map< KeyType, ValueType, Types... > >
struct	cpg::types::hidden::st_tbb_map_container< tbb::concurrent_unordered_map< KeyType, ValueType, Types... > >
struct	cpg::types::hidden::st_make_unique_types<>
struct	cpg::types::hidden::st_make_unique_types< Type, Types... >
struct	cpg::types::hidden::st_make_unique_types< type_container< Types... > >
struct	cpg::types::hidden::st_make_unique_types< type_container< LeftTypes... >, type_container< Head > >
struct	cpg::types::hidden::st_make_unique_types< type_container< LeftTypes... >, type_container< First, Second, Tails... > >
struct	cpg::types::hidden::st_is_variant< T >
struct	cpg::types::hidden::st_is_variant< std::variant< Types... > >
struct	cpg::types::hidden::st_is_tuple< T >
struct	cpg::types::hidden::st_is_tuple< std::tuple< Types... > >
struct	cpg::types::hidden::st_is_std_array< T >
struct	cpg::types::hidden::st_is_std_array< std::array< T, N > >
struct	cpg::types::hidden::st_is_span< T >
struct	cpg::types::hidden::st_is_span< std::span< T, N > >
struct	cpg::types::hidden::st_is_c_array< T >
struct	cpg::types::hidden::st_is_c_array< T[N]>
struct	cpg::types::hidden::st_is_pair< T >
struct	cpg::types::hidden::st_is_pair< std::pair< T, S > >
struct	cpg::types::hidden::st_const_chars< T >
struct	cpg::types::hidden::st_const_chars< const char[N]>
struct	cpg::types::hidden::st_const_chars< const wchar_t[N]>
struct	cpg::types::hidden::st_const_chars< const char * >
struct	cpg::types::hidden::st_const_chars< const wchar_t * >
struct	cpg::types::hidden::st_const_chars< const char8_t[N]>
struct	cpg::types::hidden::st_const_chars< const char8_t * >
struct	cpg::types::hidden::st_const_chars< const char16_t[N]>
struct	cpg::types::hidden::st_const_chars< const char16_t * >
struct	cpg::types::hidden::st_const_chars< const char32_t[N]>
struct	cpg::types::hidden::st_const_chars< const char32_t * >
struct	cpg::types::hidden::st_non_const_chars< T >
struct	cpg::types::hidden::st_non_const_chars< char[N]>
struct	cpg::types::hidden::st_non_const_chars< wchar_t[N]>
struct	cpg::types::hidden::st_non_const_chars< char * >
struct	cpg::types::hidden::st_non_const_chars< wchar_t * >
struct	cpg::types::hidden::st_non_const_chars< char8_t[N]>
struct	cpg::types::hidden::st_non_const_chars< char8_t * >
struct	cpg::types::hidden::st_non_const_chars< char16_t[N]>
struct	cpg::types::hidden::st_non_const_chars< char16_t * >
struct	cpg::types::hidden::st_non_const_chars< char32_t[N]>
struct	cpg::types::hidden::st_non_const_chars< char32_t * >
struct	cpg::types::hidden::st_std_common_array< A, B >
struct	cpg::types::hidden::st_std_common_array< A, B >
struct	cpg::types::hidden::st_std_common_array< std::array< A, N >, std::array< B, N > >
struct	cpg::types::hidden::st_std_common_array< std::array< A, N >, B >
struct	cpg::types::hidden::st_std_common_array< A, std::array< B, N > >
struct	cpg::types::hidden::st_std_common_array< std::array< A, M >, std::array< B, N > >
class	cpg::types::exit_workhorse< ArgTypes >
struct	cpg::types::item_index< T, START, END, STEP, Index >
struct	cpg::types::hidden::st_create_sequence<>
struct	cpg::types::hidden::st_create_sequence< END >
struct	cpg::types::hidden::st_create_sequence< START, END >
struct	cpg::types::hidden::st_create_sequence< START, END, STEP >
struct	cpg::types::row_column_value< T, Row, Column, Index >
struct	cpg::types::height_row_column_value< T, Height, Row, Column, Index >
struct	cpg::types::hidden::st_row_column_value< T >
struct	cpg::types::hidden::st_row_column_value< row_column_value< T, Row, Column, Index > >
struct	cpg::types::hidden::st_height_row_column_value< T >
struct	cpg::types::hidden::st_height_row_column_value< height_row_column_value< T, Height, Row, Column, Index > >

Namespaces
namespace	std
namespace	cpg
	Includes subnamespace conversion.
namespace	cpg::literals
namespace	cpg::hidden
namespace	cpg::types
namespace	cpg::types::hidden
namespace	cpg::types::array_tuple_hidden

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

Macros
#define	NOMINMAX
#define	TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS   1
#define	TBB_SUPPRESS_DEPRECATED_MESSAGES   1
#define	CPG_SAFE_OPERATION   2LL
#define	CpgSafe(arg)   arg
#define	Cpg_CharStr(asciistr)   cpg::types::cHarsTR{asciistr, L##asciistr}
#define	Cpg_GetTypeName(type_arg, ...)    cpg::types::type_tO_sTring<type_arg, ##__VA_ARGS__>()
#define	Cpg_GetTypeCategory(instance_arg, ...)    cpg::types::type_tO_sTring<decltype(instance_arg, ##__VA_ARGS__)>()
#define	Cpg_DebugException(debug_message)   cpg::debug_exception{debug_message, __LINE__, __FILE__}
#define	Cpg_ThrowDebugException(debug_message)   throw cpg::debug_exception{debug_message, __LINE__, __FILE__}
#define	Tpf_TestTrunction(TargetType, SourceValue)

Typedefs
using	cpg::big_integer_t = long long
using	cpg::big_unsigned_t = unsigned long long
template<typename FuncType , typename Type >
using	cpg::types::return_type_t = decltype(return_type(std::declval< FuncType >(), Type{}))
template<auto Id, auto... Ids>
using	cpg::types::index_t = std::index_sequence<(std::size_t) Id,(std::size_t) Ids... >
template<auto N>
using	cpg::types::make_index_t = std::make_index_sequence<(std::size_t) N >
template<typename ... Types>
using	cpg::types::index_for = std::make_index_sequence< sizeof...(Types)>
template<auto Index>
using	cpg::types::indexer_t = indexer_type< std::remove_cvref_t< decltype(Index)>, Index >
template<typename T >
using	cpg::types::make_signed_t = typename hidden::st_signed_type< std::remove_cvref_t< T > >::type
template<typename T >
using	cpg::types::make_unsigned_t = typename hidden::st_unsigned_type< std::remove_cvref_t< T > >::type
template<typename... Types>
using	cpg::types::common_signed_t = make_signed_t< std::common_type_t< std::remove_cvref_t< Types >... > >
template<typename... Types>
using	cpg::types::common_unsigned_t = make_unsigned_t< std::common_type_t< std::remove_cvref_t< Types >... > >
template<typename S , typename T >
using	cpg::types::common_container_t = typename hidden::st_common_container< S, T >::type
template<typename FuncType , typename TupleType >
using	cpg::types::apply_return_t = decltype(hidden::fn_apply(std::declval< FuncType >(), std::declval< TupleType >()))
template<typename FuncType , typename... TupleTypes>
using	cpg::types::common_apply_t = std::common_type_t< apply_return_t< FuncType, TupleTypes >... >
template<typename ReturnType , typename FuncType , typename... TupleTypes>
using	cpg::types::enable_if_all_apply_t = std::enable_if_t< all_apply_v< FuncType, TupleTypes... >, ReturnType >
template<typename FuncType , typename... TupleTypes>
using	cpg::types::apply_return_tuple_t = std::tuple< apply_return_t< FuncType, TupleTypes > ... >
template<typename FuncType , typename... TupleTypes>
using	cpg::types::apply_return_array_t = std::array< std::common_type_t< apply_return_t< FuncType, TupleTypes >... >, sizeof...(TupleTypes)>
template<typename FuncType , typename... TupleTypes>
using	cpg::types::apply_return_vector_t = std::vector< std::common_type_t< apply_return_t< FuncType, TupleTypes >... > >
template<typename FuncType , typename... TupleTypes>
using	cpg::types::void_if_all_apply_t = enable_if_all_apply_t< void, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	cpg::types::tuple_if_all_apply_t = enable_if_all_apply_t< apply_return_tuple_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	cpg::types::array_if_all_apply_t = enable_if_all_apply_t< apply_return_array_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	cpg::types::vector_if_all_apply_t = enable_if_all_apply_t< apply_return_vector_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
template<typename FuncType , typename... TupleTypes>
using	cpg::types::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	cpg::types::first_type_t = typename hidden::st_first_element< std::remove_cvref_t< T > >::type
template<auto... Indices>
using	cpg::types::sequence = std::integer_sequence< std::common_type_t< std::remove_cvref_t< decltype(Indices)>... >, Indices... >
template<typename Type >
using	cpg::types::const_ptr_t = std::add_pointer_t< std::add_const_t< Type > >
template<typename A , typename B >
using	cpg::types::common_vector_t = typename hidden::st_common_vector< std::remove_cvref_t< A >, std::remove_cvref_t< B > >::type
template<typename... Types>
using	cpg::types::pop_front_t = typename hidden::st_pop_front_t< Types... >::type
template<typename... Types>
using	cpg::types::pop_back_t = typename hidden::st_pop_back_t< Types... >::type
using	cpg::types::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	cpg::types::make_unique_types_t = typename hidden::st_make_unique_types< Types... >::type
template<typename VariantType >
using	cpg::types::make_unique_variant_t = decltype(hidden::fn_make_unique_variant(VariantType{}))
template<typename T , T START, T END, T STEP>
using	cpg::types::make_sequence = decltype(hidden::fn_make_sequence< T, START, END, STEP >(std::integer_sequence< T >{}))
template<typename A , typename B >
using	cpg::types::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	cpg::types::create_sequence = typename hidden::st_create_sequence< Indices... >::type
template<auto Row, auto Column, auto Index>
using	cpg::types::row_column_index = row_column_value< decltype(Row), Row, Column, Index >
template<auto Height, auto Row, auto Column, auto Index>
using	cpg::types::height_row_column_index = height_row_column_value< decltype(Height), Height, Row, Column, Index >
template<typename T , T Rows, T Columns>
using	cpg::types::generate_row_column_value = decltype(hidden::generate_row_column_value< T, Rows, Columns >())
template<auto Rows, auto Columns>
using	cpg::types::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	cpg::types::generate_height_row_column_value = decltype(hidden::generate_height_row_column_value< T, Heights, Rows, Columns >())
template<auto Heights, auto Rows, auto Columns>
using	cpg::types::create_height_row_column_value_t = decltype(generate_height_row_column_value< decltype(Heights), Heights, Rows, Columns >())

Functions
constexpr std::size_t	cpg::literals::operator""_size_t (unsigned long long value)
constexpr unsigned int	cpg::literals::operator""_unsigned (unsigned long long value)
constexpr short	cpg::literals::operator""_short (unsigned long long value)
constexpr unsigned short	cpg::literals::operator""_ushort (unsigned long long value)
constexpr char	cpg::literals::operator""_char (unsigned long long value)
constexpr char	cpg::literals::operator""_schar (unsigned long long value)
constexpr unsigned char	cpg::literals::operator""_uchar (unsigned long long value)
constexpr long double	cpg::literals::operator""_ldouble (long double value)
template<typename Type >
constexpr auto	cpg::types::not_a_number () noexcept
template<std::size_t KeyIndex, typename Type , auto Index, auto... Indices>
constexpr auto	cpg::types::get_nth_value (std::integer_sequence< Type, Index, Indices... >) noexcept
template<typename = void>
std::wstring	cpg::types::hidden::ascii_conversion (std::string const &str)
template<typename = void>
std::string	cpg::types::hidden::ascii_conversion (std::wstring const &str)
template<typename CharType >
std::basic_ostream< CharType > &	cpg::types::operator<< (std::basic_ostream< CharType > &os, cpg::types::cHarsTR const &charstr)
template<typename OperationType >
	cpg::types::fold_visitor (OperationType) -> fold_visitor< OperationType >
template<typename OperationType , typename DelimiterType >
	cpg::types::fold_visitor (auto, OperationType, DelimiterType) -> fold_visitor< OperationType, DelimiterType >
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 >
void	cpg::types::print_args_inorder (auto &&... args)
void	cpg::types::print_args_reverse (auto &&... args)
template<typename Type >
std::string	cpg::types::type_tO_sTring ()
template<typename CharType >
void	cpg::types::display_nontypes (std::basic_ostream< CharType > &os, nontype_container<>) noexcept
template<typename CharType , auto arg, auto... args>
void	cpg::types::display_nontypes (std::basic_ostream< CharType > &os, nontype_container< arg, args... >) noexcept
template<typename CharType , auto... args>
std::basic_ostream< CharType > &	cpg::types::operator<< (std::basic_ostream< CharType > &os, nontype_container< args... >) noexcept
template<typename CharType , auto... args>
std::basic_ostream< CharType > &	cpg::types::operator>> (std::basic_ostream< CharType > &os, nontype_container< args... > nc) noexcept
template<std::size_t Index, auto arg, auto... args>
constexpr auto	cpg::types::get (nontype_container< arg, args... >) noexcept
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... >)
template<std::size_t N, typename FuncType , typename Type , typename... Types>
constexpr auto	cpg::types::hidden::argument_count (FuncType func, type_container< Type, Types... >)
template<typename FuncType , typename Type >
constexpr auto	cpg::types::return_type (FuncType func, Type)
template<typename FuncType , typename Type >
constexpr auto	cpg::types::argument_count (FuncType func, Type)
template<typename CharType , typename Type >
std::basic_ostream< CharType > &	cpg::types::operator<< (std::basic_ostream< CharType > &os, range< Type > const &r)
template<typename Type >
	cpg::types::range (Type) -> range< Type >
template<typename Type >
	cpg::types::range (Type, Type) -> range< Type >
template<pointer_c PointerType, pointer_callable_c< PointerType > FuncType>
auto	cpg::types::raii_create_object (PointerType object_ptr, FuncType func)
template<typename CharType >
std::basic_ostream< CharType > &	cpg::types::operator<< (std::basic_ostream< CharType > &os, no_type const &oh_no)
constexpr auto	cpg::types::difference_absolute (arithmetic_c auto a, arithmetic_c auto b) noexcept
template<std::floating_point T, std::integral S>
constexpr decltype(auto)	cpg::types::numeric_cast (S s)
template<std::signed_integral T, std::unsigned_integral U>
constexpr decltype(auto)	cpg::types::numeric_cast (U u)
template<typename EleType , typename S >
void	cpg::types::truncation_test (S &&s)
template<numerical_c... ArgTypes>
constexpr decltype(auto)	cpg::types::signed_cast (ArgTypes... args)
template<numerical_c... ArgTypes>
constexpr decltype(auto)	cpg::types::unsigned_cast (ArgTypes... args)
template<typename T >
constexpr auto	cpg::types::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 && >	cpg::types::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 >	cpg::types::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 && >	cpg::types::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 >	cpg::types::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 > && >	cpg::types::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 >	cpg::types::smart_move (_Ty &&_Arg) noexcept
template<auto N, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::index_sequence< N >, std::unique_ptr< T[], Deleter > &uptr) noexcept
template<auto N, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::index_sequence< N >, std::unique_ptr< T[], Deleter > const &uptr) noexcept
template<auto N1, auto N2, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
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) noexcept
template<auto N1, auto N2, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
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) noexcept
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
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) noexcept
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto &	cpg::types::cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
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) noexcept
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]) noexcept
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]) noexcept
template<auto N1, auto N2, typename T , auto N = N1 * N2>
auto &	cpg::types::cast_ref (T(&array)[N1][N2]) noexcept
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]) noexcept
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]) noexcept
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]) noexcept
template<auto N1, auto N2, auto N3, typename T , auto N = N1 * N2* N3>
auto &	cpg::types::cast_ref (T(&array)[N1][N2][N3]) noexcept
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]) noexcept
template<auto N, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cpg::types::cast_ref (T array) noexcept
template<auto N1, auto N2, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto &	cpg::types::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 &	cpg::types::cast_ref (T array) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) 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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::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 &	cpg::types::cast_ref (std::index_sequence< N1, N2, N3 >, std::array< T, N > const &array) noexcept
template<std::size_t N, typename T >
auto &	cpg::types::cast_ref (std::vector< T > &vctr) noexcept
template<std::size_t N, typename T >
auto &	cpg::types::cast_ref (std::vector< T > const &vctr) noexcept
template<std::size_t N, typename T >
auto &	cpg::types::cast_ref (std::index_sequence< N >, std::vector< T > &vctr) noexcept
template<std::size_t N, typename T >
auto &	cpg::types::cast_ref (std::index_sequence< N >, std::vector< T > const &vctr) noexcept
template<std::size_t N1, std::size_t N2, typename T >
auto &	cpg::types::cast_ref (std::vector< T > &vctr) noexcept
template<std::size_t N1, std::size_t N2, typename T >
auto &	cpg::types::cast_ref (std::vector< T > const &vctr) noexcept
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) noexcept
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) noexcept
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto &	cpg::types::cast_ref (std::vector< T > &vctr) noexcept
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) noexcept
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) noexcept
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) noexcept
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]) noexcept
template<size_t N1, size_t N2, typename T , size_t N = N1 * N2>
auto	cpg::types::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	cpg::types::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	cpg::types::cast_array (T(&array)[N1][N2][N3]) noexcept
template<typename T , size_t N>
auto	cpg::types::cast_array (std::array< T, N > &array) noexcept
template<typename T , size_t N>
auto	cpg::types::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	cpg::types::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	cpg::types::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	cpg::types::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	cpg::types::cast_array (std::array< T, N > const &array) noexcept
template<typename FuncType , typename... ArgTypes>
auto	cpg::types::hidden::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	cpg::types::hidden::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	cpg::types::hidden::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	cpg::types::hidden::fn_apply (FuncType &&f, TupleType &&args) -> decltype(safe_apply(f, args))
template<typename FuncType , typename... ArgTypes>
types::tuple_if_all_apply_t< FuncType, ArgTypes... >	cpg::types::apply_tuple (FuncType &&f, ArgTypes &&... args)
template<typename FuncType , typename... ArgTypes>
types::vector_if_all_apply_t< FuncType, ArgTypes... >	cpg::types::apply_vector (FuncType &&f, ArgTypes &&... args)
template<typename FuncType , typename... ArgTypes>
types::array_if_all_apply_t< FuncType, ArgTypes... >	cpg::types::apply_array (FuncType &&f, ArgTypes &&... args)
template<typename L , typename R >
constexpr auto	cpg::types::operator+ (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<typename L , typename R >
constexpr auto	cpg::types::operator- (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<typename L , typename R >
constexpr auto	cpg::types::operator* (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<typename L , typename R >
constexpr auto	cpg::types::operator/ (safe_cast_operation< L > const &a, safe_cast_operation< R > const &b) noexcept
template<non_safe_co_c L, typename R >
constexpr auto	cpg::types::operator+ (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	cpg::types::operator+ (safe_cast_operation< L > const &a, R &&b)
template<non_safe_co_c L, typename R >
constexpr auto	cpg::types::operator- (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	cpg::types::operator- (safe_cast_operation< L > const &a, R &&b)
template<non_safe_co_c L, typename R >
constexpr auto	cpg::types::operator* (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	cpg::types::operator* (safe_cast_operation< L > const &a, R &&b)
template<non_safe_co_c L, typename R >
constexpr auto	cpg::types::operator/ (L &&a, safe_cast_operation< R > const &b)
template<typename L , non_safe_co_c R>
constexpr auto	cpg::types::operator/ (safe_cast_operation< L > const &a, R &&b)
template<typename L , typename R >
constexpr auto	cpg::types::operator+ (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<typename L , typename R >
constexpr auto	cpg::types::operator- (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<typename L , typename R >
constexpr auto	cpg::types::operator* (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<typename L , typename R >
constexpr auto	cpg::types::operator/ (safe_integral_operation< L > const &a, safe_integral_operation< R > const &b)
template<non_safe_io_c L, typename R >
constexpr auto	cpg::types::operator+ (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	cpg::types::operator+ (safe_integral_operation< L > const &a, R &&b)
template<non_safe_io_c L, typename R >
constexpr auto	cpg::types::operator- (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	cpg::types::operator- (safe_integral_operation< L > const &a, R &&b)
template<non_safe_io_c L, typename R >
constexpr auto	cpg::types::operator* (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	cpg::types::operator* (safe_integral_operation< L > const &a, R &&b)
template<non_safe_io_c L, typename R >
constexpr auto	cpg::types::operator/ (L &&a, safe_integral_operation< R > const &b)
template<typename L , non_safe_io_c R>
constexpr auto	cpg::types::operator/ (safe_integral_operation< L > const &a, R &&b)
template<typename L , typename R >
constexpr auto	cpg::types::operator+ (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<typename L , typename R >
constexpr auto	cpg::types::operator- (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<typename L , typename R >
constexpr auto	cpg::types::operator* (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<typename L , typename R >
constexpr auto	cpg::types::operator/ (safe_numerical_operation< L > const &a, safe_numerical_operation< R > const &b)
template<non_safe_no_c L, typename R >
constexpr auto	cpg::types::operator+ (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	cpg::types::operator+ (safe_numerical_operation< L > const &a, R &&b)
template<non_safe_no_c L, typename R >
constexpr auto	cpg::types::operator- (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	cpg::types::operator- (safe_numerical_operation< L > const &a, R &&b)
template<non_safe_no_c L, typename R >
constexpr auto	cpg::types::operator* (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	cpg::types::operator* (safe_numerical_operation< L > const &a, R &&b)
template<non_safe_no_c L, typename R >
constexpr auto	cpg::types::operator/ (L &&a, safe_numerical_operation< R > const &b)
template<typename L , non_safe_no_c R>
constexpr auto	cpg::types::operator/ (safe_numerical_operation< L > const &a, R &&b)
template<long long DebugMode = 2, typename T = int>
constexpr auto	cpg::types::sbo (T &&value) noexcept(!cpg::bDetectOverFlow)
template<typename P , typename... Types>
consteval bool	cpg::types::hidden::fn_all_different ()
template<typename T >
constexpr decltype(auto)	cpg::types::decay_value (T &&value) noexcept
template<template< typename... > class ContainerType, typename... ArgTypes>
constexpr auto	cpg::types::create_container (ArgTypes &&... args) noexcept
template<all_the_same_flat_c... ArgTypes>
constexpr auto	cpg::types::make_array (ArgTypes &&... args) noexcept
template<typename... ArgTypes>
constexpr auto	cpg::types::make_tuple (ArgTypes &&... args) noexcept
template<typename CharType , typename... Types>
std::basic_ostream< CharType > &	cpg::types::operator<< (std::basic_ostream< CharType > &os, const type_container< Types... > &tc)
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)
template<typename... LeftTypes>
constexpr auto	cpg::types::hidden::fn_pop_back (type_container< LeftTypes... > left, type_container< > right)
template<typename... LeftTypes, typename Head >
constexpr auto	cpg::types::hidden::fn_pop_back (type_container< LeftTypes... > left, type_container< Head > right)
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)
template<typename... Types>
consteval auto	cpg::types::hidden::fn_type_container_to_variant (types::type_container< Types... >)
template<typename... Types>
consteval auto	cpg::types::hidden::fn_make_unique_variant (std::variant< Types... >)
template<typename... Types>
auto	cpg::types::make_vector_of_variants (Types... args)
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)
template<vector_c... ContainerTypes, auto N = sizeof...(ContainerTypes)> requires (N > 0)
constexpr auto	cpg::types::element_counts_are_the_same (ContainerTypes &&... containers)
template<std_array_flat_c... ContainerTypes, auto N = sizeof...(ContainerTypes)> requires (N > 0)
constexpr auto	cpg::types::element_counts_are_the_same (ContainerTypes... containers)
template<std::size_t N, vector_c VectorType>
constexpr decltype(auto)	cpg::types::make_span (VectorType &&v)
template<std_array_flat_c ArrayType>
constexpr decltype(auto)	cpg::types::make_span (ArrayType &&array)
template<typename T , std::size_t N>
constexpr decltype(auto)	cpg::types::make_span (T(&array)[N])
template<typename T , T START, T END, T STEP>
consteval T	cpg::types::hidden::compute_last_index ()
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)
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)
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)
template<std::size_t... Ints, typename FuncType >
auto	cpg::types::for_tuple (FuncType &&f, std::index_sequence< Ints... >)
template<std::size_t... Ints, typename FuncType >
auto	cpg::types::for_tuple (std::index_sequence< Ints... >, FuncType &&f)
template<std::size_t N, typename FuncType >
auto	cpg::types::for_tuple (FuncType &&f)
template<std::size_t... Ints, typename FuncType >
auto	cpg::types::for_array (FuncType &&f, std::index_sequence< Ints... >)
template<std::size_t... Ints, typename FuncType >
auto	cpg::types::for_array (std::index_sequence< Ints... >, FuncType &&f)
template<std::size_t N, typename FuncType >
auto	cpg::types::for_array (FuncType &&f)
template<std::size_t... Ints, typename FuncType >
auto	cpg::types::for_vector (FuncType &&f, std::index_sequence< Ints... >)
template<std::size_t... Ints, typename FuncType >
auto	cpg::types::for_vector (std::index_sequence< Ints... >, FuncType &&f)
template<std::size_t N, typename FuncType >
auto	cpg::types::for_vector (FuncType &&f)
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)
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)
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)
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)
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)
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)
template<typename T , T Rows, T Columns>
constexpr auto	cpg::types::hidden::generate_row_column_value ()
template<typename T , T Heights, T Rows, T Columns>
constexpr auto	cpg::types::hidden::generate_height_row_column_value ()
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... >) noexcept
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... >) noexcept
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... >) noexcept
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... >) noexcept
template<typename... Ls, typename... Rs>
constexpr auto	cpg::types::tuple_append (std::tuple< Ls... > const &A, std::tuple< Rs... > const &B) noexcept
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) noexcept
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) noexcept
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) noexcept
template<typename... Ls, neither_array_nor_tuple_c... ArgTypes>
constexpr auto	cpg::types::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	cpg::types::tuple_append (std::array< L, N > const &A, ArgTypes &&... args) noexcept
template<neither_array_nor_tuple_c... Types>
constexpr auto	cpg::types::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	cpg::types::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	cpg::types::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	cpg::types::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	cpg::types::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	cpg::types::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)	cpg::types::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)	cpg::types::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)	cpg::types::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)	cpg::types::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)	cpg::types::for_stallion (WorkType &&work, ArgTypes &&... args)
template<auto head, auto... tails>
constexpr auto	cpg::types::drop_head (sequence< head, tails... >)
template<auto left, auto... lefts, auto head, auto... tails>
constexpr auto	cpg::types::compute_multipliers (sequence< left, lefts... > result, sequence< head, tails... >)
template<auto head, auto... tails>
constexpr auto	cpg::types::get_total (sequence< head, tails... >)
template<auto ii, auto head, auto... tails>
constexpr auto	cpg::types::get (sequence< head, tails... >)
template<auto... ms, auto... rs>
constexpr auto	cpg::types::reverse (sequence< ms... > mm, sequence< rs... >)
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)
template<typename T , T... args>
constexpr auto	cpg::types::create_tuple_sequence (std::integer_sequence< T, args... > dimensions)
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)
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)
template<tuple_flat_c TupleType>
constexpr decltype(auto)	cpg::types::array_tuple_hidden::tuple_to_array_recursive (TupleType &&tuple)
template<tuple_flat_c TupleType>
constexpr decltype(auto)	cpg::types::array_tuple_hidden::tuple_to_array (TupleType &&tuple)
template<tuple_flat_c TupleType>
constexpr decltype(auto)	cpg::types::tuple_to_array (TupleType &&tuple)
template<tuple_flat_c TupleType>
constexpr decltype(auto)	cpg::types::tuple_to_array_recursive (TupleType &&tuple)
template<typename... Types>
auto	cpg::types::reverse_tuple (std::tuple< Types... > const &tuple)
template<typename Type , std::size_t N>
auto	cpg::types::reverse_array (std::array< Type, N > const &array)

Variables
constexpr auto	cpg::flush = hidden::flush{}
constexpr auto	cpg::clear = hidden::clear{}
constexpr auto	cpg::endl = hidden::endl{}
constexpr auto	cpg::endL = hidden::endL{}
template<typename Type >
constexpr auto	cpg::type_max_v = std::numeric_limits<Type>::max()
constexpr size_t	cpg::InvalidIndex = type_max_v<size_t>
constexpr size_t	cpg::SelectAll = InvalidIndex
constexpr const bool	cpg::bDetectOverFlow = true
no_type	cpg::types::hidden::array_apply (...)
no_type	cpg::types::hidden::safe_apply (...)
no_type	cpg::types::hidden::fn_apply (...)
template<typename FuncType , typename TupleType >
constexpr bool	cpg::types::is_apply_v = !no_type_c<apply_return_t<FuncType, TupleType>>
template<typename FuncType , typename... TupleTypes>
constexpr bool	cpg::types::all_apply_v = ( is_apply_v<FuncType, TupleTypes> && ... )
template<typename FuncType , typename... TupleTypes>
constexpr bool	cpg::types::common_apply_v

Macro Definition Documentation

Cpg_CharStr

#define Cpg_CharStr

(

asciistr

)

cpg::types::cHarsTR{asciistr, L##asciistr}

Definition at line 582 of file cpg_types.hpp.

Cpg_DebugException

#define Cpg_DebugException

(

debug_message

)

cpg::debug_exception{debug_message, __LINE__, __FILE__}

Definition at line 746 of file cpg_types.hpp.

Cpg_GetTypeCategory

#define Cpg_GetTypeCategory	(		instance_arg,
			...
	)		cpg::types::type_tO_sTring<decltype(instance_arg, ##__VA_ARGS__)>()

Definition at line 743 of file cpg_types.hpp.

Cpg_GetTypeName

#define Cpg_GetTypeName	(		type_arg,
			...
	)		cpg::types::type_tO_sTring<type_arg, ##__VA_ARGS__>()

Definition at line 740 of file cpg_types.hpp.

CPG_SAFE_OPERATION

#define CPG_SAFE_OPERATION   2LL

Definition at line 67 of file cpg_types.hpp.

Cpg_ThrowDebugException

#define Cpg_ThrowDebugException

(

debug_message

)

throw cpg::debug_exception{debug_message, __LINE__, __FILE__}

Definition at line 748 of file cpg_types.hpp.

CpgSafe

#define CpgSafe

(

arg

)

arg

Definition at line 88 of file cpg_types.hpp.

NOMINMAX

#define NOMINMAX

Definition at line 12 of file cpg_types.hpp.

TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS

#define TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS   1

Definition at line 16 of file cpg_types.hpp.

TBB_SUPPRESS_DEPRECATED_MESSAGES

#define TBB_SUPPRESS_DEPRECATED_MESSAGES   1

Definition at line 20 of file cpg_types.hpp.

Tpf_TestTrunction

#define Tpf_TestTrunction	(		TargetType,
			SourceValue
	)

Definition at line 1193 of file cpg_types.hpp.