Plasma Engine  2.0
Loading...
Searching...
No Matches
StreamOperations_inl.h
1#pragma once
2
3#include <Foundation/Containers/Bitfield.h>
4#include <Foundation/Containers/HybridArray.h>
5#include <Foundation/Strings/String.h>
6#include <Foundation/Strings/StringBuilder.h>
7#include <Foundation/Types/Bitflags.h>
8#include <Foundation/Types/Enum.h>
9
10// Standard operators for overloads of common data types
11
13
14inline plStreamWriter& operator<<(plStreamWriter& inout_stream, bool bValue)
15{
16 plUInt8 uiValue = bValue ? 1 : 0;
17 inout_stream.WriteBytes(&uiValue, sizeof(plUInt8)).AssertSuccess();
18 return inout_stream;
19}
20
21inline plStreamReader& operator>>(plStreamReader& inout_stream, bool& out_bValue)
22{
23 plUInt8 uiValue = 0;
24 PL_VERIFY(inout_stream.ReadBytes(&uiValue, sizeof(plUInt8)) == sizeof(plUInt8), "End of stream reached.");
25 out_bValue = (uiValue != 0);
26 return inout_stream;
27}
28
30
31inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plUInt8 uiValue)
32{
33 inout_stream.WriteBytes(&uiValue, sizeof(plUInt8)).AssertSuccess();
34 return inout_stream;
35}
36
37inline plStreamReader& operator>>(plStreamReader& inout_stream, plUInt8& out_uiValue)
38{
39 PL_VERIFY(inout_stream.ReadBytes(&out_uiValue, sizeof(plUInt8)) == sizeof(plUInt8), "End of stream reached.");
40 return inout_stream;
41}
42
43inline plResult SerializeArray(plStreamWriter& inout_stream, const plUInt8* pArray, plUInt64 uiCount)
44{
45 return inout_stream.WriteBytes(pArray, sizeof(plUInt8) * uiCount);
46}
47
48inline plResult DeserializeArray(plStreamReader& inout_stream, plUInt8* pArray, plUInt64 uiCount)
49{
50 const plUInt64 uiNumBytes = sizeof(plUInt8) * uiCount;
51 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
52 return PL_SUCCESS;
53
54 return PL_FAILURE;
55}
56
57
58inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plUInt16 uiValue)
59{
60 inout_stream.WriteWordValue(&uiValue).AssertSuccess();
61 return inout_stream;
62}
63
64inline plStreamReader& operator>>(plStreamReader& inout_stream, plUInt16& ref_uiValue)
65{
66 inout_stream.ReadWordValue(&ref_uiValue).AssertSuccess();
67 return inout_stream;
68}
69
70inline plResult SerializeArray(plStreamWriter& inout_stream, const plUInt16* pArray, plUInt64 uiCount)
71{
72 return inout_stream.WriteBytes(pArray, sizeof(plUInt16) * uiCount);
73}
74
75inline plResult DeserializeArray(plStreamReader& inout_stream, plUInt16* pArray, plUInt64 uiCount)
76{
77 const plUInt64 uiNumBytes = sizeof(plUInt16) * uiCount;
78 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
79 return PL_SUCCESS;
80
81 return PL_FAILURE;
82}
83
84
85inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plUInt32 uiValue)
86{
87 inout_stream.WriteDWordValue(&uiValue).AssertSuccess();
88 return inout_stream;
89}
90
91inline plStreamReader& operator>>(plStreamReader& inout_stream, plUInt32& ref_uiValue)
92{
93 inout_stream.ReadDWordValue(&ref_uiValue).AssertSuccess();
94 return inout_stream;
95}
96
97inline plResult SerializeArray(plStreamWriter& inout_stream, const plUInt32* pArray, plUInt64 uiCount)
98{
99 return inout_stream.WriteBytes(pArray, sizeof(plUInt32) * uiCount);
100}
101
102inline plResult DeserializeArray(plStreamReader& inout_stream, plUInt32* pArray, plUInt64 uiCount)
103{
104 const plUInt64 uiNumBytes = sizeof(plUInt32) * uiCount;
105 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
106 return PL_SUCCESS;
107
108 return PL_FAILURE;
109}
110
111
112inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plUInt64 uiValue)
113{
114 inout_stream.WriteQWordValue(&uiValue).AssertSuccess();
115 return inout_stream;
116}
117
118inline plStreamReader& operator>>(plStreamReader& inout_stream, plUInt64& ref_uiValue)
119{
120 inout_stream.ReadQWordValue(&ref_uiValue).AssertSuccess();
121 return inout_stream;
122}
123
124inline plResult SerializeArray(plStreamWriter& inout_stream, const plUInt64* pArray, plUInt64 uiCount)
125{
126 return inout_stream.WriteBytes(pArray, sizeof(plUInt64) * uiCount);
127}
128
129inline plResult DeserializeArray(plStreamReader& inout_stream, plUInt64* pArray, plUInt64 uiCount)
130{
131 const plUInt64 uiNumBytes = sizeof(plUInt64) * uiCount;
132 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
133 return PL_SUCCESS;
134
135 return PL_FAILURE;
136}
137
139
140inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plInt8 iValue)
141{
142 inout_stream.WriteBytes(reinterpret_cast<const plUInt8*>(&iValue), sizeof(plInt8)).AssertSuccess();
143 return inout_stream;
144}
145
146inline plStreamReader& operator>>(plStreamReader& inout_stream, plInt8& ref_iValue)
147{
148 PL_VERIFY(inout_stream.ReadBytes(reinterpret_cast<plUInt8*>(&ref_iValue), sizeof(plInt8)) == sizeof(plInt8), "End of stream reached.");
149 return inout_stream;
150}
151
152inline plResult SerializeArray(plStreamWriter& inout_stream, const plInt8* pArray, plUInt64 uiCount)
153{
154 return inout_stream.WriteBytes(pArray, sizeof(plInt8) * uiCount);
155}
156
157inline plResult DeserializeArray(plStreamReader& inout_stream, plInt8* pArray, plUInt64 uiCount)
158{
159 const plUInt64 uiNumBytes = sizeof(plInt8) * uiCount;
160 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
161 return PL_SUCCESS;
162
163 return PL_FAILURE;
164}
165
166
167inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plInt16 iValue)
168{
169 inout_stream.WriteWordValue(&iValue).AssertSuccess();
170 return inout_stream;
171}
172
173inline plStreamReader& operator>>(plStreamReader& inout_stream, plInt16& ref_iValue)
174{
175 inout_stream.ReadWordValue(&ref_iValue).AssertSuccess();
176 return inout_stream;
177}
178
179inline plResult SerializeArray(plStreamWriter& inout_stream, const plInt16* pArray, plUInt64 uiCount)
180{
181 return inout_stream.WriteBytes(pArray, sizeof(plInt16) * uiCount);
182}
183
184inline plResult DeserializeArray(plStreamReader& inout_stream, plInt16* pArray, plUInt64 uiCount)
185{
186 const plUInt64 uiNumBytes = sizeof(plInt16) * uiCount;
187 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
188 return PL_SUCCESS;
189
190 return PL_FAILURE;
191}
192
193
194inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plInt32 iValue)
195{
196 inout_stream.WriteDWordValue(&iValue).AssertSuccess();
197 return inout_stream;
198}
199
200inline plStreamReader& operator>>(plStreamReader& inout_stream, plInt32& ref_iValue)
201{
202 inout_stream.ReadDWordValue(&ref_iValue).AssertSuccess();
203 return inout_stream;
204}
205
206inline plResult SerializeArray(plStreamWriter& inout_stream, const plInt32* pArray, plUInt64 uiCount)
207{
208 return inout_stream.WriteBytes(pArray, sizeof(plInt32) * uiCount);
209}
210
211inline plResult DeserializeArray(plStreamReader& inout_stream, plInt32* pArray, plUInt64 uiCount)
212{
213 const plUInt64 uiNumBytes = sizeof(plInt32) * uiCount;
214 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
215 return PL_SUCCESS;
216
217 return PL_FAILURE;
218}
219
220
221inline plStreamWriter& operator<<(plStreamWriter& inout_stream, plInt64 iValue)
222{
223 inout_stream.WriteQWordValue(&iValue).AssertSuccess();
224 return inout_stream;
225}
226
227inline plStreamReader& operator>>(plStreamReader& inout_stream, plInt64& ref_iValue)
228{
229 inout_stream.ReadQWordValue(&ref_iValue).AssertSuccess();
230 return inout_stream;
231}
232
233inline plResult SerializeArray(plStreamWriter& inout_stream, const plInt64* pArray, plUInt64 uiCount)
234{
235 return inout_stream.WriteBytes(pArray, sizeof(plInt64) * uiCount);
236}
237
238inline plResult DeserializeArray(plStreamReader& inout_stream, plInt64* pArray, plUInt64 uiCount)
239{
240 const plUInt64 uiNumBytes = sizeof(plInt64) * uiCount;
241 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
242 return PL_SUCCESS;
243
244 return PL_FAILURE;
245}
246
247
249
250inline plStreamWriter& operator<<(plStreamWriter& inout_stream, float fValue)
251{
252 inout_stream.WriteDWordValue(&fValue).AssertSuccess();
253 return inout_stream;
254}
255
256inline plStreamReader& operator>>(plStreamReader& inout_stream, float& ref_fValue)
257{
258 inout_stream.ReadDWordValue(&ref_fValue).AssertSuccess();
259 return inout_stream;
260}
261
262inline plResult SerializeArray(plStreamWriter& inout_stream, const float* pArray, plUInt64 uiCount)
263{
264 return inout_stream.WriteBytes(pArray, sizeof(float) * uiCount);
265}
266
267inline plResult DeserializeArray(plStreamReader& inout_stream, float* pArray, plUInt64 uiCount)
268{
269 const plUInt64 uiNumBytes = sizeof(float) * uiCount;
270 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
271 return PL_SUCCESS;
272
273 return PL_FAILURE;
274}
275
276
277inline plStreamWriter& operator<<(plStreamWriter& inout_stream, double fValue)
278{
279 inout_stream.WriteQWordValue(&fValue).AssertSuccess();
280 return inout_stream;
281}
282
283inline plStreamReader& operator>>(plStreamReader& inout_stream, double& ref_fValue)
284{
285 inout_stream.ReadQWordValue(&ref_fValue).AssertSuccess();
286 return inout_stream;
287}
288
289inline plResult SerializeArray(plStreamWriter& inout_stream, const double* pArray, plUInt64 uiCount)
290{
291 return inout_stream.WriteBytes(pArray, sizeof(double) * uiCount);
292}
293
294inline plResult DeserializeArray(plStreamReader& inout_stream, double* pArray, plUInt64 uiCount)
295{
296 const plUInt64 uiNumBytes = sizeof(double) * uiCount;
297 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
298 return PL_SUCCESS;
299
300 return PL_FAILURE;
301}
302
303
304// C-style strings
305// No read equivalent for C-style strings (but can be read as plString & plStringBuilder instances)
306
307PL_FOUNDATION_DLL plStreamWriter& operator<<(plStreamWriter& inout_stream, const char* szValue);
308PL_FOUNDATION_DLL plStreamWriter& operator<<(plStreamWriter& inout_stream, plStringView sValue);
309
310// plHybridString
311
312template <plUInt16 Size, typename AllocatorWrapper>
313inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plHybridString<Size, AllocatorWrapper>& sValue)
314{
315 inout_stream.WriteString(sValue.GetView()).AssertSuccess();
316 return inout_stream;
317}
318
319template <plUInt16 Size, typename AllocatorWrapper>
320inline plStreamReader& operator>>(plStreamReader& inout_stream, plHybridString<Size, AllocatorWrapper>& out_sValue)
321{
322 plStringBuilder builder;
323 inout_stream.ReadString(builder).AssertSuccess();
324 out_sValue = std::move(builder);
325
326 return inout_stream;
327}
328
329// plStringBuilder
330
331PL_FOUNDATION_DLL plStreamWriter& operator<<(plStreamWriter& inout_stream, const plStringBuilder& sValue);
332PL_FOUNDATION_DLL plStreamReader& operator>>(plStreamReader& inout_stream, plStringBuilder& out_sValue);
333
334// plEnum
335
336template <typename T>
337inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plEnum<T>& value)
338{
339 inout_stream << value.GetValue();
340
341 return inout_stream;
342}
343
344template <typename T>
345inline plStreamReader& operator>>(plStreamReader& inout_stream, plEnum<T>& value)
346{
347 typename T::StorageType storedValue = T::Default;
348 inout_stream >> storedValue;
349 value.SetValue(storedValue);
350
351 return inout_stream;
352}
353
354// plBitflags
355
356template <typename T>
357inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plBitflags<T>& value)
358{
359 inout_stream << value.GetValue();
360
361 return inout_stream;
362}
363
364template <typename T>
365inline plStreamReader& operator>>(plStreamReader& inout_stream, plBitflags<T>& value)
366{
367 typename T::StorageType storedValue = T::Default;
368 inout_stream >> storedValue;
369 value.SetValue(storedValue);
370
371 return inout_stream;
372}
plStreamReader
Interface for binary in (read) streams.
Definition Stream.h:22
plStreamReader::ReadWordValue
plResult ReadWordValue(T *pWordValue)
Helper method to read a word value correctly (copes with potentially different endianess)
Definition Stream_inl.h:85
plStreamReader::ReadQWordValue
plResult ReadQWordValue(T *pQWordValue)
Helper method to read a qword value correctly (copes with potentially different endianess)
Definition Stream_inl.h:107
plStreamReader::ReadDWordValue
plResult ReadDWordValue(T *pDWordValue)
Helper method to read a dword value correctly (copes with potentially different endianess)
Definition Stream_inl.h:96
plStreamReader::ReadString
plResult ReadString(plStringBuilder &ref_sBuilder)
Reads a string into an plStringBuilder.
Definition Stream.cpp:10
plStreamReader::ReadBytes
virtual plUInt64 ReadBytes(void *pReadBuffer, plUInt64 uiBytesToRead)=0
Reads a raw number of bytes into the read buffer, this is the only method which has to be implemented...
plStreamWriter
Interface for binary out (write) streams.
Definition Stream.h:107
plStreamWriter::WriteBytes
virtual plResult WriteBytes(const void *pWriteBuffer, plUInt64 uiBytesToWrite)=0
Writes a raw number of bytes from the buffer, this is the only method which has to be implemented to ...
plStreamWriter::WriteDWordValue
plResult WriteDWordValue(const T *pDWordValue)
Helper method to write a dword value correctly (copes with potentially different endianess)
Definition Stream_inl.h:126
plStreamWriter::WriteWordValue
plResult WriteWordValue(const T *pWordValue)
Helper method to write a word value correctly (copes with potentially different endianess)
Definition Stream_inl.h:118
plStreamWriter::WriteString
plResult WriteString(const plStringView sStringView)
Writes a string.
Definition Stream.cpp:51
plStreamWriter::WriteQWordValue
plResult WriteQWordValue(const T *pQWordValue)
Helper method to write a qword value correctly (copes with potentially different endianess)
Definition Stream_inl.h:134
plStringBuilder
plStringBuilder is a class that is meant for creating and modifying strings.
Definition StringBuilder.h:35
plStringView
plStringView represent a read-only sub-string of a larger string, as it can store a dedicated string ...
Definition StringView.h:34
plBitflags
The plBitflags class allows you to work with type-safe bitflags.
Definition Bitflags.h:82
plBitflags::SetValue
PL_ALWAYS_INLINE void SetValue(StorageType value)
Overwrites the flags with a new value.
Definition Bitflags.h:205
plBitflags::GetValue
PL_ALWAYS_INLINE StorageType GetValue() const
Returns the stored value as the underlying integer type.
Definition Bitflags.h:199
plEnum
A custom enum implementation that allows to define the underlying storage type to control its memory ...
Definition Enum.h:37
plEnum::GetValue
PL_ALWAYS_INLINE StorageType GetValue() const
Returns the enum value as an integer.
Definition Enum.h:98
plEnum::SetValue
PL_ALWAYS_INLINE void SetValue(StorageType value)
Sets the enum value through an integer.
Definition Enum.h:104
plHybridString
Definition String.h:146
plResult
Default enum for returning failure or success, instead of using a bool.
Definition Types.h:54
plResult::AssertSuccess
void AssertSuccess(const char *szMsg=nullptr, const char *szDetails=nullptr) const
Asserts that the function succeeded. In case of failure, the program will terminate.
Definition Status.cpp:7
plStringBase::GetView
plStringView GetView() const
Returns a string view to this string's data.
Definition StringBase_inl.h:329