Stream.cc

#include "Stream.hh"
 
#include <cstring>
 
namespace Kinoko::EGG {
 
Stream::Stream() : m_endian(std::endian::big), m_index(0) {}
 
Stream::~Stream() = default;
 
void Stream::skip(u32 count) {
    m_index += count;
    ASSERT(!bad());
}
 
void Stream::jump(u32 index) {
    m_index = index;
    ASSERT(!bad());
}
 
u8 Stream::read_u8() {
    return read<u8>();
}
 
u16 Stream::read_u16() {
    return read<u16>();
}
 
u32 Stream::read_u32() {
    return read<u32>();
}
 
u64 Stream::read_u64() {
    return read<u64>();
}
 
s8 Stream::read_s8() {
    return read<s8>();
}
 
s16 Stream::read_s16() {
    return read<s16>();
}
 
s32 Stream::read_s32() {
    return read<s32>();
}
 
s64 Stream::read_s64() {
    return read<s64>();
}
 
f32 Stream::read_f32() {
    return read<f32>();
}
 
f64 Stream::read_f64() {
    return read<f64>();
}
 
void Stream::write_u8(u8 val) {
    return write(val);
}
 
void Stream::write_u16(u16 val) {
    return write(val);
}
 
void Stream::write_u32(u32 val) {
    return write(val);
}
 
void Stream::write_u64(u64 val) {
    return write(val);
}
 
void Stream::write_s8(s8 val) {
    return write(val);
}
 
void Stream::write_s16(s16 val) {
    return write(val);
}
 
void Stream::write_s32(s32 val) {
    return write(val);
}
 
void Stream::write_s64(s64 val) {
    return write(val);
}
 
void Stream::write_f32(f32 val) {
    return write(val);
}
 
void Stream::write_f64(f64 val) {
    return write(val);
}
 
RamStream::RamStream() : m_buffer(nullptr), m_size(0) {}
 
RamStream::RamStream(const void *buffer, u32 size) {
    setBufferAndSize(const_cast<void *>(buffer), size);
}
 
void RamStream::read(void *output, u32 size) {
    u8 *buffer = reinterpret_cast<u8 *>(output);
    for (size_t i = 0; i < size; ++i) {
        buffer[i] = m_buffer[m_index + i];
    }
}
 
void RamStream::write(void *input, u32 size) {
    u8 *buffer = reinterpret_cast<u8 *>(input);
    for (size_t i = 0; i < size; ++i) {
        m_buffer[m_index + i] = buffer[i];
    }
}
 
// Expects a null-terminated char array, and moves the index past the null terminator
const char *RamStream::read_string() {
    const char *ret = reinterpret_cast<char *>(m_buffer + m_index);
    m_index += strlen(ret) + 1;
    ASSERT(!bad());
    return ret;
}
 
void RamStream::setBufferAndSize(void *buffer, u32 size) {
    m_buffer = reinterpret_cast<u8 *>(buffer);
    m_size = size;
}

RamStream RamStream::split(u32 size) {
    RamStream stream = RamStream(m_buffer + m_index, size);
    m_index += size;
    ASSERT(!bad());
 
    return stream;
}
 
} // namespace Kinoko::EGG