mstd Namespace Reference

Namespaces
namespace	utils

Classes
class	vec
class	quat
class	mat
class	bimap
class	ordered_set
class	ordered_map
class	stable_vector
struct	is_iterator
struct	is_iterator< T, std::void_t< typename std::iterator_traits< T >::iterator_category > >
struct	is_iterator_of
struct	is_iterator_of< Iter, T, std::void_t< std::enable_if_t< is_iterator_v< Iter > &&(std::is_convertible_v< typename std::iterator_traits< Iter >::value_type, remove_cvref_t< T > >||std::is_same_v< typename std::iterator_traits< Iter >::value_type, remove_cvref_t< T > >)> > >
struct	is_same_without_cvref
struct	is_same_without_cvref< T, T >
class	event_handler
struct	function_traits
struct	function_traits< R(Args...)>
struct	function_traits< R(Args...) noexcept >
struct	function_traits< R(Args...), C >
struct	function_traits< R(Args...) const, C >
struct	function_traits< R(Args...) volatile, C >
struct	function_traits< R(Args...) &, C >
struct	function_traits< R(Args...) &&, C >
struct	function_traits< R(Args...) noexcept, C >
struct	function_traits< R(Args...) const volatile, C >
struct	function_traits< R(Args...) const &, C >
struct	function_traits< R(Args...) const &&, C >
struct	function_traits< R(Args...) const noexcept, C >
struct	function_traits< R(Args...) const volatile &, C >
struct	function_traits< R(Args...) const volatile &&, C >
struct	function_traits< R(Args...) const volatile noexcept, C >
struct	function_traits< R(Args...) const volatile &noexcept, C >
struct	function_traits< R(Args...) const volatile &&noexcept, C >
struct	function_traits< R(Args...) const &noexcept, C >
struct	function_traits< R(Args...) const &&noexcept, C >
struct	function_traits< R(Args...) volatile &, C >
struct	function_traits< R(Args...) volatile &&, C >
struct	function_traits< R(Args...) volatile noexcept, C >
struct	function_traits< R(Args...) volatile &noexcept, C >
struct	function_traits< R(Args...) volatile &&noexcept, C >
struct	function_traits< R(Args...) &noexcept, C >
struct	function_traits< R(Args...) &&noexcept, C >
struct	function_traits< std::function< R(Args...)> >
struct	function_traits< R(*)(Args...)>
struct	function_traits< R(*)(Args...) noexcept >
struct	function_traits< R(&)(Args...)>
struct	function_traits< R(&)(Args...) noexcept >
struct	function_traits< R(&&)(Args...)>
struct	function_traits< R(&&)(Args...) noexcept >
struct	function_traits< F, std::void_t< decltype(&F::operator())> >
struct	function_traits< R(C::*)(Args...)>
struct	function_traits< R(C::*)(Args...) const >
struct	function_traits< R(C::*)(Args...) volatile >
struct	function_traits< R(C::*)(Args...) & >
struct	function_traits< R(C::*)(Args...) && >
struct	function_traits< R(C::*)(Args...) noexcept >
struct	function_traits< R(C::*)(Args...) const volatile >
struct	function_traits< R(C::*)(Args...) const & >
struct	function_traits< R(C::*)(Args...) const && >
struct	function_traits< R(C::*)(Args...) const noexcept >
struct	function_traits< R(C::*)(Args...) const volatile & >
struct	function_traits< R(C::*)(Args...) const volatile && >
struct	function_traits< R(C::*)(Args...) const volatile noexcept >
struct	function_traits< R(C::*)(Args...) const volatile &noexcept >
struct	function_traits< R(C::*)(Args...) const volatile &&noexcept >
struct	function_traits< R(C::*)(Args...) const &noexcept >
struct	function_traits< R(C::*)(Args...) const &&noexcept >
struct	function_traits< R(C::*)(Args...) volatile & >
struct	function_traits< R(C::*)(Args...) volatile && >
struct	function_traits< R(C::*)(Args...) volatile noexcept >
struct	function_traits< R(C::*)(Args...) volatile &noexcept >
struct	function_traits< R(C::*)(Args...) volatile &&noexcept >
struct	function_traits< R(C::*)(Args...) &noexcept >
struct	function_traits< R(C::*)(Args...) &&noexcept >
struct	is_callable
struct	is_callable< F, std::void_t< typename function_traits< F >::std_function_type > >
class	function_view
struct	is_same_function
struct	is_same_function< F, F, std::void_t< std::enable_if_t< is_function_v< F > > > >
struct	is_same_function< Fa, Fb, std::void_t< as_std_function_t< Fa >, as_std_function_t< Fb > > >
class	flags
class	base_id_manager
struct	all_check
struct	any_check
struct	is_signed_integral
struct	is_unsigned_integral
struct	are_arithmetic
struct	are_signed
struct	are_unsigned
struct	are_floating_points
struct	are_integrals
struct	are_signed_integrals
struct	are_unsigned_integrals
struct	is_eq
struct	is_neq
struct	is_gt
struct	is_gteq
struct	is_lt
struct	is_lteq
struct	types_holder

Concepts
concept	iterator
concept	iterator_of
concept	same_without_cvref_as
concept	function_ptr
concept	function_ref
concept	function_moved
concept	functor
concept	member_function
concept	free_function
concept	parent_ref_function
concept	parent_moved_function
concept	const_function
concept	noexcept_function
concept	volatile_function
concept	callable
concept	func
concept	action
concept	method
concept	same_function_as
concept	arithmetic
concept	signed_arithmetic
concept	unsigned_arithmetic
concept	floating_point
concept	integral
concept	signed_integral
concept	unsigned_integral

Typedefs
using	fquat = quat<float>
using	dquat = quat<double>
using	ldquat = quat<long double>
using	iquat = quat<int>
using	uquat = quat<unsigned int>
using	bquat = quat<bool>
using	cquat = quat<char>
using	ucquat = quat<unsigned char>
using	scquat = quat<signed char>
using	lquat = quat<long>
using	ulquat = quat<unsigned long>
using	llquat = quat<long long>
using	ullquat = quat<unsigned long long>
template<size_t N, class T>
using	mat_sqr = mat<N, N, T>
template<class Key, class T>
using	unordered_bimap = bimap<Key, T, std::unordered_map>
template<class Key, class T>
using	ordered_bimap = bimap<Key, T, ordered_map>
using	method_event_handler = event_handler<>
template<class F>
using	function_type_t = _MSTD_TYPENAME17 function_traits<F>::function_type
template<class F>
using	core_function_type_t = _MSTD_TYPENAME17 function_traits<F>::core_function_type
template<class F>
using	as_std_function_t = _MSTD_TYPENAME17 function_traits<F>::std_function_type
template<class F>
using	function_return_t = _MSTD_TYPENAME17 function_traits<F>::return_type
template<class F>
using	function_decayed_return_t = _MSTD_TYPENAME17 function_traits<F>::decayed_return_type
template<class F>
using	function_args_t = _MSTD_TYPENAME17 function_traits<F>::args_tuple
template<class F>
using	function_decayed_args_t = _MSTD_TYPENAME17 function_traits<F>::decayed_args_tuple
template<class F, size_t N>
using	function_arg_t = _MSTD_TYPENAME17 function_traits<F>::template arg_type<N>
template<class F, size_t N>
using	function_decayed_arg_t = _MSTD_TYPENAME17 function_traits<F>::template decayed_arg_type<N>
template<class F>
using	function_parent_t = _MSTD_TYPENAME17 function_traits<F>::parent_type
template<class F>
using	func_t = as_std_function_t<F>
template<class... Args>
using	action_t = func_t<void(Args...)>
using	method_t = action_t<>
template<class F>
using	c_func_t = _MSTD_TYPENAME17 utils::c_func_impl<F, void>::type
template<class C, class F>
using	c_member_func_t = _MSTD_TYPENAME17 utils::c_func_impl<F, C>::type
template<class... Args>
using	c_action_t = c_func_t<void(Args...)>
template<class C, class... Args>
using	c_member_action_t = c_member_func_t<C, void(Args...)>
using	c_method_t = c_action_t<>
template<class C>
using	c_member_method_t = c_member_action_t<C>
template<size_t Start, size_t End>
using	make_index_sequence_from_to = decltype(shift_index_sequence<Start>(std::make_index_sequence<End - Start>()))
template<size_t Start, size_t Size>
using	make_index_sequence_from = decltype(shift_index_sequence<Start>(std::make_index_sequence<Size>()))
template<size_t Start, class... Ts>
using	make_index_sequence_for_from = decltype(shift_index_sequence<Start>(std::index_sequence_for<Ts...>()))
template<class... Ts>
using	unique_types = _MSTD_TYPENAME17 utils::unique_impl<types_holder<>, types_holder<Ts...> >::type
using	id_manager = base_id_manager<size_t>
using	id8_manager = base_id_manager<uint8_t>
using	id16_manager = base_id_manager<uint16_t>
using	id32_manager = base_id_manager<uint32_t>
using	id64_manager = base_id_manager<uint64_t>
template<class T>
using	remove_cvref_t = std::remove_cvref_t<T>

Functions
	_MSTD_MAKE_VECS_TYPES (2)
	_MSTD_MAKE_VECS_TYPES (3)
	_MSTD_MAKE_VECS_TYPES (4)
	_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES (2, 3)
	_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES (2, 4)
	_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES (3, 4)
	_MSTD_MAKE_MAT_SQR_TYPES (2)
	_MSTD_MAKE_MAT_SQR_TYPES (3)
	_MSTD_MAKE_MAT_SQR_TYPES (4)
_MSTD_INLINE17 _MSTD_CONSTEXPR20 uint32_t	swap_endians (uint32_t value) noexcept
template<size_t C, size_t R, arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 mat< C, R, T >	clamp (const mat< C, R, T > &a, const T &minVal, const T &maxVal)
template<size_t C, size_t R, arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 mat< C, R, T >	clamp (const mat< C, R, T > &a, const mat< C, R, T > &minVal, const mat< C, R, T > &maxVal)
template<arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	signum (const T &x) noexcept
template<arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	step (const T &edge, const T &x) noexcept
template<arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	remap (const T &input, const T &currStart, const T &currEnd, const T &expectedStart, const T &expectedEnd) noexcept
template<arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	deg_to_rad (const T &angle) noexcept
template<arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	rad_to_deg (const T &rad) noexcept
template<floating_point AT, floating_point BT, floating_point EpsT>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	epsilon_equal (const AT &a, const BT &b, const EpsT &epsilon=default_epsilon) noexcept
template<arithmetic AT, arithmetic BT, floating_point EpsT = double>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	is_equal (const AT &a, const BT &b, const EpsT &eps=default_epsilon)
template<arithmetic AT, arithmetic BT, floating_point EpsT = double>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	is_not_equal (const AT &a, const BT &b, const EpsT &eps=default_epsilon)
template<arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	saturate (const T &a) noexcept
template<arithmetic T>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	fract (const T &x)
_MSTD_INLINE17 _MSTD_CONSTEXPR20 float	q_rsqrt (float number) noexcept
template<arithmetic N, arithmetic Na, arithmetic Nb>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	add_overflow (const Na &a, const Nb &b, N &out)
template<arithmetic N, arithmetic Na, arithmetic Nb>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	sub_overflow (const Na &a, const Nb &b, N &out)
template<arithmetic N, arithmetic Na, arithmetic Nb>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	mul_overflow (const Na &a, const Nb &b, N &out)
template<arithmetic N, arithmetic Na, arithmetic Nb>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	div_overflow (const Na &a, const Nb &b, N &out)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	length (const vec< N, T > &a) noexcept
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	normalize (const vec< N, T > &a) noexcept
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	max (const vec< N, T > &a, const vec< N, T > &b) noexcept
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	min (const vec< N, T > &a, const vec< N, T > &b) noexcept
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	dot (const vec< N, T > &a, const vec< N, T > &b)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	cross (const vec< N, T > &a, const vec< N, T > &b)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 T	angle_between (const vec< N, T > &a, const vec< N, T > &b)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	reflect (const vec< N, T > &dir, const vec< N, T > &normal)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	refract (const vec< N, T > &dir, const vec< N, T > &normal, const T &eta)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	saturate (const vec< N, T > &a)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	fract (const vec< N, T > &a)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	mod (const vec< N, T > &a, const T &y)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	mod (const vec< N, T > &a, const vec< N, T > &b)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	pow (const vec< N, T > &a, const T &y)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	pow (const vec< N, T > &a, const vec< N, T > &b)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	clamp (const vec< N, T > &a, const T &minVal, const T &maxVal)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	clamp (const vec< N, T > &a, const vec< N, T > &minVal, const vec< N, T > &maxVal)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	step (const T &edge, const vec< N, T > &a)
template<class T, size_t N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T >	step (const vec< N, T > &edge, const vec< N, T > &a)
std::string	format_log (const std::string_view expression, _MSTD_SOURCE_LOCATION_ARG, const std::string_view message="") noexcept
void	log_assert_handler (const std::string_view expression, const mstd::function_view< void(const std::string_view)> &errorLogger, _MSTD_SOURCE_LOCATION_ARG) noexcept
bool	stop_assert_handler (const std::string_view expression, const mstd::function_view< void(const std::string_view)> &errorLogger, _MSTD_SOURCE_LOCATION_ARG) noexcept
template<class... Args>
void	log_assert_handler (const std::string_view expression, const mstd::function_view< void(const std::string_view)> &errorLogger, _MSTD_SOURCE_LOCATION_ARG, fmt::format_string< Args... > fmtFormat, Args &&... args) noexcept
template<class... Args>
bool	stop_assert_handler (const std::string_view expression, const mstd::function_view< void(const std::string_view)> &errorLogger, _MSTD_SOURCE_LOCATION_ARG, fmt::format_string< Args... > fmtFormat, Args &&... args) noexcept
template<class BitsEnum>
_MSTD_CONSTEXPR17 flags< BitsEnum >	operator| (const BitsEnum bit, const BitsEnum otherBit) noexcept
template<class T, class... Ts>
void	hash_append (size_t &hashValue, const T &value, const Ts &... values)
template<class T0, class T1, class... Ts>
size_t	hash_combine (const T0 &value0, const T1 &value1, const Ts &... values)
template<class Iter>
void	hash_range (size_t &seed, const Iter &begin, const Iter &end)
template<size_t Start, size_t... Indices>
_MSTD_CONSTEXPR20 std::index_sequence<(Start+Indices)... >	shift_index_sequence (const std::index_sequence< Indices... > &)
bool	isstrhex (const std::string_view str)
bool	isstroct (const std::string_view str)
bool	isstrbin (const std::string_view str)
bool	isstrnum (const std::string_view str)
bool	isstrunum (const std::string_view str)
bool	isstrfp (const std::string_view str)
template<class... Strings>
std::string &	concat_to (std::string &out, Strings &&... strs)
template<class... Strings>
std::string	concat (Strings &&... strs)
std::string	trim (const std::string_view str)
template<mstd::integral N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	strxtonum (const std::string_view hexStr, N &num)
template<mstd::integral N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	strctonum (const std::string_view octStr, N &num)
template<mstd::integral N>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	strbtonum (const std::string_view binStr, N &num)
template<mstd::signed_integral SN>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	strtonum (const std::string_view str, SN &num)
template<mstd::unsigned_integral UN>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	strtounum (const std::string_view str, UN &num)
template<mstd::floating_point FP>
_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool	strtofp (const std::string_view str, FP &num)
void	get_terminal_size (int &width, int &height)
void	clear_terminal ()

Variables
static _MSTD_CONSTEXPR17 const float	default_epsilon = 1e-4f
template<class T>
_MSTD_CONSTEXPR17 bool	is_iterator_v = is_iterator<T>::value
template<class Iter, class T>
_MSTD_CONSTEXPR17 bool	is_iterator_of_v = is_iterator_of<Iter, T>::value
template<class T, class U>
_MSTD_CONSTEXPR17 bool	is_same_without_cvref_v = is_same_without_cvref<T, U>::value
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_std_function_v = function_traits<F>::is_std_function
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_function_ptr_v = function_traits<F>::is_ptr
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_function_ref_v = function_traits<F>::is_ref
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_function_moved_v = function_traits<F>::is_moved
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_functor_v = function_traits<F>::is_functor
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_member_function_v = function_traits<F>::is_member
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_free_function_v = function_traits<F>::is_free
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_parent_ref_function_v = function_traits<F>::is_parent_ref
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_parent_moved_function_v = function_traits<F>::is_parent_moved
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_const_function_v = function_traits<F>::is_const
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_noexcept_function_v = function_traits<F>::is_noexcept
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_volatile_function_v = function_traits<F>::is_volatile
template<class F>
static _MSTD_CONSTEXPR17 const size_t	function_args_num_v = function_traits<F>::args_num
template<class F>
_MSTD_CONSTEXPR17 bool	is_callable_v = is_callable<F>::value
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_function_v
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_action_v = is_function_v<F> && std::is_void_v<function_return_t<F> >
template<class F>
static _MSTD_CONSTEXPR17 const bool	is_method_v = is_action_v<F> && function_args_num_v<F> == 0
template<class Fa, class Fb>
_MSTD_CONSTEXPR17 bool	is_same_function_v = is_same_function<Fa, Fb>::value
template<template< class > class Test, class... Ts>
static _MSTD_CONSTEXPR17 const bool	are_all_v = (Test<Ts>::value && ...)
template<template< class > class Check, class... Ts>
constexpr bool	all_check_v = all_check<Check, Ts...>::value
template<template< class > class Check, class... Ts>
constexpr bool	any_check_v = any_check<Check, Ts...>::value
template<class T>
constexpr bool	is_signed_integral_v = std::is_integral_v<T> && std::is_signed_v<T>
template<class T>
constexpr bool	is_unsigned_integral_v = std::is_integral_v<T> && std::is_unsigned_v<T>
template<class... Ns>
constexpr bool	are_arithmetic_v = are_arithmetic<Ns...>::value
template<class... Ns>
constexpr bool	are_signed_v = are_signed<Ns...>::value
template<class... Ns>
constexpr bool	are_unsigned_v = are_unsigned<Ns...>::value
template<class... Ns>
constexpr bool	are_floating_points_v = are_floating_points<Ns...>::value
template<class... Ns>
constexpr bool	are_integrals_v = are_integrals<Ns...>::value
template<class... Ns>
constexpr bool	are_signed_integrals_v = are_signed_integrals<Ns...>::value
template<class... Ns>
constexpr bool	are_unsigned_integrals_v = are_unsigned_integrals<Ns...>::value
template<auto A>
static _MSTD_CONSTEXPR17 const auto	abs_v = utils::abs_impl<A>::value
template<auto A, auto B, auto Eps, arithmetic AT = decltype(A), arithmetic BT = decltype(B), floating_point EpsT = decltype(Eps)>
_MSTD_CONSTEXPR17 const bool	is_eq_arithmetic_v
template<auto A, auto B, auto Eps, arithmetic AT = decltype(A), arithmetic BT = decltype(B), floating_point EpsT = decltype(Eps)>
_MSTD_CONSTEXPR17 const bool	is_neq_arithmetic_v = !is_eq_arithmetic_v<A, B, Eps>
template<auto A, auto B>
_MSTD_CONSTEXPR17 const bool	is_eq_v = is_eq<A, B>::value
template<auto A, auto B>
_MSTD_CONSTEXPR17 const bool	is_neq_v = is_neq<A, B>::value
template<auto A, auto B>
_MSTD_CONSTEXPR17 const bool	is_gt_v = is_gt<A, B>::value
template<auto A, auto B>
_MSTD_CONSTEXPR17 const bool	is_gteq_v = is_gteq<A, B>::value
template<auto A, auto B>
_MSTD_CONSTEXPR17 const bool	is_lt_v = is_lt<A, B>::value
template<auto A, auto B>
_MSTD_CONSTEXPR17 const bool	is_lteq_v = is_lteq<A, B>::value
template<template< class, class > class Cmp, class T, class U, class... Us>
_MSTD_CONSTEXPR17 const bool	is_type_in_v = (Cmp<T, U>::value || (sizeof...(Us) > 0 ? (Cmp<T, Us>::value || ...) : false))
template<template< auto, auto > class Cmp, auto A, auto B, auto... Cs>
_MSTD_CONSTEXPR17 const bool	is_value_in_v = (Cmp<A, B>::value || (sizeof...(Cs) > 0 ? (Cmp<A, Cs>::value || ...) : false))
template<class T, class U, class... Us>
_MSTD_CONSTEXPR17 const bool	is_same_type_in_v = is_type_in_v<std::is_same, T, U, Us...>
template<auto A, auto B, auto... Cs>
_MSTD_CONSTEXPR17 const bool	is_eq_value_in_v = is_value_in_v<is_eq, A, B, Cs...>
template<auto A, auto Min, auto Max>
_MSTD_CONSTEXPR17 const bool	is_in_range_v = (is_gteq_v<A, Min> && is_lteq_v<A, Max>)
template<class T, template< class... > class U>
_MSTD_CONSTEXPR17 const bool	is_based_on_v = false
template<template< class... > class U, class... Vs>
_MSTD_CONSTEXPR17 const bool	is_based_on_v< U< Vs... >, U > = true
template<bool Condition, auto TrueValue, auto FalseValue>
static _MSTD_CONSTEXPR17 const auto	if_v = utils::if_impl<Condition, TrueValue, FalseValue>::value

Typedef Documentation

action_t

template<class... Args>

using mstd::action_t = func_t<void(Args...)>

as_std_function_t

template<class F>

using mstd::as_std_function_t = _MSTD_TYPENAME17 function_traits<F>::std_function_type

bquat

using mstd::bquat = quat<bool>

c_action_t

template<class... Args>

using mstd::c_action_t = c_func_t<void(Args...)>

c_func_t

template<class F>

using mstd::c_func_t = _MSTD_TYPENAME17 utils::c_func_impl<F, void>::type

c_member_action_t

template<class C, class... Args>

using mstd::c_member_action_t = c_member_func_t<C, void(Args...)>

c_member_func_t

template<class C, class F>

using mstd::c_member_func_t = _MSTD_TYPENAME17 utils::c_func_impl<F, C>::type

c_member_method_t

template<class C>

using mstd::c_member_method_t = c_member_action_t<C>

c_method_t

using mstd::c_method_t = c_action_t<>

core_function_type_t

template<class F>

using mstd::core_function_type_t = _MSTD_TYPENAME17 function_traits<F>::core_function_type

cquat

using mstd::cquat = quat<char>

dquat

using mstd::dquat = quat<double>

fquat

using mstd::fquat = quat<float>

func_t

template<class F>

using mstd::func_t = as_std_function_t<F>

function_arg_t

template<class F, size_t N>

using mstd::function_arg_t = _MSTD_TYPENAME17 function_traits<F>::template arg_type<N>

function_args_t

template<class F>

using mstd::function_args_t = _MSTD_TYPENAME17 function_traits<F>::args_tuple

function_decayed_arg_t

template<class F, size_t N>

using mstd::function_decayed_arg_t = _MSTD_TYPENAME17 function_traits<F>::template decayed_arg_type<N>

function_decayed_args_t

template<class F>

using mstd::function_decayed_args_t = _MSTD_TYPENAME17 function_traits<F>::decayed_args_tuple

function_decayed_return_t

template<class F>

using mstd::function_decayed_return_t = _MSTD_TYPENAME17 function_traits<F>::decayed_return_type

function_parent_t

template<class F>

using mstd::function_parent_t = _MSTD_TYPENAME17 function_traits<F>::parent_type

function_return_t

template<class F>

using mstd::function_return_t = _MSTD_TYPENAME17 function_traits<F>::return_type

function_type_t

template<class F>

using mstd::function_type_t = _MSTD_TYPENAME17 function_traits<F>::function_type

id16_manager

using mstd::id16_manager = base_id_manager<uint16_t>

id32_manager

using mstd::id32_manager = base_id_manager<uint32_t>

id64_manager

using mstd::id64_manager = base_id_manager<uint64_t>

id8_manager

using mstd::id8_manager = base_id_manager<uint8_t>

id_manager

using mstd::id_manager = base_id_manager<size_t>

iquat

using mstd::iquat = quat<int>

ldquat

using mstd::ldquat = quat<long double>

llquat

using mstd::llquat = quat<long long>

lquat

using mstd::lquat = quat<long>

make_index_sequence_for_from

template<size_t Start, class... Ts>

using mstd::make_index_sequence_for_from = decltype(shift_index_sequence<Start>(std::index_sequence_for<Ts...>()))

make_index_sequence_from

template<size_t Start, size_t Size>

using mstd::make_index_sequence_from = decltype(shift_index_sequence<Start>(std::make_index_sequence<Size>()))

make_index_sequence_from_to

template<size_t Start, size_t End>

using mstd::make_index_sequence_from_to = decltype(shift_index_sequence<Start>(std::make_index_sequence<End - Start>()))

mat_sqr

template<size_t N, class T>

using mstd::mat_sqr = mat<N, N, T>

method_event_handler

using mstd::method_event_handler = event_handler<>

method_t

using mstd::method_t = action_t<>

ordered_bimap

template<class Key, class T>

using mstd::ordered_bimap = bimap<Key, T, ordered_map>

remove_cvref_t

template<class T>

using mstd::remove_cvref_t = std::remove_cvref_t<T>

scquat

using mstd::scquat = quat<signed char>

ucquat

using mstd::ucquat = quat<unsigned char>

ullquat

using mstd::ullquat = quat<unsigned long long>

ulquat

using mstd::ulquat = quat<unsigned long>

unique_types

template<class... Ts>

using mstd::unique_types = _MSTD_TYPENAME17 utils::unique_impl<types_holder<>, types_holder<Ts...> >::type

unordered_bimap

template<class Key, class T>

using mstd::unordered_bimap = bimap<Key, T, std::unordered_map>

uquat

using mstd::uquat = quat<unsigned int>

Function Documentation

_MSTD_MAKE_MAT_SQR_TYPES() [1/3]

mstd::_MSTD_MAKE_MAT_SQR_TYPES

(

2

)

_MSTD_MAKE_MAT_SQR_TYPES() [2/3]

mstd::_MSTD_MAKE_MAT_SQR_TYPES

(

3

)

_MSTD_MAKE_MAT_SQR_TYPES() [3/3]

mstd::_MSTD_MAKE_MAT_SQR_TYPES

(

4

)

_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES() [1/3]

mstd::_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES	(	2	,
		3	)

_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES() [2/3]

mstd::_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES	(	2	,
		4	)

_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES() [3/3]

mstd::_MSTD_MAKE_TWO_MAT_NOT_SQR_TYPES	(	3	,
		4	)

_MSTD_MAKE_VECS_TYPES() [1/3]

mstd::_MSTD_MAKE_VECS_TYPES

(

2

)

_MSTD_MAKE_VECS_TYPES() [2/3]

mstd::_MSTD_MAKE_VECS_TYPES

(

3

)

_MSTD_MAKE_VECS_TYPES() [3/3]

mstd::_MSTD_MAKE_VECS_TYPES

(

4

)

add_overflow()

template<arithmetic N, arithmetic Na, arithmetic Nb>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::add_overflow	(	const Na &	a,
		const Nb &	b,
		N &	out )

angle_between()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::angle_between	(	const vec< N, T > &	a,
		const vec< N, T > &	b )

clamp() [1/4]

template<size_t C, size_t R, arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 mat< C, R, T > mstd::clamp	(	const mat< C, R, T > &	a,
		const mat< C, R, T > &	minVal,
		const mat< C, R, T > &	maxVal )

clamp() [2/4]

template<size_t C, size_t R, arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 mat< C, R, T > mstd::clamp	(	const mat< C, R, T > &	a,
		const T &	minVal,
		const T &	maxVal )

clamp() [3/4]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::clamp	(	const vec< N, T > &	a,
		const T &	minVal,
		const T &	maxVal )

clamp() [4/4]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::clamp	(	const vec< N, T > &	a,
		const vec< N, T > &	minVal,
		const vec< N, T > &	maxVal )

clear_terminal()

void mstd::clear_terminal ( )

inline

concat()

template<class... Strings>

std::string mstd::concat ( Strings &&... strs )

inline

concat_to()

template<class... Strings>

std::string & mstd::concat_to ( std::string & out, Strings &&... strs )

inline

cross()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::cross	(	const vec< N, T > &	a,
		const vec< N, T > &	b )

deg_to_rad()

template<arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::deg_to_rad ( const T & angle )

noexcept

div_overflow()

template<arithmetic N, arithmetic Na, arithmetic Nb>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::div_overflow	(	const Na &	a,
		const Nb &	b,
		N &	out )

dot()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::dot	(	const vec< N, T > &	a,
		const vec< N, T > &	b )

epsilon_equal()

template<floating_point AT, floating_point BT, floating_point EpsT>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::epsilon_equal ( const AT & a, const BT & b, const EpsT & epsilon = default_epsilon )

noexcept

format_log()

std::string mstd::format_log ( const std::string_view expression, _MSTD_SOURCE_LOCATION_ARG , const std::string_view message = "" )

inlinenoexcept

fract() [1/2]

template<arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::fract

(

const T &

x

)

fract() [2/2]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::fract

(

const vec< N, T > &

a

)

get_terminal_size()

void mstd::get_terminal_size ( int & width, int & height )

inline

hash_append()

template<class T, class... Ts>

void mstd::hash_append ( size_t & hashValue, const T & value, const Ts &... values )

inline

hash_combine()

template<class T0, class T1, class... Ts>

size_t mstd::hash_combine ( const T0 & value0, const T1 & value1, const Ts &... values )

inline

hash_range()

template<class Iter>

void mstd::hash_range ( size_t & seed, const Iter & begin, const Iter & end )

inline

is_equal()

template<arithmetic AT, arithmetic BT, floating_point EpsT = double>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::is_equal	(	const AT &	a,
		const BT &	b,
		const EpsT &	eps = default_epsilon )

is_not_equal()

template<arithmetic AT, arithmetic BT, floating_point EpsT = double>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::is_not_equal	(	const AT &	a,
		const BT &	b,
		const EpsT &	eps = default_epsilon )

isstrbin()

bool mstd::isstrbin ( const std::string_view str )

inline

isstrfp()

bool mstd::isstrfp ( const std::string_view str )

inline

isstrhex()

bool mstd::isstrhex ( const std::string_view str )

inline

isstrnum()

bool mstd::isstrnum ( const std::string_view str )

inline

isstroct()

bool mstd::isstroct ( const std::string_view str )

inline

isstrunum()

bool mstd::isstrunum ( const std::string_view str )

inline

length()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::length ( const vec< N, T > & a )

noexcept

log_assert_handler() [1/2]

void mstd::log_assert_handler ( const std::string_view expression, const mstd::function_view< void(const std::string_view)> & errorLogger, _MSTD_SOURCE_LOCATION_ARG  )

inlinenoexcept

log_assert_handler() [2/2]

template<class... Args>

void mstd::log_assert_handler ( const std::string_view expression, const mstd::function_view< void(const std::string_view)> & errorLogger, _MSTD_SOURCE_LOCATION_ARG , fmt::format_string< Args... > fmtFormat, Args &&... args )

inlinenoexcept

max()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::max ( const vec< N, T > & a, const vec< N, T > & b )

noexcept

min()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::min ( const vec< N, T > & a, const vec< N, T > & b )

noexcept

mod() [1/2]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::mod	(	const vec< N, T > &	a,
		const T &	y )

mod() [2/2]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::mod	(	const vec< N, T > &	a,
		const vec< N, T > &	b )

mul_overflow()

template<arithmetic N, arithmetic Na, arithmetic Nb>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::mul_overflow	(	const Na &	a,
		const Nb &	b,
		N &	out )

normalize()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::normalize ( const vec< N, T > & a )

noexcept

operator|()

template<class BitsEnum>

_MSTD_CONSTEXPR17 flags< BitsEnum > mstd::operator| ( const BitsEnum bit, const BitsEnum otherBit )

nodiscardnoexcept

pow() [1/2]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::pow	(	const vec< N, T > &	a,
		const T &	y )

pow() [2/2]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::pow	(	const vec< N, T > &	a,
		const vec< N, T > &	b )

q_rsqrt()

_MSTD_INLINE17 _MSTD_CONSTEXPR20 float mstd::q_rsqrt ( float number )

noexcept

rad_to_deg()

template<arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::rad_to_deg ( const T & rad )

noexcept

reflect()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::reflect	(	const vec< N, T > &	dir,
		const vec< N, T > &	normal )

refract()

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::refract	(	const vec< N, T > &	dir,
		const vec< N, T > &	normal,
		const T &	eta )

remap()

template<arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::remap ( const T & input, const T & currStart, const T & currEnd, const T & expectedStart, const T & expectedEnd )

noexcept

saturate() [1/2]

template<arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::saturate ( const T & a )

noexcept

saturate() [2/2]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::saturate

(

const vec< N, T > &

a

)

shift_index_sequence()

template<size_t Start, size_t... Indices>

_MSTD_CONSTEXPR20 std::index_sequence<(Start+Indices)... > mstd::shift_index_sequence

(

const std::index_sequence< Indices... > &

)

signum()

template<arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::signum ( const T & x )

noexcept

step() [1/3]

template<arithmetic T>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 T mstd::step ( const T & edge, const T & x )

noexcept

step() [2/3]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::step	(	const T &	edge,
		const vec< N, T > &	a )

step() [3/3]

template<class T, size_t N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 vec< N, T > mstd::step	(	const vec< N, T > &	edge,
		const vec< N, T > &	a )

stop_assert_handler() [1/2]

bool mstd::stop_assert_handler ( const std::string_view expression, const mstd::function_view< void(const std::string_view)> & errorLogger, _MSTD_SOURCE_LOCATION_ARG  )

inlinenoexcept

stop_assert_handler() [2/2]

template<class... Args>

bool mstd::stop_assert_handler ( const std::string_view expression, const mstd::function_view< void(const std::string_view)> & errorLogger, _MSTD_SOURCE_LOCATION_ARG , fmt::format_string< Args... > fmtFormat, Args &&... args )

inlinenoexcept

strbtonum()

template<mstd::integral N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::strbtonum	(	const std::string_view	binStr,
		N &	num )

strctonum()

template<mstd::integral N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::strctonum	(	const std::string_view	octStr,
		N &	num )

strtofp()

template<mstd::floating_point FP>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::strtofp	(	const std::string_view	str,
		FP &	num )

strtonum()

template<mstd::signed_integral SN>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::strtonum	(	const std::string_view	str,
		SN &	num )

strtounum()

template<mstd::unsigned_integral UN>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::strtounum	(	const std::string_view	str,
		UN &	num )

strxtonum()

template<mstd::integral N>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::strxtonum	(	const std::string_view	hexStr,
		N &	num )

sub_overflow()

template<arithmetic N, arithmetic Na, arithmetic Nb>

_MSTD_INLINE17 _MSTD_CONSTEXPR20 bool mstd::sub_overflow	(	const Na &	a,
		const Nb &	b,
		N &	out )

swap_endians()

_MSTD_INLINE17 _MSTD_CONSTEXPR20 uint32_t mstd::swap_endians ( uint32_t value )

noexcept

trim()

std::string mstd::trim ( const std::string_view str )

inline

Variable Documentation

abs_v

template<auto A>

_MSTD_CONSTEXPR17 const auto mstd::abs_v = utils::abs_impl<A>::value

static

all_check_v

template<template< class > class Check, class... Ts>

bool mstd::all_check_v = all_check<Check, Ts...>::value

constexpr

any_check_v

template<template< class > class Check, class... Ts>

bool mstd::any_check_v = any_check<Check, Ts...>::value

constexpr

are_all_v

template<template< class > class Test, class... Ts>

_MSTD_CONSTEXPR17 const bool mstd::are_all_v = (Test<Ts>::value && ...)

static

are_arithmetic_v

template<class... Ns>

bool mstd::are_arithmetic_v = are_arithmetic<Ns...>::value

constexpr

are_floating_points_v

template<class... Ns>

bool mstd::are_floating_points_v = are_floating_points<Ns...>::value

constexpr

are_integrals_v

template<class... Ns>

bool mstd::are_integrals_v = are_integrals<Ns...>::value

constexpr

are_signed_integrals_v

template<class... Ns>

bool mstd::are_signed_integrals_v = are_signed_integrals<Ns...>::value

constexpr

are_signed_v

template<class... Ns>

bool mstd::are_signed_v = are_signed<Ns...>::value

constexpr

are_unsigned_integrals_v

template<class... Ns>

bool mstd::are_unsigned_integrals_v = are_unsigned_integrals<Ns...>::value

constexpr

are_unsigned_v

template<class... Ns>

bool mstd::are_unsigned_v = are_unsigned<Ns...>::value

constexpr

default_epsilon

_MSTD_CONSTEXPR17 const float mstd::default_epsilon = 1e-4f

static

function_args_num_v

template<class F>

_MSTD_CONSTEXPR17 const size_t mstd::function_args_num_v = function_traits<F>::args_num

static

if_v

template<bool Condition, auto TrueValue, auto FalseValue>

_MSTD_CONSTEXPR17 const auto mstd::if_v = utils::if_impl<Condition, TrueValue, FalseValue>::value

static

is_action_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_action_v = is_function_v<F> && std::is_void_v<function_return_t<F> >

static

is_based_on_v

template<class T, template< class... > class U>

_MSTD_CONSTEXPR17 const bool mstd::is_based_on_v = false

is_based_on_v< U< Vs... >, U >

template<template< class... > class U, class... Vs>

_MSTD_CONSTEXPR17 const bool mstd::is_based_on_v< U< Vs... >, U > = true

is_callable_v

template<class F>

_MSTD_CONSTEXPR17 bool mstd::is_callable_v = is_callable<F>::value

is_const_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_const_function_v = function_traits<F>::is_const

static

is_eq_arithmetic_v

template<auto A, auto B, auto Eps, arithmetic AT = decltype(A), arithmetic BT = decltype(B), floating_point EpsT = decltype(Eps)>

_MSTD_CONSTEXPR17 const bool mstd::is_eq_arithmetic_v

Initial value:

                                          =
(std::is_floating_point_v<AT> || std::is_floating_point_v<BT>) ? (abs_v<A - B> < Eps) : (A == B)

is_eq_v

template<auto A, auto B>

_MSTD_CONSTEXPR17 const bool mstd::is_eq_v = is_eq<A, B>::value

is_eq_value_in_v

template<auto A, auto B, auto... Cs>

_MSTD_CONSTEXPR17 const bool mstd::is_eq_value_in_v = is_value_in_v<is_eq, A, B, Cs...>

is_free_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_free_function_v = function_traits<F>::is_free

static

is_function_moved_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_function_moved_v = function_traits<F>::is_moved

static

is_function_ptr_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_function_ptr_v = function_traits<F>::is_ptr

static

is_function_ref_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_function_ref_v = function_traits<F>::is_ref

static

is_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_function_v

static

Initial value:

                                            =
is_callable_v<F> && (is_free_function_v<F> || is_member_function_v<F>) && !is_functor_v<F> && !is_std_function_v<F>

is_functor_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_functor_v = function_traits<F>::is_functor

static

is_gt_v

template<auto A, auto B>

_MSTD_CONSTEXPR17 const bool mstd::is_gt_v = is_gt<A, B>::value

is_gteq_v

template<auto A, auto B>

_MSTD_CONSTEXPR17 const bool mstd::is_gteq_v = is_gteq<A, B>::value

is_in_range_v

template<auto A, auto Min, auto Max>

_MSTD_CONSTEXPR17 const bool mstd::is_in_range_v = (is_gteq_v<A, Min> && is_lteq_v<A, Max>)

is_iterator_of_v

template<class Iter, class T>

_MSTD_CONSTEXPR17 bool mstd::is_iterator_of_v = is_iterator_of<Iter, T>::value

inline

is_iterator_v

template<class T>

_MSTD_CONSTEXPR17 bool mstd::is_iterator_v = is_iterator<T>::value

inline

is_lt_v

template<auto A, auto B>

_MSTD_CONSTEXPR17 const bool mstd::is_lt_v = is_lt<A, B>::value

is_lteq_v

template<auto A, auto B>

_MSTD_CONSTEXPR17 const bool mstd::is_lteq_v = is_lteq<A, B>::value

is_member_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_member_function_v = function_traits<F>::is_member

static

is_method_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_method_v = is_action_v<F> && function_args_num_v<F> == 0

static

is_neq_arithmetic_v

template<auto A, auto B, auto Eps, arithmetic AT = decltype(A), arithmetic BT = decltype(B), floating_point EpsT = decltype(Eps)>

_MSTD_CONSTEXPR17 const bool mstd::is_neq_arithmetic_v = !is_eq_arithmetic_v<A, B, Eps>

is_neq_v

template<auto A, auto B>

_MSTD_CONSTEXPR17 const bool mstd::is_neq_v = is_neq<A, B>::value

is_noexcept_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_noexcept_function_v = function_traits<F>::is_noexcept

static

is_parent_moved_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_parent_moved_function_v = function_traits<F>::is_parent_moved

static

is_parent_ref_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_parent_ref_function_v = function_traits<F>::is_parent_ref

static

is_same_function_v

template<class Fa, class Fb>

_MSTD_CONSTEXPR17 bool mstd::is_same_function_v = is_same_function<Fa, Fb>::value

is_same_type_in_v

template<class T, class U, class... Us>

_MSTD_CONSTEXPR17 const bool mstd::is_same_type_in_v = is_type_in_v<std::is_same, T, U, Us...>

is_same_without_cvref_v

template<class T, class U>

_MSTD_CONSTEXPR17 bool mstd::is_same_without_cvref_v = is_same_without_cvref<T, U>::value

inline

is_signed_integral_v

template<class T>

bool mstd::is_signed_integral_v = std::is_integral_v<T> && std::is_signed_v<T>

constexpr

is_std_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_std_function_v = function_traits<F>::is_std_function

static

is_type_in_v

template<template< class, class > class Cmp, class T, class U, class... Us>

_MSTD_CONSTEXPR17 const bool mstd::is_type_in_v = (Cmp<T, U>::value || (sizeof...(Us) > 0 ? (Cmp<T, Us>::value || ...) : false))

is_unsigned_integral_v

template<class T>

bool mstd::is_unsigned_integral_v = std::is_integral_v<T> && std::is_unsigned_v<T>

constexpr

is_value_in_v

template<template< auto, auto > class Cmp, auto A, auto B, auto... Cs>

_MSTD_CONSTEXPR17 const bool mstd::is_value_in_v = (Cmp<A, B>::value || (sizeof...(Cs) > 0 ? (Cmp<A, Cs>::value || ...) : false))

is_volatile_function_v

template<class F>

_MSTD_CONSTEXPR17 const bool mstd::is_volatile_function_v = function_traits<F>::is_volatile

static