NumericValidation.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <stratax/core/dtypes/Concepts.hpp>
#include <stratax/exceptions/Exceptions.hpp>
 
#include <climits>
#include <cstdint>
#include <limits>
#include <type_traits>
 
namespace stratax::core::validation {
 
template<Numeric L, Numeric R>
void require_valid_division(const L& lhs, const R& rhs)
{
    if (rhs == R{})
    {
        throw Exceptions::ZeroDivisionError("Division by zero.");
    }
 
    if constexpr (Integral<L> && Integral<R>)
    {
        using expression_type = decltype(lhs / rhs);
        if constexpr (std::is_signed_v<expression_type>)
        {
            if (static_cast<expression_type>(lhs) ==
                std::numeric_limits<expression_type>::min() &&
                static_cast<expression_type>(rhs) == expression_type{-1})
            {
                throw Exceptions::OverflowError("Signed integer division overflow.");
            }
        }
    }
}
 
template<typename Value, Integral Count>
constexpr bool valid_shift_count(const Count& count) noexcept
{
    if constexpr (std::is_signed_v<std::remove_cvref_t<Count>>)
    {
        if (count < 0)
        {
            return false;
        }
    }
 
    using value_type = std::remove_cvref_t<Value>;
 
    return static_cast<std::uintmax_t>(count) <
        sizeof(value_type) * CHAR_BIT;
}
 
template<typename Value, Integral Count>
void require_valid_shift_count(const Count& count)
{
    if (!valid_shift_count<Value>(count))
    {
        throw Exceptions::ValueError("Invalid shift count.");
    }
}
 
} // namespace stratax::core::validation