Stream.hh

#pragma once
 
#include <Common.hh>
 
namespace Kinoko::EGG {

class Stream {
public:
    Stream();
    virtual ~Stream();
 
    virtual void read(void *output, u32 size) = 0;
    virtual void write(void *input, u32 size) = 0;
    virtual bool eof() const = 0;
    virtual bool safe(u32 size) const = 0;
    virtual bool bad() const = 0;
 
    void skip(u32 count);
    void jump(u32 index);
 
    void setEndian(std::endian endian) {
        m_endian = endian;
    }
 
    [[nodiscard]] u32 index() const {
        return m_index;
    }
 
    [[nodiscard]] u8 read_u8();
    [[nodiscard]] u16 read_u16();
    [[nodiscard]] u32 read_u32();
    [[nodiscard]] u64 read_u64();
    [[nodiscard]] s8 read_s8();
    [[nodiscard]] s16 read_s16();
    [[nodiscard]] s32 read_s32();
    [[nodiscard]] s64 read_s64();
    [[nodiscard]] f32 read_f32();
    [[nodiscard]] f64 read_f64();
 
    void write_u8(u8 val);
    void write_u16(u16 val);
    void write_u32(u32 val);
    void write_u64(u64 val);
    void write_s8(s8 val);
    void write_s16(s16 val);
    void write_s32(s32 val);
    void write_s64(s64 val);
    void write_f32(f32 val);
    void write_f64(f64 val);
 
protected:
    std::endian m_endian;
    u32 m_index;
 
private:
    template <ParseableType T>
    [[nodiscard]] T read() {
        ASSERT(safe(sizeof(T)));
        T val;
        read(&val, sizeof(val));
        m_index += sizeof(val);
 
        return parse<T>(val, m_endian);
    }
 
    template <ParseableType T>
    void write(T val) {
        ASSERT(safe(sizeof(T)));
        T parsedVal = parse<T>(val, m_endian);
        write(&parsedVal, sizeof(parsedVal));
        m_index += sizeof(parsedVal);
    }
};

class RamStream : public Stream {
public:
    RamStream();
    RamStream(const void *buffer, u32 size);
    ~RamStream() override = default;
 
    void read(void *output, u32 size) override;
    void write(void *input, u32 size) override;
 
    [[nodiscard]] bool eof() const override {
        return m_index == m_size;
    }
 
    [[nodiscard]] bool safe(u32 size) const override {
        return m_index + size <= m_size;
    }
 
    [[nodiscard]] bool bad() const override {
        return m_index > m_size;
    }
 
    [[nodiscard]] const char *read_string();
    [[nodiscard]] RamStream split(u32 size);
    void setBufferAndSize(void *buffer, u32 size);
 
    [[nodiscard]] u8 *data() {
        return m_buffer;
    }
 
    [[nodiscard]] u8 *dataAtIndex() {
        return m_buffer + m_index;
    }
 
private:
    u8 *m_buffer;
    u32 m_size;
};
 
} // namespace Kinoko::EGG