DimensionValidation.hpp

#pragma once
 
#include <cstddef>
#include <limits>
 
#include <stratax/core/Exceptions.hpp>
 
namespace stratax::core::validation {

inline std::size_t nonnegative_size(std::ptrdiff_t value, const char* message)
{
    if (value < 0)
    {
        throw Exceptions::DimensionError(message);
    }
 
    return static_cast<std::size_t>(value);
}

inline void require_rank(std::size_t actual, std::size_t expected, const char* message)
{
    if (actual != expected)
    {
        throw Exceptions::DimensionError(message);
    }
}

template<typename Ranked>
requires requires(const Ranked& object)
{
    object.rank();
}
const Ranked& require_rank(const Ranked& object, std::size_t expected, const char* message)
{
    require_rank(object.rank(), expected, message);
    return object;
}

inline std::size_t checked_multiply(
    std::size_t lhs,
    std::size_t rhs,
    const char* message)
{
    if (rhs != 0 && lhs > std::numeric_limits<std::size_t>::max() / rhs)
    {
        throw Exceptions::DimensionError(message);
    }
 
    return lhs * rhs;
}

inline std::size_t checked_add(
    std::size_t lhs,
    std::size_t rhs,
    const char* message)
{
    if (lhs > std::numeric_limits<std::size_t>::max() - rhs)
    {
        throw Exceptions::DimensionError(message);
    }
 
    return lhs + rhs;
}
 
}