vccc Namespace Reference

Namespaces
	impl
	literals
	math
	ranges
	rel_ops
	string_view_literals

Classes
class	directory
class	Formatter
	converts c-style format and inputs to std::string More...
class	GlobalStreamWrapperSettings
class	Separator
	Set separator to vccc::BasicStreamWrapper. More...
class	Quoted
	Manipulator for adding quotation to strings(only to string and string_view) More...
class	ExpandAggregate
	Manipulator for expanding aggregate types. More...
class	ExpandArray
	Expand array instead of printing its value. More...
class	IOSFlagsSaver
	RAII wrapper that restores stream's flags on destroyed. More...
class	Logger
	Ease use of vccc::StreamWrapper. More...
class	StreamManipulator
	Manipulator for vccc::StreamWrapper. More...
class	StreamWrapperBase
class	BasicStreamWrapper
	stream wrapper that supports extended operator overloading More...
class	MatrixBase
class	Matrix
	A class that represents 2D matrix. More...
class	MatrixSum
class	MatrixMinus
class	MatrixSub
class	MatrixMulScalar
class	MatrixDivScalar
class	MatrixMulMatrix
class	MatrixProxyNocopy
class	MatrixAssigner
struct	is_matrix
class	MatrixInverter
struct	differential_newtonian_t
struct	differential_symmetric_t
struct	differential_five_point_stencil_t
class	connection
	Connection manager for a single slot. More...
class	raii_connection
	Scoped connection manager for a single slot. More...
class	signal_impl
class	signal
struct	group_key
struct	group_key_compare
class	signal< R(Args...), Group >
	Signal handling class. More...
class	slot
class	slot< R(Args...)>
struct	grouped_slot_list
class	back_emplace_iterator
struct	unstable_three_way_comparable
struct	assignable_from
	Models std::assignable_from More...
struct	boolean_testable
struct	common_reference_with
	specifies that two types share a common reference type More...
struct	common_with
	specifies that two types share a common type More...
struct	comparison_common_type_with
	specifies that two types share a common type, and a const lvalue or a non-const rvalue of either type is convertible to that common type. More...
struct	constructible_from
	specifies that a variable of the type can be constructed from or bound to a set of argument types More...
struct	convertible_to
	Models std::convertible_to More...
struct	copy_constructible
	specifies that an object of a type can be copy constructed and move constructed More...
struct	copyable
	specifies that an object of a type can be copied, moved, and swapped More...
struct	default_initializable
	specifies that an object of a type can be default constructed More...
struct	dereferenceable
	specifies that an object of a type can be dereferenced More...
struct	derived_from
	Models std::derived_from More...
struct	derived_from_single_crtp
	specifies that a type is derived from single specialization of CRTP base More...
struct	destructible
	specifies that an object of the type can be destroyed More...
struct	different_from
struct	different_from_this
struct	different_from_this< Test, T >
struct	equality_comparable
	specifies that operator == is an equivalence relation More...
struct	equality_comparable_with
	specifies that operator == is an equivalence relation More...
struct	equivalence_relation
	specifies that a relation imposes an equivalence relation More...
struct	implicit_expression_check
struct	implicit_expression_check< Check, Left, Right >
struct	implicit_expression_check< Check, Left, const Right & >
struct	implicit_expression_check< Check, const Left &, const Right & >
struct	implicit_expression_check< Check, Operand >
struct	implicit_expression_check< Check, const Operand & >
struct	invocable
	specifies that a callable type can be invoked with a given set of argument types More...
struct	regular_invocable
	specifies that a callable type can be invoked with a given set of argument types More...
struct	movable
	specifies that an object of a type can be moved and swapped More...
struct	partially_ordered_with
struct	predicate
	specifies that a callable type is a Boolean predicate More...
struct	regular
	specifies that a type is regular, that is, it is both semiregular and equality_comparable More...
struct	relation
	specifies that a callable type is a binary relation More...
struct	same_as
	Models std::same_as More...
struct	semiregular
	specifies that an object of a type can be copied, moved, swapped, and default constructed More...
struct	strict_weak_order
	specifies that a relation imposes a strict weak ordering More...
struct	is_explicitly_subtractable
struct	is_explicitly_subtractable< T, U, void_t< decltype(std::declval< T >() - std::declval< U >())> >
struct	is_subtractable_impl
struct	is_subtractable_impl< T, true >
struct	subtractable
struct	swappable
	specifies that a type can be swapped or that two types can be swapped with each other More...
struct	swappable_with
	specifies that a type can be swapped or that two types can be swapped with each other More...
struct	totally_ordered
	specifies that the comparison operators on the type yield a total order More...
struct	totally_ordered_with
	specifies that the comparison operators on the type yield a total order More...
struct	ValueSwappable
struct	weakly_equality_comparable_with
	specifies that two different objects can be compared for equality with each other (in either order) using both == and != More...
class	byte
class	bad_expected_access
class	bad_expected_access< void >
class	expected
struct	unexpect_t
class	unexpected
struct	basic_FNV_prime
struct	basic_FNV_prime< T, 32 >
struct	basic_FNV_prime< T, 64 >
struct	basic_FNV_offset_basis
struct	basic_FNV_offset_basis< T, 32 >
struct	basic_FNV_offset_basis< T, 64 >
struct	identity
	function object that returns its argument unchanged More...
class	basic_const_iterator
struct	common_type< basic_const_iterator< T >, U >
struct	common_type< T, basic_const_iterator< U > >
struct	common_type< basic_const_iterator< T >, basic_const_iterator< U > >
struct	bidirectional_iterator
	specifies that a forward_iterator is a bidirectional iterator, supporting movement backwards More...
class	common_iterator
struct	incrementable_traits< common_iterator< I, S > >
struct	cxx20_iterator_traits< common_iterator< I, S > >
struct	contiguous_iterator
	specifies that a random_access_iterator is a contiguous iterator, referring to elements that are contiguous in memory More...
class	counted_iterator
struct	cxx20_iterator_traits< counted_iterator< I > >
struct	default_sentinel_t
struct	forward_iterator
	specifies that an input_iterator is a forward iterator, supporting equality comparison and multi-pass More...
struct	incrementable
struct	incrementable_traits
	computes the difference type of a weakly_incrementable type More...
struct	incrementable_traits< const T >
struct	indirect_binary_predicate
	specifies that a callable type, when invoked with the result of dereferencing two indirectly_readable types, satisfies predicate More...
struct	indirect_equivalence_relation
struct	indirect_result
struct	indirect_strict_weak_order
	specifies that a callable type, when invoked with the result of dereferencing two indirectly_readable types, satisfies strict_weak_order More...
struct	indirect_unary_predicate
	specifies that a callable type, when invoked with the result of dereferencing an indirectly_readable type, satisfies predicate More...
struct	indirectly_comparable
	specifies that the values referenced by two indirectly_readable types can be compared More...
struct	indirectly_copyable
	specifies that values may be copied from an indirectly_readable type to an indirectly_writable type More...
struct	indirectly_copyable_storable
	specifies that values may be copied from an indirectly_readable type to an indirectly_writable type and that the copy may be performed via an intermediate object More...
struct	indirectly_movable
	specifies that values may be moved from an indirectly_readable type to an indirectly_writable type More...
struct	indirectly_movable_storable
	specifies that values may be moved from an indirectly_readable type to an indirectly_writable type and that the move may be performed via an intermediate object More...
struct	indirectly_readable
struct	indirectly_readable_traits
struct	indirectly_readable_traits< T * >
struct	indirectly_readable_traits< const T >
struct	indirectly_regular_unary_invocable
	specifies that a callable type can be invoked with the result of dereferencing an indirectly_readable type More...
struct	indirectly_swappable
struct	indirectly_unary_invocable
	specifies that a callable type can be invoked with the result of dereferencing an indirectly_readable type More...
struct	indirectly_writable
	specifies that a value can be written to an iterator's referenced object More...
struct	input_iterator
	specifies that a type is an input iterator, that is, its referenced values can be read and it can be both pre- and post-incremented More...
struct	input_or_output_iterator
	specifies that objects of a type can be incremented and dereferenced More...
struct	iter_common_reference
struct	iter_const_reference
struct	iter_difference
struct	iter_key
struct	iter_mapped
struct	iter_reference
struct	iter_rvalue_reference
struct	iter_val
struct	iter_value
struct	contiguous_iterator_tag
struct	iterator_ignore
struct	cxx20_iterator_traits
struct	cxx20_iterator_traits< T * >
struct	LegacyBidirectionalIterator
struct	LegacyBidirectionalIterator< It, true >
struct	LegacyForwardIterator
struct	LegacyForwardIterator< It, true >
struct	LegacyInputIterator
struct	LegacyInputIterator< I, true >
struct	LegacyIterator
struct	LegacyIterator< I, true >
struct	LegacyRandomAccessIterator
struct	LegacyRandomAccessIterator< I, true >
struct	mergeable
struct	disable_sized_sentinel_for< std::move_iterator< Iterator1 >, std::move_iterator< Iterator2 > >
struct	cxx20_iterator_traits< std::move_iterator< Iter > >
class	move_sentinel
struct	output_iterator
	specifies that a type is an output iterator for a given value type, that is, values of that type can be written to it and it can be both pre- and post-incremented More...
struct	permutable
struct	random_access_iterator
	specifies that a bidirectional_iterator is a random-access iterator, supporting advancement in constant time and subscripting More...
struct	disable_sized_sentinel_for< std::reverse_iterator< I1 >, std::reverse_iterator< I2 > >
struct	cxx20_iterator_traits< std::reverse_iterator< Iter > >
struct	sentinel_for
struct	disable_sized_sentinel_for
struct	sized_sentinel_for
	specifies that the - operator can be applied to an iterator and a sentinel to calculate their difference in constant time More...
struct	sortable
struct	unreachable_sentinel_t
	sentinel that always compares unequal to any weakly_incrementable type More...
struct	weakly_incrementable
struct	pointer_traits
struct	pointer_traits< T * >
struct	float_equal_to
	function object implementing approximately equal of x and y More...
struct	float_equal_to< void >
	A specialization of vccc::float_equal_to with parameter and return type deduced. More...
class	bad_optional_access
	exception indicating checked access to an optional that doesn't contain a value More...
class	optional
	a wrapper that may or may not hold an object More...
struct	nullopt_t
	indicator of optional type with uninitialized state More...
struct	from_range_t
class	movable_box
class	span
	a non-owning view over a contiguous sequence of objects More...
struct	tuple_like
	specifies that a type implemented the tuple protocol More...
struct	sized_tuple_like
	check if tuple-like objects with exactly N elements. More...
struct	are_arithmetic
struct	are_integral
struct	are_floating_point
struct	are_scalar
struct	arity
	get parameter count of a given function More...
struct	bigger_type
struct	bigger_type< T >
struct	bigger_type< T1, T2 >
struct	bigger_type< T1, T2, Ts... >
struct	signed_bigger_type
struct	signed_bigger_type< T >
struct	signed_bigger_type< T1, T2 >
struct	signed_bigger_type< T1, T2, Ts... >
struct	unsigned_bigger_type
struct	unsigned_bigger_type< T >
struct	unsigned_bigger_type< T1, T2 >
struct	unsigned_bigger_type< T1, T2, Ts... >
struct	always_false
struct	always_true
struct	common_reference
struct	basic_common_reference
struct	common_reference<>
struct	common_reference< T >
struct	common_reference< T1, T2 >
struct	common_reference< T1, T2, R... >
struct	basic_common_reference< std::pair< T1, T2 >, std::pair< U1, U2 >, TQual, UQual >
struct	basic_common_reference< std::reference_wrapper< R >, T, RQual, TQual >
struct	basic_common_reference< T, std::reference_wrapper< R >, TQual, RQual >
struct	common_type
struct	common_type<>
struct	common_type< T >
struct	common_type< T1, T2 >
struct	common_type< T1, T2, Ts... >
struct	common_type< std::pair< T1, T2 >, std::pair< U1, U2 > >
struct	common_type< std::chrono::duration< Rep1, Period1 >, std::chrono::duration< Rep2, Period2 > >
struct	common_type< std::chrono::time_point< Clock, Duration1 >, std::chrono::time_point< Clock, Duration2 > >
struct	conjunction
struct	conjunction<>
struct	conjunction< B1 >
struct	conjunction< B1, BN... >
struct	copy_const
struct	copy_const< const From, To >
struct	copy_volatile
struct	copy_volatile< volatile From, To >
struct	copy_cv
struct	copy_reference
struct	copy_reference< From &, To >
struct	copy_reference< From &&, To >
struct	copy_cvref
struct	copy_template
struct	copy_template< From< T... >, To, Proj >
struct	disjunction
struct	disjunction<>
struct	disjunction< B1 >
struct	disjunction< B1, BN... >
struct	empty
struct	has_operator_arrow
struct	has_operator_arrow< T, void_t< decltype(std::declval< T >().operator->())> >
struct	has_typename_difference_type
struct	has_typename_difference_type< T, void_t< typename T::difference_type > >
struct	has_typename_element_type
struct	has_typename_element_type< T, void_t< typename T::element_type > >
struct	has_typename_type
struct	has_typename_type< T, void_t< typename T::type > >
struct	has_typename_value_type
struct	has_typename_value_type< T, void_t< typename T::value_type > >
struct	is_bounded_array
struct	is_bounded_array< T[N]>
struct	is_character
	Check if type is character type. More...
struct	is_class_or_enum
struct	is_explicitly_constructible
struct	is_explicitly_convertible
struct	is_explicitly_convertible< From, To, void_t< decltype(static_cast< To >(std::declval< From >()))> >
struct	is_implicitly_constructible
struct	is_initializer_list
struct	is_integer_like
	Check if type models integer-like type (C++ 20 requirement) More...
struct	is_signed_integer_like
struct	is_unsigned_integer_like
struct	invoke_result
	deduces the result type of invoking a callable object with a set of arguments More...
struct	is_invocable
	Determines whether INVOKE(std::declval<Fn>(), std::declval<ArgTypes>()...) is well formed when treated as anunevaluated operand. More...
struct	is_invocable_r
	Determines whether INVOKE<R>(std::declval<Fn>(), std::declval<ArgTypes>()...) is well formed when treated as an unevaluated operand. More...
struct	is_nothrow_invocable
	Determines whether INVOKE(std::declval<Fn>(), std::declval<ArgTypes>()...) is well formed when treated as an unevaluated operand, and is known not to throw any exceptions. More...
struct	is_nothrow_invocable_r
	Determines whether INVOKE<R>(std::declval<Fn>(), std::declval<ArgTypes>()...) is well formed when treated as an unevaluated operand, and is known not to throw any exceptions. More...
struct	is_list_initializable
struct	is_copy_list_initializable
struct	is_nothrow_convertible
struct	is_printable
struct	is_printable< T, void_t< decltype(std::declval< std::ostream & >()<< std::declval< const T & >())> >
struct	is_range
	check if a type met range requirements(deprecated) More...
struct	is_range< T, void_t< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end())> >
struct	is_referencable
struct	is_referencable< T, void_t< T & > >
struct	is_specialization
struct	is_specialization< Ref< Args... >, Ref >
struct	is_string_like
struct	is_string_like< const char * >
struct	is_swappable
struct	is_nothrow_swappable
struct	is_swappable_with
struct	is_nothrow_swappable_with
struct	is_tuple_like
	Check if type is tuple-like(deprecated. Use tuple_like instead) More...
struct	is_tuple_like< T, void_t< decltype(std::tuple_size< T >::value)> >
struct	is_unbounded_array
struct	is_unbounded_array< T[]>
struct	is_iterator
struct	value >>
struct	is_iterable
struct	lossless_type_add
struct	lossless_type_mul
struct	lossless_type_div
struct	negation
struct	multiples_of
	check if A is multiples of B More...
struct	is_odd
	check if a value is odd More...
struct	is_even
	check if a value is even More...
struct	static_max
struct	static_max< T, v >
struct	static_max< T, v1, v2, v3... >
struct	static_min
struct	static_min< T, v >
struct	static_min< T, v1, v2, v3... >
struct	static_diff
	Get abs(v1 - v2) in compile-time. More...
struct	remove_cvref
struct	simple_common_reference
struct	simple_common_reference< T1 &, T2 & >
struct	simple_common_reference< T1 &&, T2 && >
struct	simple_common_reference< A &, B && >
struct	simple_common_reference< B &&, A & >
struct	template_arity
	get template parameter count of template class More...
struct	mandatory_template_arity
	get mandatory template parameter count of template class More...
struct	default_template_arity
	get default template parameter count of template class More...
struct	type_identity
struct	compressed_pair_empty_t
class	compressed_pair
	An size-optimized pair using empty base optimization. More...
struct	in_place_t
	in-place construction tag More...
struct	in_place_type_t
struct	in_place_index_t
struct	nontype_t
	value construction tag More...
struct	type_sequence
struct	type_sequence_type_count
	count the number of occurences of T in type_sequence More...
struct	type_sequence_type_index
	get the index of T in type_sequence. More...
struct	type_sequence_element_type
	get type of \(I\)-th element of type_sequence More...
struct	type_sequence_element_type< I, type_sequence<> >
struct	type_sequence_element_type< 0, type_sequence< U, Us... > >
struct	type_sequence_element_type< I, type_sequence< U, Us... > >
class	bad_variant_access
struct	monostate
class	variant
	a type-safe discriminated union More...
struct	variant_alternative
struct	variant_alternative< I, const T >
struct	variant_alternative< I, variant< Types... > >
struct	variant_size
struct	variant_size< variant< Ts... > >
struct	variant_size< const T >
class	basic_string_view
	The templated class vccc::basic_string_view provides a lightweight object that offers read-only access to a string or a part of a string using an interface similar to the interface of std::basic_string. More...

Typedefs
using	StreamWrapper = BasicStreamWrapper< char >
using	FNV_prime = basic_FNV_prime< std::size_t >
using	FNV_offset_basis = basic_FNV_offset_basis< std::size_t >
template<typename I >
using	const_iterator = std::enable_if_t< input_iterator< I >::value, std::conditional_t< detail::constant_iterator< I >::value, I, basic_const_iterator< I > > >
template<typename S >
using	const_sentinel = std::enable_if_t< semiregular< S >::value, std::conditional_t< input_iterator< S >::value, const_iterator< S >, S > >
template<typename F , typename... Is>
using	indirect_result_t = typename indirect_result< F, Is... >::type
template<typename T >
using	iter_common_reference_t = typename iter_common_reference< T >::type
	Computes the common reference type of T. This is the common reference type between its reference type and an lvalue reference to its value type. More...
template<typename T >
using	iter_const_reference_t = typename iter_const_reference< T >::type
template<typename T >
using	iter_difference_t = typename iter_difference< T >::type
	Computes the difference type of T More...
template<typename T >
using	iter_key_t = typename iter_key< T >::type
template<typename T >
using	iter_mapped_t = typename iter_mapped< T >::type
template<typename T >
using	iter_reference_t = typename iter_reference< T >::type
template<typename T >
using	iter_rvalue_reference_t = typename iter_rvalue_reference< T >::type
template<typename T >
using	iter_val_t = typename iter_val< T >::type
template<typename T >
using	iter_value_t = typename iter_value< T >::type
using	input_iterator_tag = std::input_iterator_tag
using	output_iterator_tag = std::output_iterator_tag
using	forward_iterator_tag = std::forward_iterator_tag
using	bidirectional_iterator_tag = std::bidirectional_iterator_tag
using	random_access_iterator_tag = std::random_access_iterator_tag
template<typename I , typename Proj >
using	projected = typename detail::projected_impl< I, Proj >::type
template<typename I , typename Proj >
using	projectable = has_typename_type< detail::projected_impl< I, Proj > >
	Test if expression vccc::projected<I, Proj> is valid in an unqualified context. More...
template<typename T >
using	pair_like = sized_tuple_like< T, 2 >
	pair-like objects are tuple-like objects with exactly 2 elements. More...
template<typename ... Ts>
using	are_arithmetic_t = typename are_arithmetic< Ts... >::type
template<typename ... Ts>
using	are_integral_t = typename are_integral< Ts... >::type
template<typename ... Ts>
using	are_floating_point_t = typename are_floating_point< Ts... >::type
template<typename ... Ts>
using	are_scalar_t = typename are_scalar< Ts... >::type
template<typename T >
using	arity_t = typename arity< T >::type
template<typename ... Ts>
using	bigger_type_t = typename bigger_type< Ts... >::type
template<typename ... Ts>
using	signed_bigger_type_t = typename signed_bigger_type< Ts... >::type
template<typename ... Ts>
using	unsigned_bigger_type_t = typename unsigned_bigger_type< Ts... >::type
template<bool v>
using	bool_constant = std::integral_constant< bool, v >
template<typename... T>
using	common_reference_t = typename common_reference< T... >::type
template<typename ... T>
using	common_type_t = typename common_type< T... >::type
template<typename From , typename To >
using	copy_const_t = typename copy_const< From, To >::type
template<typename From , typename To >
using	copy_volatile_t = typename copy_volatile< From, To >::type
template<typename From , typename To >
using	copy_cv_t = typename copy_cv< From, To >::type
template<typename From , typename To >
using	copy_reference_t = typename copy_reference< From, To >::type
template<typename From , typename To >
using	copy_cvref_t = typename copy_cvref< From, To >::type
template<typename From , template< typename... > class To, template< typename, typename... > class Proj = type_identity_t>
using	copy_template_t = typename copy_template< From, To, Proj >::type
template<class T >
using	is_complete = decltype(detail::is_complete_impl(std::declval< T * >()))
template<typename T , typename... Args>
using	is_explicitly_constructible_t = typename is_explicitly_constructible< T, Args... >::type
template<typename T , typename... Args>
using	is_implicitly_constructible_t = typename is_implicitly_constructible< T, Args... >::type
template<typename F , typename ... Args>
using	invoke_result_t = typename invoke_result< F, Args... >::type
template<typename To , typename From >
using	is_list_initializable_t = typename is_list_initializable< To, From >::type
template<typename To , typename From >
using	is_copy_list_initializable_t = typename is_copy_list_initializable< To, From >::type
template<typename T >
using	is_range_t = typename is_range< T >::type
template<typename T >
using	is_string_like_t = typename is_string_like< T >::type
template<typename T >
using	is_iterator_t = typename is_iterator< T >::type
template<typename ... Types>
using	decay_if_float_t = typename std::conditional_t< conjunction< std::is_same< Types, float >... >::value, float, double >
template<typename ... Ts>
using	lossless_type_add_t = typename lossless_type_add< Ts... >::type
template<typename ... Ts>
using	lossless_type_mul_t = typename lossless_type_mul< Ts... >::type
template<typename ... Ts>
using	lossless_type_div_t = typename lossless_type_div< Ts... >::type
template<bool Const, typename V >
using	maybe_const = std::conditional_t< Const, const V, V >
template<typename T , T A, T B>
using	multiples_of_t = typename multiples_of< T, A, B >::type
template<typename T , T A>
using	is_odd_t = typename is_odd< T, A >::type
template<typename T , T A>
using	is_even_t = typename is_even< T, A >::type
template<typename T >
using	remove_cvref_t = typename remove_cvref< T >::type
template<typename T >
using	type_identity_t = typename type_identity< T >::type
template<typename ... >
using	void_t = void
template<std::size_t N>
using	make_rindex_sequence = decltype(internal::rindex_sequence(std::make_index_sequence< N >{}))
	alias of reverse index sequence More...
template<typename T , T v, std::size_t N>
using	make_same_sequence = decltype(internal::same_sequence< T, v >(std::make_integer_sequence< T, N >{}))
	alias of same integer sequence More...
template<std::size_t N>
using	make_zero_sequence = make_same_sequence< int, 0, N >
	alias of zero std::size_t sequence More...
template<typename T , T begin, T end, T step = 1, T size = (end + (end>0?-1:1) - begin)/step>
using	make_range_sequence = decltype(internal::range_sequence< T, begin, step >(std::make_integer_sequence< T,(size >=0 ? size+1 :size)>{}))
	alias of range integer sequence More...
template<std::size_t begin, std::size_t end, std::size_t step = 1, std::size_t size = (end + (end>0?-1:1) - begin)/step>
using	make_index_range_sequence = decltype(internal::range_sequence< std::size_t, begin, step >(std::make_integer_sequence< std::size_t,(size >=0 ? size+1 :size)>{}))
	alias of range index sequence More...
template<typename T , std::size_t N>
using	make_type_sequence = typename detail::make_type_sequence_impl< T, N >::type
	create a type_sequence that holds T of N times More...
template<std::size_t I, typename TS >
using	type_sequence_element_type_t = typename type_sequence_element_type< I, TS >::type
template<std::size_t I, class T >
using	variant_alternative_t = typename variant_alternative< I, T >::type
using	string_view = basic_string_view< char >
using	wstring_view = basic_string_view< wchar_t >
using	u16string_view = basic_string_view< char16_t >
using	u32string_view = basic_string_view< char32_t >

Enumerations
enum	group_category { ungrouped_front , grouped , ungrouped_back }
enum	slot_position { at_back , at_front }

Functions
Formatter	operator""_format (const char *format, std::size_t)
	Formatter helper on string literal. More...
template<typename T >
T	epsilon ()
	Get machine epsilon for the given type. More...
template<std::size_t i, typename Tuple , typename T >
constexpr auto	addEpsilon (Tuple vars, T epsilon)
	Increase the value by small amount. More...
template<typename T , typename DifferentialCategory = differential_symmetric_t, typename Func , typename ... Vars, typename ... Args>
auto	gradient (Func f, std::tuple< Vars... > vars, Args &&... args)
template<typename E1 , typename E2 , std::enable_if_t< internal::math::is_same_size< E1, E2 >::value, int > = 0>
constexpr bool	operator== (const MatrixBase< E1 > &lhs, const MatrixBase< E2 > &rhs)
template<typename E1 , typename E2 , std::enable_if_t< internal::math::is_same_size< E1, E2 >::value, int > = 0>
constexpr bool	operator!= (const MatrixBase< E1 > &lhs, const MatrixBase< E2 > &rhs)
template<typename LhsType , typename RhsType , std::enable_if_t<!is_matrix< RhsType >::value, int > = 0>
constexpr MatrixDivScalar< LhsType, RhsType >	operator/ (const MatrixBase< LhsType > &lhs, const RhsType &value)
template<typename E >
constexpr MatrixMinus< E >	operator- (const MatrixBase< E > &lhs)
template<typename E1 , typename E2 , std::enable_if_t<(internal::math::traits< E1 >::cols==internal::math::traits< E2 >::rows), int > = 0>
constexpr MatrixMulMatrix< E1, E2 >	operator* (const MatrixBase< E1 > &lhs, const MatrixBase< E2 > &rhs)
template<typename LhsType , typename RhsType , std::enable_if_t<!is_matrix< RhsType >::value, int > = 0>
constexpr MatrixMulScalar< LhsType, RhsType >	operator* (const MatrixBase< LhsType > &lhs, const RhsType &value)
template<typename E >
std::ostream &	operator<< (std::ostream &os, const MatrixBase< E > &mat_expr)
template<typename E1 , typename E2 , std::enable_if_t< internal::math::is_same_size< E1, E2 >::value, int > = 0>
MatrixSub< E1, E2 >	operator- (const MatrixBase< E1 > &lhs, const MatrixBase< E2 > &rhs) noexcept
template<typename E1 , typename E2 , std::enable_if_t< internal::math::is_same_size< E1, E2 >::value, int > = 0>
constexpr MatrixSum< E1, E2 >	operator+ (const MatrixBase< E1 > &lhs, const MatrixBase< E2 > &rhs)
template<typename T , std::size_t I, typename Func , typename VarTuple , typename ... Args>
auto	partialDiff (differential_symmetric_t, Func f, VarTuple vars, Args &&... args)
	get partial differential value using symmetric method More...
template<typename T , std::size_t I, typename Func , typename VarTuple , typename ... Args>
auto	partialDiff (differential_newtonian_t, Func f, VarTuple vars, Args &&... args)
	get partial differential value using newtonian method More...
template<typename T , std::size_t I, typename Func , typename VarTuple , typename ... Args>
auto	partialDiff (differential_five_point_stencil_t, Func f, VarTuple vars, Args &&... args)
	get partial differential value using five point stencil method More...
template<typename T , typename Container = std::unordered_set<T>, typename RandomGenerator >
Container	pick_k (T a, T b, T k, RandomGenerator &&gen)
	pick k from int range [a, b] (no duplicates) More...
template<typename T , typename Container = std::vector<T>>
Container	random_sample (T a, T b, T k, std::mt19937 &&gen=std::mt19937(std::random_device{}()))
	get shuffled random sample in [a, b], size k More...
template<typename T , typename Container = std::vector<T>, typename Generator >
Container	random_sample (T a, T b, T k, Generator &&gen)
template<typename Group >
bool	operator== (const group_key< Group > &lhs, const group_key< Group > &rhs)
template<typename Group >
bool	operator!= (const group_key< Group > &lhs, const group_key< Group > &rhs)
template<std::size_t I, typename T , std::enable_if_t< is_tuple_like< std::decay_t< T >>::value, int > = 0>
constexpr decltype(auto)	at (T &&t) noexcept
	Return i-th element of tuple-like object. More...
template<std::size_t i, std::size_t j, typename C , typename T >
constexpr decltype(auto)	at (T &&t)
	returns cv::saturate_cast<C>(vccc::at<i, j>(t)) More...
template<typename ... Args>
constexpr internal::bind_obj< Args... >	bind_at (Args &&... args)
	call at<...>(...) to args... More...
template<typename Container >
back_emplace_iterator< Container >	back_emplacer (Container &container)
	make back_emplace_iterator More...
template<typename ToType , typename FromType >
constexpr decltype(auto)	cast (FromType &&from)
template<typename To , typename From , std::enable_if_t<!std::is_same< To, From >::value, int > = 0>
std::enable_if_t< disjunction< is_tuple_like< To >, is_tuple_like< From > >::value, To >	convert_to (const From &from)
template<typename To , std::size_t n, typename From , std::enable_if_t<!std::is_same< To, From >::value, int > = 0>
std::enable_if_t< disjunction< is_tuple_like< To >, is_tuple_like< From > >::value, To >	convert_to (const From &from)
	convert with specifying the converting size convert to container types: same size as n convert to opencv types: fill rest with 0 More...
template<typename To >
decltype(auto)	convert_to (To &&from)
	converting to same type More...
template<typename To >
To	convert_to (const To &from)
template<std::size_t i, typename R , std::enable_if_t< ranges::range< R >::value, int > = 0>
decltype(auto)	at (R &&container)
template<std::size_t i, std::size_t j, typename T , int m, int n>
constexpr T &	at (cv::Matx< T, m, n > &matx)
template<std::size_t i, std::size_t j, typename T , int m, int n>
constexpr const T &	at (const cv::Matx< T, m, n > &matx)
template<std::size_t i, std::size_t j, typename T , int m, int n>
constexpr T &&	at (cv::Matx< T, m, n > &&matx)
template<std::size_t i, std::size_t j, typename T , int m, int n>
constexpr const T &&	at (const cv::Matx< T, m, n > &&matx)
template<typename T , int m, int n, typename N >
cv::Matx< T, m, n >	add (const cv::Matx< T, m, n > &matx, N n_)
template<typename T , typename N >
cv::Point_< T >	add (const cv::Point_< T > &point2, N n)
template<typename T , typename N >
cv::Point3_< T >	add (const cv::Point3_< T > &point3, N n)
template<int new_size, typename T , std::enable_if_t< new_size==2, int > = 0>
auto	resize (const cv::Point_< T > &from)
template<int new_size, typename T , std::enable_if_t< new_size==2, int > = 0>
auto	resize (const cv::Point3_< T > &from)
template<typename T , int cn, typename N >
cv::Vec< T, cn >	add (const cv::Vec< T, cn > &vec, N n)
template<int new_size, typename T , typename = void_t<decltype(std::declval<T>().resize(new_size))>>
decltype(auto)	resize (T &&t)
	returns any resized resizable type More...
template<std::size_t i, typename ... Args, std::enable_if_t<(i< sizeof...(Args)), int > = 0>
decltype(auto)	variadic_at (Args &&... args)
	Index-based value accessor. More...
template<typename T , typename Allocator = std::allocator<T>>
std::vector< T, Allocator >	reserved_vector (typename std::vector< T, Allocator >::size_type size)
	returns reserved vector More...
template<typename T , typename Allocator >
std::vector< T, Allocator > &	concat (std::vector< T, Allocator > &to, const std::vector< T, Allocator > &from)
template<typename T , typename Allocator >
std::vector< T, Allocator > &	concat (std::vector< T, Allocator > &to, std::vector< T, Allocator > &&from)
	concat two vectors More...
template<typename NewType , template< typename, int... > class CVType, typename OldType , int ... CVParams, std::enable_if_t<!std::is_same< NewType, OldType >::value, int > = 0>
decltype(auto)	vtype_convert (const CVType< OldType, CVParams... > &cv_type)
	returns similar opencv type, but the value_type is different More...
template<typename NewType , typename Func , template< typename... > class Container, typename OldType , typename ... Params, std::enable_if_t< is_range< Container< OldType, Params... >>::value, int > = 0>
decltype(auto)	vtype_convert (const Container< OldType, Params... > &container, Func func)
	vtype_convert on container types with custom unary operation More...
template<typename NewType , template< typename... > class Container, typename ... Params, typename UnaryOperation , std::enable_if_t< is_range< Container< NewType, Params... >>::value, int > = 0>
decltype(auto)	vtype_convert (const Container< NewType, Params... > &container, UnaryOperation func)
template<typename NewType , template< typename... > class Container, typename OldType , typename ... Params, std::enable_if_t< is_range< Container< OldType, Params... >>::value, int > = 0>
decltype(auto)	vtype_convert (const Container< OldType, Params... > &container)
	returns similar container type, but the value_type is different More...
template<typename NewType , template< typename... > class Container, typename ... Params, std::enable_if_t< is_range< Container< NewType, Params... >>::value, int > = 0>
decltype(auto)	vtype_convert (const Container< NewType, Params... > &container)
template<typename NewType , template< typename... > class Container, typename ... Params, std::enable_if_t< is_range< Container< NewType, Params... >>::value, int > = 0>
decltype(auto)	vtype_convert (Container< NewType, Params... > &&container)
template<typename NewType , typename OldType , std::size_t n, typename UnaryOperation , std::enable_if_t<!std::is_same< NewType, OldType >::value, int > = 0>
constexpr decltype(auto)	vtype_convert (const std::array< OldType, n > &container, UnaryOperation func)
template<typename NewType , std::size_t n, typename UnaryOperation >
constexpr decltype(auto)	vtype_convert (const std::array< NewType, n > &container, UnaryOperation func)
template<typename NewType , std::size_t n, typename UnaryOperation >
constexpr decltype(auto)	vtype_convert (std::array< NewType, n > &&container, UnaryOperation func)
template<typename NewType , typename OldType , std::size_t n, std::enable_if_t<!std::is_same< NewType, OldType >::value, int > = 0>
constexpr decltype(auto)	vtype_convert (const std::array< OldType, n > &container)
template<typename NewType , std::size_t n>
constexpr decltype(auto)	vtype_convert (const std::array< NewType, n > &container)
template<typename NewType , std::size_t n>
constexpr decltype(auto)	vtype_convert (std::array< NewType, n > &&container)
template<typename T , typename Compare >
constexpr const T &	clamp (const T &v, const T &lo, const T &hi, Compare comp)
template<typename T >
constexpr const T &	clamp (const T &v, const T &lo, const T &hi)
template<typename InputIt , typename Size , typename UnaryFunction >
constexpr InputIt	for_each_n (InputIt first, Size n, UnaryFunction f)
template<typename ForwardIt >
constexpr ForwardIt	shift_left (ForwardIt first, ForwardIt last, typename cxx20_iterator_traits< ForwardIt >::difference_type n)
template<typename ForwardIt >
constexpr ForwardIt	shift_right (ForwardIt first, ForwardIt last, typename cxx20_iterator_traits< ForwardIt >::difference_type n)
template<typename T , std::size_t N, std::enable_if_t< std::is_constructible< T, T & >::value &&!std::is_array< T >::value, int > = 0>
constexpr std::array< std::remove_cv_t< T >, N >	to_array (T(&a)[N])
template<typename T , std::size_t N, std::enable_if_t< std::is_move_constructible< T >::value &&!std::is_array< T >::value, int > = 0>
constexpr std::array< std::remove_cv_t< T >, N >	to_array (T(&&a)[N])
template<typename IntegerType >
constexpr std::enable_if_t< std::is_integral< IntegerType >::value, IntegerType >	to_integer (byte b) noexcept
template<class IntegerType >
constexpr std::enable_if_t< std::is_integral< IntegerType >::value, byte >	operator<< (byte b, IntegerType shift) noexcept
template<class IntegerType >
constexpr std::enable_if_t< std::is_integral< IntegerType >::value, byte >	operator>> (byte b, IntegerType shift) noexcept
template<class IntegerType >
constexpr std::enable_if_t< std::is_integral< IntegerType >::value, byte & >	operator<<= (byte &b, IntegerType shift) noexcept
template<class IntegerType >
constexpr std::enable_if_t< std::is_integral< IntegerType >::value, byte & >	operator>>= (byte &b, IntegerType shift) noexcept
constexpr byte	operator| (byte l, byte r) noexcept
constexpr byte	operator& (byte l, byte r) noexcept
constexpr byte	operator^ (byte l, byte r) noexcept
constexpr byte	operator~ (byte b) noexcept
constexpr byte &	operator|= (byte &l, byte r) noexcept
constexpr byte &	operator&= (byte &l, byte r) noexcept
constexpr byte &	operator^= (byte &l, byte r) noexcept
template<typename F , typename... Args, std::enable_if_t< conjunction< std::is_constructible< std::decay_t< F >, F >, std::is_move_constructible< std::decay_t< F >>, std::is_constructible< std::decay_t< Args >, Args >..., std::is_move_constructible< std::decay_t< Args >>... >::value, int > = 0>
constexpr auto	bind_back (F &&f, Args &&... args)
template<typename F , typename... Args, std::enable_if_t< conjunction< std::is_constructible< std::decay_t< F >, F >, std::is_move_constructible< std::decay_t< F >>, std::is_constructible< std::decay_t< Args >, Args >..., std::is_move_constructible< std::decay_t< Args >>... >::value, int > = 0>
constexpr auto	bind_front (F &&f, Args &&... args)
template<typename T >
std::size_t	FNV_1 (std::size_t value, const T &byte)
std::size_t	FNV_1 (std::size_t value, const unsigned char *const bytes, std::size_t size)
template<typename T >
std::size_t	FNV_1a (std::size_t value, const T &byte)
std::size_t	FNV_1a (std::size_t value, const unsigned char *const bytes, std::size_t size)
template<typename T >
std::size_t	hash_array (const T *bytes, std::size_t size)
template<typename T , std::size_t N>
std::size_t	hash_array (const T(&bytes)[N])
template<typename F , typename ... Args>
constexpr invoke_result_t< F, Args... >	invoke (F &&f, Args &&... args) noexcept(is_nothrow_invocable< F, Args... >::value)
template<typename R , typename F , typename ... Args>
constexpr std::enable_if_t< is_invocable_r< R, F, Args... >::value, R >	invoke_r (F &&f, Args &&... args) noexcept(is_nothrow_invocable_r< R, F, Args... >::value)
template<typename I , std::enable_if_t< input_iterator< I >::value, int > = 0>
constexpr const_iterator< I >	make_const_iterator (I it)
template<typename S , std::enable_if_t< semiregular< S >::value, int > = 0>
constexpr const_sentinel< S >	make_const_sentinel (S s)
template<typename T >
std::enable_if_t< std::is_object< T >::value, T * >	addressof (T &t) noexcept
template<typename T >
constexpr std::enable_if_t< std::is_object< T >::value==false, T * >	addressof (T &t) noexcept
template<typename T >
constexpr const T *	addressof (T &&)=delete
template<typename T , typename... Args, std::enable_if_t< detail::in_place_constructible< T, Args... >::value, int > = 0>
constexpr T *	construct_at (T *p, Args &&... args) noexcept(std::is_nothrow_constructible< T, Args... >::value)
template<typename ForwardIt >
VCCC_CONSTEXPR_AFTER_CXX20 void	destroy (ForwardIt first, ForwardIt last)
template<typename T , std::enable_if_t<!std::is_array< T >::value, int > = 0>
VCCC_CONSTEXPR_AFTER_CXX20 void	destroy_at (T *p)
template<class T >
constexpr T *	to_address (T *p) noexcept
template<class T >
constexpr auto	to_address (const T &p) noexcept
template<typename InputIterator , std::enable_if_t< is_iterable< InputIterator >::value, int > = 0>
constexpr auto	average (InputIterator first, InputIterator last)
	get average of iterator values [first, last) More...
template<typename InputIterator , typename UnaryOperation , std::enable_if_t< is_iterable< InputIterator >::value, int > = 0>
constexpr auto	average (InputIterator first, InputIterator last, UnaryOperation unary_op)
	get average of iterator values [first, last) More...
template<typename ... Numbers, std::enable_if_t< conjunction< std::is_arithmetic< Numbers >... >::value, int > = 0>
constexpr auto	average (Numbers... numbers)
	get average value of arithmetic types More...
template<typename ... Args, std::enable_if_t< conjunction< negation< disjunction< is_iterable< Args >... >>, negation< disjunction< std::is_arithmetic< Args >... >> >::value, int > = 0>
constexpr auto	average (const Args &... args)
	get average value of custom types More...
template<typename ... Ints, std::enable_if_t< conjunction< std::is_integral< Ints >... >::value, int > = 0>
constexpr auto	int_average (Ints... ints)
	get average value of integers(result is floored) More...
template<typename T , typename U , typename E = std::common_type_t<T, U>>
constexpr bool	float_equal (const T &a, const U &b, const E &epsilon=vccc::epsilon< E >())
	Compare if two floating-points are approximately equal. More...
template<typename T1 , typename T2 >
decltype(auto)	lossless_div (const T1 a, const T2 b)
	divide without narrowing More...
template<typename InputIterator , std::enable_if_t< is_iterable< InputIterator >::value, int > = 0>
auto	norm (InputIterator first, InputIterator last)
	calculate norm on iterator [first, last) More...
template<typename T , std::enable_if_t< std::is_arithmetic< T >::value, int > = 0>
T	norm (T arg)
template<typename Arg , typename ... Args, std::enable_if_t< conjunction< std::is_arithmetic< Arg >, std::is_arithmetic< Args... >>::value, int > = 0>
auto	norm (Arg arg, Args... args)
	calculate norm of variadics More...
template<typename To , typename From , std::enable_if_t< conjunction< std::is_integral< To >, std::is_integral< From >>::value, int > = 0>
constexpr To	saturate_cast (From x) noexcept
template<typename InputIterator , typename T , std::enable_if_t< is_iterator< InputIterator >::value, int > = 0>
auto	stddev (InputIterator first, InputIterator last, T avg)
	calculate standard deviation with pre-calculated average on iterators More...
template<typename InputIterator , std::enable_if_t< is_iterable< InputIterator >::value, int > = 0>
auto	stddev (InputIterator first, InputIterator last)
	calculate standard deviation on iterators More...
template<typename ... Numbers, std::enable_if_t< negation< disjunction< is_iterable< Numbers >... >>::value, int > = 0>
auto	stddev (Numbers... numbers)
	calculate standard deviation on variadics More...
template<typename InputIterator >
auto	avg_stddev (InputIterator first, InputIterator last)
	calculate standard deviation and average More...
template<typename InputIterator , std::enable_if_t< is_iterable< InputIterator >::value, int > = 0>
constexpr auto	sum (InputIterator first, InputIterator last)
	sum of iterator [first, last) More...
template<typename InputIterator , typename UnaryOperation , std::enable_if_t< is_iterable< InputIterator >::value, int > = 0>
constexpr auto	sum (InputIterator first, InputIterator last, UnaryOperation unary_op)
	sum of iterator [first, last) with custom unary operator More...
template<typename ... Args, std::enable_if_t< negation< disjunction< is_iterable< Args >... >>::value, int > = 0>
constexpr auto	sum (const Args &... args)
	sum of variadic More...
template<typename UnaryOperation , typename Arg >
constexpr auto	sum_custom (const UnaryOperation &unary_op, const Arg &arg)
	sum of variadic with custom operator More...
template<typename UnaryOperation , typename Arg , typename ... Args>
constexpr auto	sum_custom (const UnaryOperation &unary_op, const Arg &arg, const Args &... args)
template<typename T >
constexpr T	square (const T &val)
	get squared value More...
template<typename InputIterator , std::enable_if_t< is_iterable< InputIterator >::value, int > = 0>
constexpr auto	square_sum (InputIterator first, InputIterator last)
	square sum of iterator [first, last) More...
template<typename Arg >
constexpr auto	square_sum (const Arg &arg)
template<typename Arg1 , typename Arg2 , std::enable_if_t< negation< disjunction< is_iterator< Arg1 >, is_iterable< Arg2 > > >::value, int > = 0>
constexpr auto	square_sum (const Arg1 &arg1, const Arg2 &arg2)
template<typename Arg , typename ... Args, std::enable_if_t<!is_iterable< Arg >::value, int > = 0>
constexpr auto	square_sum (const Arg &arg, const Args &... args)
	square sum of variadic More...
template<typename T >
constexpr optional< std::decay_t< T > >	make_optional (T &&value)
template<typename T >
constexpr optional< T >	make_optional ()
template<typename T , typename Arg , typename ... Args>
constexpr optional< T >	make_optional (Arg &&arg, Args &&... args)
template<typename T , typename U , typename ... Args>
constexpr optional< T >	make_optional (std::initializer_list< U > ilist, Args &&... args)
template<typename T , typename U >
constexpr bool	operator== (const optional< T > &lhs, const optional< U > &rhs)
template<typename T , typename U >
constexpr bool	operator!= (const optional< T > &lhs, const optional< U > &rhs)
template<typename T , typename U >
constexpr bool	operator< (const optional< T > &lhs, const optional< U > &rhs)
template<typename T , typename U >
constexpr bool	operator<= (const optional< T > &lhs, const optional< U > &rhs)
template<typename T , typename U >
constexpr bool	operator> (const optional< T > &lhs, const optional< U > &rhs)
template<typename T , typename U >
constexpr bool	operator>= (const optional< T > &lhs, const optional< U > &rhs)
template<typename T >
constexpr bool	operator== (const optional< T > &opt, nullopt_t) noexcept
template<typename T >
constexpr bool	operator== (nullopt_t, const optional< T > &opt) noexcept
template<typename T >
constexpr bool	operator!= (const optional< T > &opt, nullopt_t) noexcept
template<typename T >
constexpr bool	operator!= (nullopt_t, const optional< T > &opt) noexcept
template<typename T >
constexpr bool	operator< (const optional< T > &opt, nullopt_t) noexcept
template<typename T >
constexpr bool	operator< (nullopt_t, const optional< T > &opt) noexcept
template<typename T >
constexpr bool	operator<= (const optional< T > &opt, nullopt_t) noexcept
template<typename T >
constexpr bool	operator<= (nullopt_t, const optional< T > &opt) noexcept
template<typename T >
constexpr bool	operator> (const optional< T > &opt, nullopt_t) noexcept
template<typename T >
constexpr bool	operator> (nullopt_t, const optional< T > &opt) noexcept
template<typename T >
constexpr bool	operator>= (const optional< T > &opt, nullopt_t) noexcept
template<typename T >
constexpr bool	operator>= (nullopt_t, const optional< T > &opt) noexcept
template<typename T , typename U >
constexpr bool	operator== (const optional< T > &opt, const U &value)
template<typename T , typename U >
constexpr bool	operator== (const T &value, const optional< U > &opt)
template<typename T , typename U >
constexpr bool	operator!= (const optional< T > &opt, const U &value)
template<typename T , typename U >
constexpr bool	operator!= (const T &value, const optional< U > &opt)
template<typename T , typename U >
constexpr bool	operator< (const optional< T > &opt, const U &value)
template<typename T , typename U >
constexpr bool	operator< (const T &value, const optional< U > &opt)
template<typename T , typename U >
constexpr bool	operator<= (const optional< T > &opt, const U &value)
template<typename T , typename U >
constexpr bool	operator<= (const T &value, const optional< U > &opt)
template<typename T , typename U >
constexpr bool	operator> (const optional< T > &opt, const U &value)
template<typename T , typename U >
constexpr bool	operator> (const T &value, const optional< U > &opt)
template<typename T , typename U >
constexpr bool	operator>= (const optional< T > &opt, const U &value)
template<typename T , typename U >
constexpr bool	operator>= (const T &value, const optional< U > &opt)
template<typename T , std::size_t N>
constexpr span< const byte, detail::as_bytes_size< T, N >::value >	as_bytes (span< T, N > s) noexcept
	converts a span into a view of its underlying bytes More...
template<typename T , std::size_t N, std::enable_if_t< std::is_const< T >::value==false, int > = 0>
constexpr span< byte, detail::as_bytes_size< T, N >::value >	as_writable_bytes (span< T, N > s) noexcept
	converts a span into a view of its underlying bytes More...
template<class F , class Tuple >
constexpr decltype(auto)	apply (F &&f, Tuple &&t)
	calls a function with the elements of tuple of arguments More...
template<typename T , typename Tuple , std::enable_if_t< internal::is_constructible_from_tuple< T, Tuple >::value, int > = 0>
constexpr T	make_from_tuple (Tuple &&t)
	construct an object with a tuple of arguments More...
template<typename Tuple , typename T , typename F , std::enable_if_t< conjunction< tuple_like< Tuple >>::value, int > = 0>
constexpr auto	tuple_fold_left (Tuple &&tuple, T &&init, F &&f)
	Left fold operation for each tuple elements. More...
template<typename Tuple , typename F >
constexpr std::enable_if_t< detail::tuple_for_each_invocable< Tuple, F >::value >	tuple_for_each (Tuple &&t, F &&f)
template<typename Tuple , typename F >
constexpr std::enable_if_t< detail::tuple_for_each_in_place_index_invocable< Tuple, F >::value >	tuple_for_each_index (Tuple &&t, F &&f)
template<typename Tuple , typename F >
constexpr auto	tuple_transform (Tuple &&t, F &&f) noexcept(noexcept(detail::tuple_transform_impl(std::forward< Tuple >(t), std::forward< F >(f), std::make_index_sequence< std::tuple_size< remove_cvref_t< Tuple >>::value >{})))
	Constructs a new tuple with each elements transformed. More...
template<typename C >
constexpr auto	size (const C &c) -> decltype(c.size())
template<typename T , std::size_t N>
constexpr std::size_t	size (const T(&array)[N]) noexcept
template<typename C >
constexpr auto	ssize (const C &c) -> common_type_t< std::ptrdiff_t, std::make_signed_t< decltype(c.size())>>
template<typename T , std::ptrdiff_t N>
constexpr std::ptrdiff_t	ssize (const T(&array)[N]) noexcept
template<typename T >
constexpr std::add_const_t< T > &	as_const (T &t) noexcept
	obtains a reference to const to its argument More...
template<typename T >
void	as_const (T &&)=delete
template<typename T , typename U >
constexpr bool	cmp_equal (T t, U u) noexcept
template<typename T , typename U >
constexpr bool	cmp_not_equal (T t, U u) noexcept
template<typename T , typename U >
constexpr bool	cmp_less (T t, U u) noexcept
template<typename T , typename U >
constexpr bool	cmp_greater (T t, U u) noexcept
template<class T , class U >
constexpr bool	cmp_less_equal (T t, U u) noexcept
template<class T , class U >
constexpr bool	cmp_greater_equal (T t, U u) noexcept
template<typename T , typename U >
constexpr std::enable_if_t< conjunction< is_swappable< T >, is_swappable< U > >::value >	swap (compressed_pair< T, U > &lhs, compressed_pair< T, U > &rhs) noexcept(conjunction< is_nothrow_swappable< T >, is_nothrow_swappable< U >>::value)
template<typename R , typename T >
constexpr bool	in_range (T t) noexcept
template<typename T , T... v, typename F >
constexpr std::enable_if_t< detail::sequence_for_each_invocable< std::integer_sequence< T, v... >, F >::value >	sequence_for_each (std::integer_sequence< T, v... >, F &&f)
	performs f(std::integral_constant<T, i>{}) for i in v... More...
template<typename T , T N, typename F >
constexpr std::enable_if_t< detail::sequence_for_each_invocable< std::make_integer_sequence< T, N >, F >::value >	sequence_for_each (F &&f)
	performs f(std::integral_constant<T, i>{}) for i in [0, N) More...
template<std::size_t N, typename F >
constexpr std::enable_if_t< detail::sequence_for_each_invocable< std::make_index_sequence< N >, F >::value >	sequence_for_each (F &&f)
	performs f(std::integral_constant<std::size_t, i>{}) for i in [0, N) More...
template<typename T >
auto	getCurrentTime ()
decltype(auto)	getCurrentMilliseconds ()
decltype(auto)	getCurrentMicroseconds ()
decltype(auto)	getCurrentNanoseconds ()
template<typename Enum >
constexpr std::underlying_type_t< Enum > &	as_const (Enum e) noexcept
	converts an enumeration to its underlying type More...
template<typename T , typename... Types, std::enable_if_t<(type_sequence< Types... >::template count< T >==1), int > = 0>
constexpr bool	holds_alternative (const variant< Types... > &v) noexcept
constexpr bool	operator== (monostate, monostate) noexcept
constexpr bool	operator!= (monostate, monostate) noexcept
constexpr bool	operator< (monostate, monostate) noexcept
constexpr bool	operator> (monostate, monostate) noexcept
constexpr bool	operator<= (monostate, monostate) noexcept
constexpr bool	operator>= (monostate, monostate) noexcept
template<std::size_t I, typename... Types>
constexpr variant_alternative_t< I, variant< Types... > > &	get (variant< Types... > &v)
template<std::size_t I, typename... Types>
constexpr variant_alternative_t< I, variant< Types... > > &&	get (variant< Types... > &&v)
template<std::size_t I, typename... Types>
constexpr const variant_alternative_t< I, variant< Types... > > &	get (const variant< Types... > &v)
template<std::size_t I, typename... Types>
constexpr const variant_alternative_t< I, variant< Types... > > &&	get (const variant< Types... > &&v)
template<typename T , typename... Types, std::enable_if_t<(type_sequence_type_count< T, type_sequence< Types... >>::value==1), int > = 0>
constexpr T &	get (variant< Types... > &v)
template<typename T , typename... Types, std::enable_if_t<(type_sequence_type_count< T, type_sequence< Types... >>::value==1), int > = 0>
constexpr T &&	get (variant< Types... > &&v)
template<typename T , typename... Types, std::enable_if_t<(type_sequence_type_count< T, type_sequence< Types... >>::value==1), int > = 0>
constexpr const T &	get (const variant< Types... > &v)
template<typename T , typename... Types, std::enable_if_t<(type_sequence_type_count< T, type_sequence< Types... >>::value==1), int > = 0>
constexpr const T &&	get (const variant< Types... > &&v)
template<std::size_t I, typename... Types>
constexpr std::add_pointer_t< variant_alternative_t< I, variant< Types... > > >	get_if (variant< Types... > *pv) noexcept
template<std::size_t I, typename... Types>
constexpr std::add_pointer_t< const variant_alternative_t< I, variant< Types... > > >	get_if (const variant< Types... > *pv) noexcept
template<typename T , typename... Types, std::enable_if_t<(type_sequence_type_count< T, type_sequence< Types... >>::value==1), int > = 0>
constexpr std::add_pointer_t< T >	get_if (variant< Types... > *pv) noexcept
template<typename T , typename... Types, std::enable_if_t<(type_sequence_type_count< T, type_sequence< Types... >>::value==1), int > = 0>
constexpr std::add_pointer_t< const T >	get_if (const variant< Types... > *pv) noexcept
template<typename... Types, std::enable_if_t< conjunction< equality_comparable< Types >... >::value, int > = 0>
constexpr bool	operator== (const variant< Types... > &v, const variant< Types... > &w)
template<typename... Types, std::enable_if_t< conjunction< equality_comparable< Types >... >::value, int > = 0>
constexpr bool	operator!= (const variant< Types... > &v, const variant< Types... > &w)
template<typename... Types, std::enable_if_t< conjunction< totally_ordered< Types >... >::value, int > = 0>
constexpr bool	operator< (const variant< Types... > &v, const variant< Types... > &w)
template<typename... Types, std::enable_if_t< conjunction< totally_ordered< Types >... >::value, int > = 0>
constexpr bool	operator> (const variant< Types... > &v, const variant< Types... > &w)
template<typename... Types, std::enable_if_t< conjunction< totally_ordered< Types >... >::value, int > = 0>
constexpr bool	operator<= (const variant< Types... > &v, const variant< Types... > &w)
template<typename... Types, std::enable_if_t< conjunction< totally_ordered< Types >... >::value, int > = 0>
constexpr bool	operator>= (const variant< Types... > &v, const variant< Types... > &w)
template<typename... Types>
constexpr std::enable_if_t< conjunction< std::is_move_constructible< Types >..., is_swappable< Types >... >::value >	swap (variant< Types... > &lhs, variant< Types... > &rhs) noexcept(noexcept(lhs.swap(rhs)))
template<typename R , typename Visitor , typename... Variants, std::enable_if_t< conjunction< is_invocable< detail::as_variant_niebloid, Variants >... >::value, int > = 0>
constexpr R	visit (Visitor &&vis, Variants &&... vars)
template<typename Visitor , typename... Variants, std::enable_if_t< conjunction< is_invocable< detail::as_variant_niebloid, Variants >... >::value, int > = 0>
constexpr decltype(auto)	visit (Visitor &&vis, Variants &&... vars)
template<typename CharT , typename Traits >
constexpr bool	operator== (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
template<typename CharT , typename Traits >
constexpr bool	operator!= (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
template<typename CharT , typename Traits >
constexpr bool	operator< (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
template<typename CharT , typename Traits >
constexpr bool	operator<= (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
template<typename CharT , typename Traits >
constexpr bool	operator> (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
template<typename CharT , typename Traits >
constexpr bool	operator>= (basic_string_view< CharT, Traits > lhs, basic_string_view< CharT, Traits > rhs) noexcept
template<typename CharT , typename Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, basic_string_view< CharT, Traits > sv)
constexpr string_view	operator""_sv (const char *str, std::size_t len) noexcept
constexpr u16string_view	operator""_sv (const char16_t *str, std::size_t len) noexcept
constexpr u32string_view	operator""_sv (const char32_t *str, std::size_t len) noexcept
constexpr wstring_view	operator""_sv (const wchar_t *str, std::size_t len) noexcept

Variables
constexpr VCCC_INLINE_OR_STATIC Logger	Log
	Global vccc::Logger instance for syntax sugar. More...
constexpr VCCC_INLINE_OR_STATIC unexpect_t	unexpect {}
constexpr VCCC_INLINE_OR_STATIC default_sentinel_t	default_sentinel {}
constexpr VCCC_INLINE_OR_STATIC unreachable_sentinel_t	unreachable_sentinel {}
constexpr nullopt_t	nullopt {0}
constexpr VCCC_INLINE_OR_STATIC from_range_t	from_range {}
constexpr VCCC_INLINE_OR_STATIC std::size_t	dynamic_extent = (std::numeric_limits<std::size_t>::max)()
constexpr VCCC_INLINE_OR_STATIC compressed_pair_empty_t	compressed_pair_empty
constexpr VCCC_INLINE_OR_STATIC in_place_t	in_place {}
template<typename T >
constexpr VCCC_INLINE_OR_STATIC in_place_type_t< T >	in_place_type {}
template<std::size_t I>
constexpr VCCC_INLINE_OR_STATIC in_place_index_t< I >	in_place_index {}
constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid< 0 >	key
constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid< 0 >	first
constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid< 1 >	value
constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid< 1 >	second
template<std::size_t I>
constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid< I >	element
template<typename T >
constexpr VCCC_INLINE_OR_STATIC nontype_t< T >	nontype {}
constexpr VCCC_INLINE_OR_STATIC std::size_t	variant_npos = -1
template<typename T >
constexpr VCCC_INLINE_OR_STATIC std::size_t	variant_size_v = variant_size<T>::value

Enumeration Type Documentation

group_category

enum group_category

Enumerator
ungrouped_front
grouped
ungrouped_back

slot_position

enum slot_position

Enumerator
at_back
at_front

Function Documentation

add() [1/3]

cv::Matx<T, m, n> vccc::add	(	const cv::Matx< T, m, n > &	matx,
		N	n_
	)

add

add() [2/3]

cv::Point3_<T> vccc::add ( const cv::Point3_< T > &  point3, N  n  )

inline

add() [3/3]

cv::Point_<T> vccc::add	(	const cv::Point_< T > &	point2,
		N	n
	)

add

addressof()

constexpr std::enable_if_t<std::is_object<T>::value == false, T*> vccc::addressof ( T &  t )

constexprnoexcept

cast()

constexpr decltype(auto) vccc::cast ( FromType &&  from )

inlineconstexpr

destroy_at()

VCCC_CONSTEXPR_AFTER_CXX20 void destroy_at

(

T *

p

)

operator!=() [1/3]

bool vccc::operator!=	(	const group_key< Group > &	lhs,
		const group_key< Group > &	rhs
	)

operator!=() [2/3]

constexpr bool vccc::operator!= ( const MatrixBase< E1 > &  lhs, const MatrixBase< E2 > &  rhs  )

constexpr

operator!=() [3/3]

constexpr bool vccc::operator!= ( monostate  , monostate    )

constexprnoexcept

operator<()

constexpr bool vccc::operator< ( monostate  , monostate    )

constexprnoexcept

operator<=()

constexpr bool vccc::operator<= ( monostate  , monostate    )

constexprnoexcept

operator==() [1/3]

bool vccc::operator==	(	const group_key< Group > &	lhs,
		const group_key< Group > &	rhs
	)

operator==() [2/3]

constexpr bool vccc::operator== ( const MatrixBase< E1 > &  lhs, const MatrixBase< E2 > &  rhs  )

constexpr

operator==() [3/3]

constexpr bool vccc::operator== ( monostate  , monostate    )

constexprnoexcept

operator>()

constexpr bool vccc::operator> ( monostate  , monostate    )

constexprnoexcept

operator>=()

constexpr bool vccc::operator>= ( monostate  , monostate    )

constexprnoexcept

resize() [1/2]

auto resize ( const cv::Point3_< T > &  from )

inline

resize() [2/2]

auto resize

(

const cv::Point_< T > &

from

)

resize

size() [1/2]

constexpr auto vccc::size ( const C &  c ) -> decltype(c.size())

inlineconstexpr

size() [2/2]

constexpr std::size_t vccc::size ( const T(&)  array[N] )

inlineconstexprnoexcept

ssize() [1/2]

constexpr auto vccc::ssize ( const C &  c ) -> common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>>

inlineconstexpr

ssize() [2/2]

constexpr std::ptrdiff_t vccc::ssize ( const T(&)  array[N] )

inlineconstexprnoexcept

Variable Documentation

element

constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid<I> element

constexpr

first

constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid<0> first

constexpr

key

constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid<0> key

constexpr

second

constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid<1> second

constexpr

value

constexpr VCCC_INLINE_OR_STATIC detail::element_niebloid<1> value

constexpr