endian.h

#ifndef OE_UTIL_ENDIAN_H
#define OE_UTIL_ENDIAN_H
 
#include <concepts>
#include <span>
#include <algorithm>
#include <cstddef>
 
#include <bit>
 
namespace oe::util::endian
{
    [[nodiscard]] constexpr bool isLittleEndianHost() noexcept
    {
        return std::endian::native == std::endian::little;
    }
 
    [[nodiscard]] constexpr bool isBigEndianHost() noexcept
    {
        return std::endian::native == std::endian::big;
    }
 
    template <typename T>
    concept NumericType = std::integral<T> || std::floating_point<T>;
 
    template <std::integral T>
    [[nodiscard]] constexpr T swapEndianess(const T& input) noexcept
    {
        #if defined(__cpp_lib_byteswap) && __cpp_lib_byteswap >= 202110L
            // Note: C++23 byteswap only do integral types
            return std::byteswap(input);
        #else
            T result;
 
            std::span input_bytes = {reinterpret_cast<const std::byte*>(&input), sizeof(T)};
            std::span result_bytes = {reinterpret_cast<std::byte*>(&result), sizeof(T)};
 
            std::ranges::reverse_copy(input_bytes, result_bytes.begin());
 
            return result;
        #endif
    }
 
    template <std::floating_point T>
    [[nodiscard]] constexpr T swapEndianess(const T& input) noexcept
    {
        T result;
 
        std::span input_bytes = {reinterpret_cast<const std::byte*>(&input), sizeof(T)};
        std::span result_bytes = {reinterpret_cast<std::byte*>(&result), sizeof(T)};
 
        std::ranges::reverse_copy(input_bytes, result_bytes.begin());
 
        return result;
    }
 
    template <NumericType T>
    [[nodiscard]] constexpr T convertLittleEndianToHost(const T& data) noexcept
    {
        if (isBigEndianHost())
        {
            return swapEndianess(data);
        }
 
        return data;
    }
 
    template <NumericType T>
    [[nodiscard]] constexpr T convertBigEndianToHost(const T& data) noexcept
    {
        if (isLittleEndianHost())
        {
            return swapEndianess(data);
        }
 
        return data;
    }
 
    template <NumericType T>
    [[nodiscard]] constexpr T convertHostToLittleEndian(const T& data) noexcept
    {
        if (isBigEndianHost())
        {
            return swapEndianess(data);
        }
 
        return data;
    }
 
    template <NumericType T>
    [[nodiscard]] constexpr T convertHostToBigEndian(const T& data) noexcept
    {
        if (isLittleEndianHost())
        {
            return swapEndianess(data);
        }
 
        return data;
    }
 
 
}
#endif