io.hpp

Go to the documentation of this file.

#ifndef RPNX_COMPRESSION_IMPLEMENTATION_IO_HPP
#define RPNX_COMPRESSION_IMPLEMENTATION_IO_HPP
 
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <optional>
#include <type_traits>
#include <utility>
 
/**
 * @file
 * @brief Shared iterator, byte-conversion, and checksum primitives.
 */
 
/** @brief Internal primitives shared by the format-specific codecs. */
namespace rpnx::compression::implementation
{
 
    /**
     * @brief Converts one supported iterator value to std::byte.
     * @tparam value_type std::byte or a one-byte integral type.
     * @param value Value to convert without changing its bit pattern.
     * @return The corresponding byte value.
     */
    template < typename value_type >
    [[nodiscard]] constexpr std::byte to_byte(value_type value) noexcept
    {
        using plain_type = std::remove_cv_t< value_type >;
        static_assert(std::is_same_v< plain_type, std::byte > || (std::is_integral_v< plain_type > && sizeof(plain_type) == 1U), "compression iterators must contain byte-sized values");
        if constexpr (std::is_same_v< plain_type, std::byte >)
        {
            return value;
        }
        else
        {
            return static_cast< std::byte >(static_cast< std::uint8_t >(value));
        }
    }
 
    /**
     * @brief Writes one byte through an output iterator and advances it.
     * @tparam output_iterator Iterator accepting std::byte or std::uint8_t.
     * @param output Iterator to update in place.
     * @param value Byte to write.
     */
    template < typename output_iterator >
    void write_byte(output_iterator& output, std::byte value)
    {
        if constexpr (requires { *output = value; })
        {
            *output = value;
        }
        else
        {
            *output = std::to_integer< std::uint8_t >(value);
        }
        ++output;
    }
 
    /**
     * @brief Single-pass byte reader over an input iterator and sentinel.
     * @tparam input_iterator Input iterator yielding std::byte or one-byte integral values.
     * @tparam sentinel Sentinel type for the input iterator.
     *
     * One byte of lookahead supports format-boundary checks without requiring a
     * forward iterator. The consumed count excludes a byte held by peek().
     */
    template < std::input_iterator input_iterator, std::sentinel_for< input_iterator > sentinel >
    class byte_reader
    {
      public:
        /**
         * @brief Constructs a reader over an iterator range.
         * @param first Iterator to the first byte.
         * @param last Sentinel past the final byte.
         */
        byte_reader(input_iterator first, sentinel last) : m_current(std::move(first)), m_last(std::move(last))
        {
        }
 
        /**
         * @brief Tests whether no unread byte remains.
         * @return true if neither lookahead nor the source contains another byte.
         */
        [[nodiscard]] bool empty() const
        {
            return !m_lookahead.has_value() && m_current == m_last;
        }
 
        /**
         * @brief Inspects the next byte without consuming it.
         * @param value Receives the next byte on success and is unchanged at end of input.
         * @return true if a byte was available; false at end of input.
         */
        [[nodiscard]] bool peek(std::byte& value)
        {
            if (!m_lookahead.has_value())
            {
                if (m_current == m_last)
                {
                    return false;
                }
                m_lookahead = to_byte(*m_current);
                ++m_current;
            }
            value = *m_lookahead;
            return true;
        }
 
        /**
         * @brief Reads one byte.
         * @param value Receives the byte on success and is unchanged at end of input.
         * @return true if a byte was consumed; false at end of input.
         */
        [[nodiscard]] bool read(std::byte& value)
        {
            if (m_lookahead.has_value())
            {
                value = *m_lookahead;
                m_lookahead.reset();
                ++m_consumed;
                return true;
            }
            if (m_current == m_last)
            {
                return false;
            }
            value = to_byte(*m_current);
            ++m_current;
            ++m_consumed;
            return true;
        }
 
        /**
         * @brief Reads one byte as an unsigned integer.
         * @param value Receives the byte on success and is unchanged at end of input.
         * @return true if a byte was consumed; false at end of input.
         */
        [[nodiscard]] bool read(std::uint8_t& value)
        {
            std::byte byte{};
            if (!read(byte))
            {
                return false;
            }
            value = std::to_integer< std::uint8_t >(byte);
            return true;
        }
 
        /**
         * @brief Returns the number of bytes consumed from the source.
         * @return Successful read count; a byte retained by peek() is not included.
         */
        [[nodiscard]] std::size_t consumed() const noexcept
        {
            return m_consumed;
        }
 
      private:
        input_iterator m_current;
        sentinel m_last;
        std::optional< std::byte > m_lookahead;
        std::size_t m_consumed = 0U;
    };
 
    /** @brief Incremental reflected IEEE CRC-32 accumulator. */
    class crc32_accumulator
    {
      public:
        /**
         * @brief Includes one byte in the checksum.
         * @param value Next byte in stream order.
         */
        void update(std::byte value) noexcept
        {
            m_checksum ^= std::to_integer< std::uint8_t >(value);
            for (std::uint8_t bit = 0U; bit < 8U; ++bit)
            {
                std::uint32_t const mask = 0U - (m_checksum & 1U);
                m_checksum = (m_checksum >> 1U) ^ (0xedb88320U & mask);
            }
        }
 
        /**
         * @brief Returns the checksum for all bytes supplied so far.
         * @return Finalized reflected IEEE CRC-32 value.
         */
        [[nodiscard]] std::uint32_t value() const noexcept
        {
            return ~m_checksum;
        }
 
      private:
        std::uint32_t m_checksum = 0xffffffffU;
    };
 
    /** @brief Incremental Adler-32 accumulator. */
    class adler32_accumulator
    {
      public:
        /**
         * @brief Includes one byte in the checksum.
         * @param value Next byte in stream order.
         */
        void update(std::byte value) noexcept
        {
            constexpr std::uint32_t modulus = 65521U;
            m_first = (m_first + std::to_integer< std::uint8_t >(value)) % modulus;
            m_second = (m_second + m_first) % modulus;
        }
 
        /**
         * @brief Returns the checksum for all bytes supplied so far.
         * @return Adler-32 value with the second sum in the high 16 bits.
         */
        [[nodiscard]] std::uint32_t value() const noexcept
        {
            return (m_second << 16U) | m_first;
        }
 
      private:
        std::uint32_t m_first = 1U;
        std::uint32_t m_second = 0U;
    };
 
} // namespace rpnx::compression::implementation
 
#endif