A reimplementation of Mario Kart Wii's physics engine in C++
Loading...
Searching...
No Matches
Stream.hh
1#pragma once
2
3#include <Common.hh>
4
5#include <string>
6
7namespace EGG {
8
10class Stream {
11public:
12 Stream();
13 virtual ~Stream();
14
15 virtual void read(void *output, u32 size) = 0;
16 virtual void write(void *input, u32 size) = 0;
17 virtual bool eof() const = 0;
18 virtual bool safe(u32 size) const = 0;
19 virtual bool bad() const = 0;
20
21 void skip(u32 count);
22 void jump(u32 index);
23
24 void setEndian(std::endian endian) {
25 m_endian = endian;
26 }
27
28 [[nodiscard]] u32 index() const {
29 return m_index;
30 }
31
32 [[nodiscard]] u8 read_u8();
33 [[nodiscard]] u16 read_u16();
34 [[nodiscard]] u32 read_u32();
35 [[nodiscard]] u64 read_u64();
36 [[nodiscard]] s8 read_s8();
37 [[nodiscard]] s16 read_s16();
38 [[nodiscard]] s32 read_s32();
39 [[nodiscard]] s64 read_s64();
40 [[nodiscard]] f32 read_f32();
41 [[nodiscard]] f64 read_f64();
42
43 void write_u8(u8 val);
44 void write_u16(u16 val);
45 void write_u32(u32 val);
46 void write_u64(u64 val);
47 void write_s8(s8 val);
48 void write_s16(s16 val);
49 void write_s32(s32 val);
50 void write_s64(s64 val);
51 void write_f32(f32 val);
52 void write_f64(f64 val);
53
54protected:
55 std::endian m_endian;
56 u32 m_index;
57
58private:
59 template <ParseableType T>
60 [[nodiscard]] T read() {
61 ASSERT(safe(sizeof(T)));
62 T val;
63 read(&val, sizeof(val));
64 m_index += sizeof(val);
65
66 return parse<T>(val, m_endian);
67 }
68
69 template <ParseableType T>
70 void write(T val) {
71 ASSERT(safe(sizeof(T)));
72 T parsedVal = parse<T>(val, m_endian);
73 write(&parsedVal, sizeof(parsedVal));
74 m_index += sizeof(parsedVal);
75 }
76};
77
83class RamStream : public Stream {
84public:
85 RamStream();
86 RamStream(const void *buffer, u32 size);
87 ~RamStream() override = default;
88
89 void read(void *output, u32 size) override;
90 void write(void *input, u32 size) override;
91
92 [[nodiscard]] bool eof() const override {
93 return m_index == m_size;
94 }
95
96 [[nodiscard]] bool safe(u32 size) const override {
97 return m_index + size <= m_size;
98 }
99
100 [[nodiscard]] bool bad() const override {
101 return m_index > m_size;
102 }
103
104 [[nodiscard]] std::string read_string();
105 [[nodiscard]] RamStream split(u32 size);
106 void setBufferAndSize(void *buffer, u32 size);
107
108 [[nodiscard]] u8 *data() {
109 return m_buffer;
110 }
111
112 [[nodiscard]] u8 *dataAtIndex() {
113 return m_buffer + m_index;
114 }
115
116private:
117 u8 *m_buffer;
118 u32 m_size;
119};
120
121} // namespace EGG
This header houses common data types such as our integral types and enums.
A stream of data stored in memory.
Definition Stream.hh:83
RamStream split(u32 size)
Splits the current stream into two.
Definition Stream.cc:136
A stream of data, abstracted to allow for continuous seeking.
Definition Stream.hh:10
EGG core library.
Definition Archive.cc:6