crunch_integrity.hpp

#pragma once
 
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <numeric>
#include <span>
#include <type_traits>
 
namespace Crunch {
 
template <typename Policy>
concept IntegrityPolicy = requires(std::span<const std::byte> data) {
    {
        std::bool_constant<(Policy::size(), true)>()
    } -> std::same_as<std::true_type>;
    { Policy::size() } -> std::same_as<std::size_t>;
    {
        std::bool_constant<(Policy::calculate(std::span<const std::byte>{}),
                            true)>()
    } -> std::same_as<std::true_type>;
 
    {
        Policy::calculate(data)
    } -> std::same_as<std::array<std::byte, Policy::size()>>;
};
 
namespace integrity {
 
struct None {
    [[nodiscard]] static constexpr std::size_t size() noexcept { return 0; }
    [[nodiscard]] static constexpr auto calculate(
        std::span<const std::byte>) noexcept -> std::array<std::byte, 0> {
        return {};
    }
};
 
struct CRC16 {
    [[nodiscard]] static constexpr std::size_t size() noexcept { return 2; }
 
    [[nodiscard]] static constexpr auto calculate(
        std::span<const std::byte> data) noexcept -> std::array<std::byte, 2> {
        uint16_t crc = 0xFFFF;
        for (std::byte b : data) {
            crc ^= (static_cast<uint8_t>(b) << 8);
            for (int i = 0; i < 8; i++) {
                if (crc & 0x8000) {
                    crc = static_cast<uint16_t>((crc << 1) ^ 0x1021);
                } else {
                    crc = static_cast<uint16_t>(crc << 1);
                }
            }
        }
        return {static_cast<std::byte>((crc >> 8) & 0xFF),
                static_cast<std::byte>(crc & 0xFF)};
    }
};
 
struct Parity {
    [[nodiscard]] static constexpr std::size_t size() noexcept { return 1; }
 
    [[nodiscard]] static constexpr auto calculate(
        std::span<const std::byte> data) noexcept -> std::array<std::byte, 1> {
        return {std::accumulate(data.begin(), data.end(), std::byte{0},
                                std::bit_xor<std::byte>{})};
    }
};
 
}  // namespace integrity
 
}  // namespace Crunch