Skip to content

File include/brisk/core/internal/Constants.hpp

constant typedef

template <typename T, T N>
constant = std::integral_constant<T, N>

A template alias for std::integral_constant.

This alias allows defining compile-time constants of any type.
Template param T The type of the constant.
Template param N The value of the constant.

constant = std::integral_constant<T, N>

A template alias for std::integral_constant.

This alias allows defining compile-time constants of any type.
Template param T The type of the constant.
Template param N The value of the constant.

constants typedef

template <typename T, T... N>
constants = std::integer_sequence<T, N...>

A template alias for std::integer_sequence.

This alias allows the creation of sequences of compile-time integers.
Template param T The type of the sequence elements.
Template param N The values of the sequence elements.

constants = std::integer_sequence<T, N...>

A template alias for std::integer_sequence.

This alias allows the creation of sequences of compile-time integers.
Template param T The type of the sequence elements.
Template param N The values of the sequence elements.

sequence typedef

template <typename T, size_t N>
sequence = std::make_integer_sequence<T, N>

A template alias for creating an integer sequence.

This alias uses std::make_integer_sequence to create a sequence of integers.
Template param T The type of the sequence elements.
Template param N The number of elements in the sequence.

sequence = std::make_integer_sequence<T, N>

A template alias for creating an integer sequence.

This alias uses std::make_integer_sequence to create a sequence of integers.
Template param T The type of the sequence elements.
Template param N The number of elements in the sequence.

operator+ function

template <typename T, T... x, T y>
constexpr auto operator+(constants<T, x...>,
                         constant<T, y>) noexcept
    -> constants<T, (x + y)...>

Adds a constant to a sequence of constants.

This operator overload allows the addition of a constant to a sequence of constants.
Param lhs A sequence of constants.
Param rhs A constant to add.
Returns A new sequence of constants resulting from the addition.

operator- function

template <typename T, T... x, T y>
constexpr auto operator-(constants<T, x...>,
                         constant<T, y>) noexcept
    -> constants<T, (x - y)...>

Subtracts a constant from a sequence of constants.

This operator overload allows the subtraction of a constant from a sequence of constants.
Param lhs A sequence of constants.
Param rhs A constant to subtract.
Returns A new sequence of constants resulting from the subtraction.

operator^ function

template <typename T, T... x, T y>
constexpr auto operator^(constants<T, x...>,
                         constant<T, y>) noexcept
    -> constants<T, (x ^ y)...>

Bitwise XORs a constant with a sequence of constants.

This operator overload allows bitwise XOR of a constant with a sequence of constants.
Param lhs A sequence of constants.
Param rhs A constant to XOR.
Returns A new sequence of constants resulting from the bitwise XOR.

operator% function

template <typename T, T... x, T y>
constexpr auto operator%(constants<T, x...>,
                         constant<T, y>) noexcept
    -> constants<T, (x % y)...>

Computes the modulus of a sequence of constants by a constant.

This operator overload allows computing the modulus of a sequence of constants by a constant.
Param lhs A sequence of constants.
Param rhs A constant to compute the modulus with.
Returns A new sequence of constants resulting from the modulus operation.

operator+ function

template <typename T, T x, T... y>
constexpr auto operator+(constant<T, x>,
                         constants<T, y...>) noexcept
    -> constants<T, (x + y)...>

Adds a constant to a sequence of constants (reverse order).

This operator overload allows the addition of a constant to a sequence of constants with the constant on the left-hand side.
Param lhs A constant to add.
Param rhs A sequence of constants.
Returns A new sequence of constants resulting from the addition.

operator- function

template <typename T, T x, T... y>
constexpr auto operator-(constant<T, x>,
                         constants<T, y...>) noexcept
    -> constants<T, (x - y)...>

Subtracts a sequence of constants from a constant (reverse order).

This operator overload allows the subtraction of a sequence of constants from a constant with the constant on the left-hand side.
Param lhs A constant to subtract from.
Param rhs A sequence of constants.
Returns A new sequence of constants resulting from the subtraction.

operator^ function

template <typename T, T x, T... y>
constexpr auto operator^(constant<T, x>,
                         constants<T, y...>) noexcept
    -> constants<T, (x ^ y)...>

Bitwise XORs a sequence of constants with a constant (reverse order).

This operator overload allows bitwise XOR of a sequence of constants with a constant with the constant on the left-hand side.
Param lhs A constant to XOR with.
Param rhs A sequence of constants.
Returns A new sequence of constants resulting from the bitwise XOR.

operator% function

template <typename T, T x, T... y>
constexpr auto operator%(constant<T, x>,
                         constants<T, y...>) noexcept
    -> constants<T, (x % y)...>

Computes the modulus of a constant by a sequence of constants (reverse order).

This operator overload allows computing the modulus of a constant by a sequence of constants with the constant on the left-hand side.
Param lhs A constant to compute the modulus of.
Param rhs A sequence of constants.
Returns A new sequence of constants resulting from the modulus operation.

findIntegralType function (Internal::findIntegralType)

template <std::integral auto Min, std::integral auto Max>
constexpr auto findIntegralType()

Finds the appropriate integral type based on the given range.

This helper function determines the smallest integral type that can represent the range [Min, Max].
Template param Min The minimum value of the range.
Template param Max The maximum value of the range.
Returns The integral type that can represent the specified range.

findIntegralType typedef

template <auto Min, auto Max>
findIntegralType =
    decltype(Internal::findIntegralType<Min, Max>())

Finds the integral type that can represent the given range.

This alias evaluates to the integral type that can safely represent the values in the range [Min, Max].
Template param Min The minimum value of the range.
Template param Max The maximum value of the range.

findIntegralType =
    decltype(Internal::findIntegralType<Min, Max>())

Finds the integral type that can represent the given range.

This alias evaluates to the integral type that can safely represent the values in the range [Min, Max].
Template param Min The minimum value of the range.
Template param Max The maximum value of the range.

Auto-generated from sources, Revision , https://github.com/brisklib/brisk/blob//include/brisk/