binary_stream.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <bit>
#include <cstddef>
#include <cstdint>
#include <istream>
#include <limits>
#include <ostream>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
 
#include "orrery/core/types.hpp"
 
namespace orrery::sim {
 
static_assert(std::numeric_limits<core::Real>::is_iec559,
              "The binary formats store the bit pattern of a Real, which assumes IEEE 754");

using RealBits = std::conditional_t<core::kSinglePrecision, std::uint32_t, std::uint64_t>;
 
static_assert(sizeof(RealBits) == sizeof(core::Real));

inline constexpr std::size_t kRealBytes = sizeof(core::Real);

inline constexpr std::uint64_t kChecksumBasis = 0xcbf29ce484222325ULL;
inline constexpr std::uint64_t kChecksumPrime = 0x00000100000001b3ULL;

[[nodiscard]] constexpr std::uint64_t checksum_byte(std::uint64_t checksum,
                                                    std::byte value) noexcept {
    return (checksum ^ static_cast<std::uint64_t>(value)) * kChecksumPrime;
}

class BinaryWriter {
public:
    explicit BinaryWriter(std::ostream& out) noexcept : out_(&out) {}
 
    void write_u8(std::uint8_t value) { write_integer(value, 1); }
 
    void write_u32(std::uint32_t value) { write_integer(value, 4); }
 
    void write_u64(std::uint64_t value) { write_integer(value, 8); }

    void write_real(core::Real value) { write_integer(std::bit_cast<RealBits>(value), kRealBytes); }

    void write_reals(std::span<const core::Real> values) {
        for (const core::Real value : values) {
            write_real(value);
        }
    }

    void write_bytes(std::string_view text);

    void write_string(std::string_view text) {
        write_u32(static_cast<std::uint32_t>(text.size()));
        write_bytes(text);
    }

    [[nodiscard]] std::uint64_t checksum() const noexcept { return checksum_; }

    [[nodiscard]] bool ok() const noexcept { return out_->good(); }
 
private:
    void write_integer(std::uint64_t value, std::size_t width) {
        std::array<char, 8> bytes{};
        for (std::size_t index = 0; index < width; ++index) {
            const auto octet = static_cast<unsigned char>((value >> (8 * index)) & 0xffU);
            bytes[index] = static_cast<char>(octet);
            checksum_ = checksum_byte(checksum_, static_cast<std::byte>(octet));
        }
        out_->write(bytes.data(), static_cast<std::streamsize>(width));
    }
 
    std::ostream* out_;
    std::uint64_t checksum_{kChecksumBasis};
};

class BinaryReader {
public:
    explicit BinaryReader(std::istream& in) noexcept : in_(&in) {}
 
    [[nodiscard]] std::uint8_t read_u8() { return static_cast<std::uint8_t>(read_integer(1)); }
 
    [[nodiscard]] std::uint32_t read_u32() { return static_cast<std::uint32_t>(read_integer(4)); }
 
    [[nodiscard]] std::uint64_t read_u64() { return read_integer(8); }
 
    [[nodiscard]] core::Real read_real() {
        return std::bit_cast<core::Real>(static_cast<RealBits>(read_integer(kRealBytes)));
    }

    void read_reals(std::span<core::Real> values) {
        for (core::Real& value : values) {
            value = read_real();
        }
    }

    [[nodiscard]] std::string read_bytes(std::size_t length);

    [[nodiscard]] std::string read_string(std::size_t limit);

    [[nodiscard]] std::uint64_t checksum() const noexcept { return checksum_; }

    [[nodiscard]] bool ok() const noexcept { return in_->good(); }
 
private:
    [[nodiscard]] std::uint64_t read_integer(std::size_t width);
 
    std::istream* in_;
    std::uint64_t checksum_{kChecksumBasis};
};
 
} // namespace orrery::sim