IndexValidation.hpp

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

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

inline std::size_t normalize_index(std::ptrdiff_t value, std::size_t size, const char* message)
{
    if (size > static_cast<std::size_t>(std::numeric_limits<std::ptrdiff_t>::max()))
    {
        throw Exceptions::IndexError(message);
    }
 
    const std::ptrdiff_t limit = static_cast<std::ptrdiff_t>(size);
    std::ptrdiff_t normalized = value;
 
    if (normalized < 0)
    {
        normalized += limit;
    }
 
    if (normalized < 0 || normalized >= limit)
    {
        throw Exceptions::IndexError(message);
    }
 
    return static_cast<std::size_t>(normalized);
}

inline void require_index(std::size_t index, std::size_t size, const char* message)
{
    if (index >= size)
    {
        throw Exceptions::IndexError(message);
    }
}

inline void require_at_most(std::size_t value, std::size_t upper, const char* message)
{
    if (value > upper)
    {
        throw Exceptions::IndexError(message);
    }
}
 
}