EHS
Loading...
Searching...
No Matches
Serializer.h
Go to the documentation of this file.
1#pragma once
2
3#include "Types.h"
4#include "BaseObj.h"
5#include "Util.h"
6#include "Array.h"
7#include "Vector.h"
8#include "Str.h"
9#include "Version.h"
10#include "Vec2.h"
11#include "Vec3.h"
12#include "Color3.h"
13#include "Vec4.h"
14#include "Rect.h"
15#include "Color4.h"
16#include "Quat.h"
17#include "Mat2.h"
18#include "Mat3.h"
19#include "Mat4.h"
20
21namespace ehs
22{
23 template<typename N = UInt_64>
25 {
26 private:
27 Endianness endianness;
28 Byte* data;
29 N size;
30 N offset;
31
32 public:
34 {
35 delete[] data;
36 }
37
39 : endianness(Endianness::BE), data(nullptr), size(0), offset(0)
40 {
41 }
42
43 Serializer(const Endianness endianness)
44 : endianness(endianness), data(nullptr), size(0), offset(0)
45 {
46 }
47
48 Serializer(const Endianness endianness, const N size)
49 : endianness(endianness), data(new Byte[size]), size(size), offset(0)
50 {
51 }
52
53 Serializer(const Endianness endianness, const Byte* const data, const N size, const N offset = 0)
54 : endianness(endianness), data(new Byte[size]), size(size), offset(offset)
55 {
56 for (N i = 0; i < size; ++i)
57 this->data[i] = data[i];
58 }
59
60 Serializer(Serializer&& serializer) noexcept
61 : endianness(serializer.endianness), data(serializer.data),
62 size(serializer.size), offset(serializer.offset)
63 {
64 serializer.data = nullptr;
65 serializer.size = 0;
66 serializer.offset = 0;
67 }
68
69 Serializer(const Serializer& serializer)
70 : endianness(serializer.endianness), data(new Byte[serializer.size]),
71 size(serializer.size), offset(serializer.offset)
72 {
73 for (N i = 0; i < serializer.size; ++i)
74 data[i] = serializer.data[i];
75 }
76
77 Serializer& operator=(Serializer&& serializer) noexcept
78 {
79 if (this == &serializer)
80 return *this;
81
82 endianness = serializer.endianness;
83 delete[] data;
84 data = serializer.data;
85 size = serializer.size;
86 offset = serializer.offset;
87
88 serializer.data = nullptr;
89 serializer.size = 0;
90 serializer.offset = 0;
91
92 return *this;
93 }
94
95 Serializer& operator=(const Serializer& serializer)
96 {
97 if (this == &serializer)
98 return *this;
99
100 endianness = serializer.endianness;
101
102 delete[] data;
103 data = new Byte[serializer.size];
104 for (N i = 0; i < serializer.size; ++i)
105 data[i] = serializer.data[i];
106
107 size = serializer.size;
108 offset = serializer.offset;
109
110 return *this;
111 }
112
113 bool operator==(const Serializer& in) const
114 {
115 if (size != in.size)
116 return false;
117
118 return Util::Compare(data, in.data, size);
119 }
120
121 bool operator!=(const Serializer& in) const
122 {
123 if (size != in.size)
124 return true;
125
126 return !Util::Compare(data, in.data, size);
127 }
128
129 Serializer& operator+=(const N size)
130 {
131 offset += size;
132 return *this;
133 }
134
135 Serializer& operator-=(const N size)
136 {
137 offset -= size;
138 return *this;
139 }
140
141 Serializer& operator*=(const N size)
142 {
143 offset *= size;
144 return *this;
145 }
146
147 Serializer& operator/=(const N size)
148 {
149 offset /= size;
150 return *this;
151 }
152
153 Serializer& operator%=(const N size)
154 {
155 offset %= size;
156 return *this;
157 }
158
159 operator const Byte* () const
160 {
161 return data;
162 }
163
164 operator Byte* ()
165 {
166 return data;
167 }
168
169 void SetEndianness(const Endianness newEndianness)
170 {
171 endianness = newEndianness;
172 }
173
175 {
176 return endianness;
177 }
178
179 template<typename T, typename O = UInt_64>
180 void WriteArray(const T* const value, const O size)
181 {
182 if (sizeof(N) + size * sizeof(T) > this->size - offset)
183 {
184 N remainder = sizeof(N) + size * sizeof(T) - (this->size - offset);
185
186 Byte* r = new Byte[this->size + remainder];
187
188 Util::Copy(r, data, this->size);
189
190 delete[] data;
191 data = r;
192 this->size += remainder;
193 }
194
196 {
197 if (endianness == Endianness::LE)
198 {
199 *(N*)&data[offset] = (N)size;
200
201 offset += sizeof(N);
202
203 for (N i = 0; i < size; ++i)
204 *(T*)&data[offset + i * sizeof(T)] = value[i];
205 }
206 else
207 {
208 N tmp = (N)size;
209
210 for (N i = 0; i < sizeof(N); ++i)
211 data[offset + i] = ((Byte*)&tmp)[sizeof(N) - i - 1];
212
213 offset += sizeof(N);
214
215 for (N i = 0; i < size; ++i)
216 for (N b = 0; b < sizeof(T); ++b)
217 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - i - 1];
218 }
219 }
220 else
221 {
222 if (endianness == Endianness::LE)
223 {
224 N tmp = (N)size;
225
226 for (N i = 0; i < sizeof(N); ++i)
227 data[offset + i] = ((Byte*)&tmp)[sizeof(N) - i - 1];
228
229 offset += sizeof(N);
230
231 for (N i = 0; i < size; ++i)
232 for (N b = 0; b < sizeof(T); ++b)
233 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - i - 1];
234 }
235 else
236 {
237 *(N*)&data[offset] = (N)size;
238
239 offset += sizeof(N);
240
241 for (N i = 0; i < size; ++i)
242 *(T*)&data[offset + i * sizeof(T)] = value[i];
243 }
244 }
245
246 offset += sizeof(T) * size;
247 }
248
249 template<typename T, typename O = UInt_64>
250 void WriteArray(const Array<T, O>& value)
251 {
252 if (sizeof(N) + value.Size() * sizeof(T) > size - offset)
253 {
254 N remainder = sizeof(N) + value.Size() * sizeof(T) - (size - offset);
255
256 Byte* r = new Byte[size + remainder];
257
258 Util::Copy(r, data, size);
259
260 delete[] data;
261 data = r;
262 size += remainder;
263 }
264
266 {
267 if (endianness == Endianness::LE)
268 {
269 *(N*)&data[offset] = (N)value.Size();
270
271 offset += sizeof(N);
272
273 for (N i = 0; i < value.Size(); ++i)
274 *(T*)&data[offset + i * sizeof(T)] = value[i];
275 }
276 else
277 {
278 N tmpSize = (N)value.Size();
279
280 for (N i = 0; i < sizeof(N); ++i)
281 data[offset + i] = ((Byte*)&tmpSize)[sizeof(N) - i - 1];
282
283 offset += sizeof(N);
284
285 for (N i = 0; i < value.Size(); ++i)
286 for (N b = 0; b < sizeof(T); ++b)
287 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - i - 1];
288 }
289 }
290 else
291 {
292 if (endianness == Endianness::LE)
293 {
294 N tmpSize = (N)value.Size();
295
296 for (N i = 0; i < sizeof(N); ++i)
297 data[offset + i] = ((Byte*)&tmpSize)[sizeof(N) - i - 1];
298
299 offset += sizeof(N);
300
301 for (N i = 0; i < value.Size(); ++i)
302 for (N b = 0; b < sizeof(T); ++b)
303 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - i - 1];
304 }
305 else
306 {
307 *(N*)&data[offset] = (N)value.Size();
308
309 offset += sizeof(N);
310
311 for (N i = 0; i < value.Size(); ++i)
312 *(T*)&data[offset + i * sizeof(T)] = value[i];
313 }
314 }
315
316 offset += sizeof(T) * value.Size();
317 }
318
319 template<typename T, typename O = UInt_64>
320 void WriteVector(const Vector<T, O>& value)
321 {
322 if (sizeof(N) + value.Size() * sizeof(T) > size - offset)
323 {
324 N remainder = sizeof(N) + value.Size() * sizeof(T) - (size - offset);
325
326 Byte* r = new Byte[size + remainder];
327
328 Util::Copy(r, data, size);
329
330 delete[] data;
331 data = r;
332 size += remainder;
333 }
334
336 {
337 if (endianness == Endianness::LE)
338 {
339 *(N*)&data[offset] = (N)value.Size();
340
341 offset += sizeof(N);
342
343 for (N i = 0; i < value.Size(); ++i)
344 *(T*)&data[offset + i * sizeof(T)] = value[i];
345 }
346 else
347 {
348 N tmpSize = (N)value.Size();
349
350 for (N i = 0; i < sizeof(N); ++i)
351 data[offset + i] = ((Byte*)&tmpSize)[sizeof(N) - i - 1];
352
353 offset += sizeof(N);
354
355 for (N i = 0; i < value.Size(); ++i)
356 for (N b = 0; b < sizeof(T); ++b)
357 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - i - 1];
358 }
359 }
360 else
361 {
362 if (endianness == Endianness::LE)
363 {
364 N tmpSize = (N)value.Size();
365
366 for (N i = 0; i < sizeof(N); ++i)
367 data[offset + i] = ((Byte*)&tmpSize)[sizeof(N) - i - 1];
368
369 offset += sizeof(N);
370
371 for (N i = 0; i < value.Size(); ++i)
372 for (N b = 0; b < sizeof(T); ++b)
373 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - i - 1];
374 }
375 else
376 {
377 *(N*)&data[offset] = (N)value.Size();
378
379 offset += sizeof(N);
380
381 for (N i = 0; i < value.Size(); ++i)
382 *(T*)&data[offset + i * sizeof(T)] = value[i];
383 }
384 }
385
386 offset += sizeof(T) * value.Size();
387 }
388
389 template<typename T, typename O = UInt_64>
390 void WriteStr(const T* str, N inSize = 0)
391 {
392 bool sizeKnown = inSize;
393
394 if (!sizeKnown)
395 while (str[inSize])
396 inSize++;
397
398 N bSize = sizeof(T) * inSize;
399 N bSizeN = bSize;
400 if (!sizeKnown)
401 bSizeN += sizeof(T);
402
403 if (bSizeN > size - offset)
404 {
405 N remainder = bSizeN - (size - offset);
406
407 Byte* r = new Byte[size + remainder];
408
409 Util::Copy(r, data, size);
410
411 delete[] data;
412 data = r;
413 size += remainder;
414 }
415
417 {
418 if (endianness == Endianness::LE)
419 {
420 Util::Copy(&data[offset], &str[0], bSize);
421
422 if (!sizeKnown)
423 *(T*)&data[offset + inSize] = 0;
424 }
425 else
426 {
427 for (N i = 0; i < inSize; ++i)
428 for (N b = 0; b < sizeof(T); ++b)
429 data[offset + sizeof(T) * i + b] = ((Byte*)&str[i])[sizeof(T) - i - 1];
430
431 if (!sizeKnown)
432 *(T*)&data[offset + bSize] = 0;
433 }
434 }
435 else
436 {
437 if (endianness == Endianness::LE)
438 {
439 for (N i = 0; i < inSize; ++i)
440 for (N b = 0; b < sizeof(T); ++b)
441 data[offset + sizeof(T) * i + b] = ((Byte*)&str[i])[sizeof(T) - i - 1];
442
443 if (!sizeKnown)
444 *(T*)&data[offset + bSize] = 0;
445 }
446 else
447 {
448 Util::Copy(&data[offset], &str[0], bSize);
449
450 if (!sizeKnown)
451 *(T*)&data[offset + bSize] = 0;
452 }
453 }
454
455 offset += bSizeN;
456 }
457
458 template<typename T, typename O = UInt_64>
459 void WriteStr(const Str<T, O>& str)
460 {
461 N inSize = sizeof(T) * (str.Size() + 1);
462
463 if (inSize > size - offset)
464 {
465 N remainder = inSize - (size - offset);
466
467 Byte* r = new Byte[size + remainder];
468
469 Util::Copy(r, data, size);
470
471 delete[] data;
472 data = r;
473 size += remainder;
474 }
475
477 {
478 if (endianness == Endianness::LE)
479 {
480 Util::Copy(&data[offset], &str[0], str.Size(true));
481
482 *(T*)&data[offset + str.Size(true)] = 0;
483 }
484 else
485 {
486 for (N i = 0; i < str.Size(); ++i)
487 for (N b = 0; b < sizeof(T); ++b)
488 data[offset + sizeof(T) * i + b] = ((Byte*)&str[i])[sizeof(T) - i - 1];
489
490 *(T*)&data[offset + str.Size(true)] = 0;
491 }
492 }
493 else
494 {
495 if (endianness == Endianness::LE)
496 {
497 for (N i = 0; i < str.Size(); ++i)
498 for (N b = 0; b < sizeof(T); ++b)
499 data[offset + sizeof(T) * i + b] = ((Byte*)&str[i])[sizeof(T) - i - 1];
500
501 *(T*)&data[offset + str.Size(true)] = 0;
502 }
503 else
504 {
505 Util::Copy(&data[offset], &str[0], str.Size(true));
506
507 *(T*)&data[offset + str.Size(true)] = 0;
508 }
509 }
510
511 offset += inSize;
512 }
513
514 void WriteVersion(const Version& value)
515 {
516 if (sizeof(unsigned int) * 3 > size - offset)
517 {
518 N remainder = sizeof(unsigned int) * 3 - (size - offset);
519
520 Byte* r = new Byte[size + remainder];
521
522 Util::Copy(r, data, size);
523
524 delete[] data;
525 data = r;
526 size += remainder;
527 }
528
530 {
531 if (endianness == Endianness::LE)
532 for (N i = 0; i < 3; ++i)
533 *(unsigned int*)&data[offset + i * sizeof(unsigned int)] = value[i];
534 else
535 for (N i = 0; i < 3; ++i)
536 for (N b = 0; b < sizeof(unsigned int); ++b)
537 data[offset + i * sizeof(unsigned int) + b] = value[sizeof(unsigned int) - i - 1];
538 }
539 else
540 {
541 if (endianness == Endianness::LE)
542 for (N i = 0; i < 3; ++i)
543 for (N b = 0; b < sizeof(unsigned int); ++b)
544 data[offset + i * sizeof(unsigned int) + b] = value[sizeof(unsigned int) - i - 1];
545 else
546 for (N i = 0; i < 3; ++i)
547 *(unsigned int*)&data[offset + i * sizeof(unsigned int)] = value[i];
548 }
549
550 offset += sizeof(unsigned int) * 3;
551 }
552
553 template<typename T>
554 void WriteVec2(const Vec2<T>& value)
555 {
556 if (sizeof(T) * 2 > size - offset)
557 {
558 N remainder = sizeof(T) * 2 - (size - offset);
559
560 Byte* r = new Byte[size + remainder];
561
562 Util::Copy(r, data, size);
563
564 delete[] data;
565 data = r;
566 size += remainder;
567 }
568
570 {
571 if (endianness == Endianness::LE)
572 for (N i = 0; i < 2; ++i)
573 *(T*)&data[offset + i * sizeof(T)] = value[i];
574 else
575 for (N i = 0; i < 2; ++i)
576 for (N b = 0; b < sizeof(T); ++b)
577 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
578 }
579 else
580 {
581 if (endianness == Endianness::LE)
582 for (N i = 0; i < 2; ++i)
583 for (N b = 0; b < sizeof(T); ++b)
584 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
585 else
586 for (N i = 0; i < 2; ++i)
587 *(T*)&data[offset + i * sizeof(T)] = value[i];
588 }
589
590 offset += sizeof(T) * 2;
591 }
592
593 template<typename T>
594 void WriteVec3(const Vec3<T>& value)
595 {
596 if (sizeof(T) * 3 > size - offset)
597 {
598 N remainder = sizeof(T) * 3 - (size - offset);
599
600 Byte* r = new Byte[size + remainder];
601
602 Util::Copy(r, data, size);
603
604 delete[] data;
605 data = r;
606 size += remainder;
607 }
608
610 {
611 if (endianness == Endianness::LE)
612 for (N i = 0; i < 3; ++i)
613 *(T*)&data[offset + i * sizeof(T)] = value[i];
614 else
615 for (N i = 0; i < 3; ++i)
616 for (N b = 0; b < sizeof(T); ++b)
617 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
618 }
619 else
620 {
621 if (endianness == Endianness::LE)
622 for (N i = 0; i < 3; ++i)
623 for (N b = 0; b < sizeof(T); ++b)
624 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
625 else
626 for (N i = 0; i < 3; ++i)
627 *(T*)&data[offset + i * sizeof(T)] = value[i];
628 }
629
630 offset += sizeof(T) * 3;
631 }
632
633 void WriteColor3(const Color3& value)
634 {
635 if (sizeof(float) * 3 > size - offset)
636 {
637 N remainder = sizeof(float) * 3 - (size - offset);
638
639 Byte* r = new Byte[size + remainder];
640
641 Util::Copy(r, data, size);
642
643 delete[] data;
644 data = r;
645 size += remainder;
646 }
647
649 {
650 if (endianness == Endianness::LE)
651 for (N i = 0; i < 3; ++i)
652 *(float*)&data[offset + i * sizeof(float)] = value[i];
653 else
654 for (N i = 0; i < 3; ++i)
655 for (N b = 0; b < sizeof(float); ++b)
656 data[offset + i * sizeof(float) + b] = value[sizeof(float) - i - 1];
657 }
658 else
659 {
660 if (endianness == Endianness::LE)
661 for (N i = 0; i < 3; ++i)
662 for (N b = 0; b < sizeof(float); ++b)
663 data[offset + i * sizeof(float) + b] = value[sizeof(float) - i - 1];
664 else
665 for (N i = 0; i < 3; ++i)
666 *(float*)&data[offset + i * sizeof(float)] = value[i];
667 }
668
669 offset += sizeof(float) * 3;
670 }
671
672 template<typename T>
673 void WriteVec4(const Vec4<T>& value)
674 {
675 if (sizeof(T) * 4 > size - offset)
676 {
677 N remainder = sizeof(T) * 4 - (size - offset);
678
679 Byte* r = new Byte[size + remainder];
680
681 Util::Copy(r, data, size);
682
683 delete[] data;
684 data = r;
685 size += remainder;
686 }
687
689 {
690 if (endianness == Endianness::LE)
691 for (N i = 0; i < 4; ++i)
692 *(T*)&data[offset + i * sizeof(T)] = value[i];
693 else
694 for (N i = 0; i < 4; ++i)
695 for (N b = 0; b < sizeof(T); ++b)
696 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
697 }
698 else
699 {
700 if (endianness == Endianness::LE)
701 for (N i = 0; i < 4; ++i)
702 for (N b = 0; b < sizeof(T); ++b)
703 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
704 else
705 for (N i = 0; i < 4; ++i)
706 *(T*)&data[offset + i * sizeof(T)] = value[i];
707 }
708
709 offset += sizeof(T) * 4;
710 }
711
712 template<typename T>
713 void WriteRect(const Rect<T>& value)
714 {
715 if (sizeof(T) * 4 > size - offset)
716 {
717 N remainder = sizeof(T) * 4 - (size - offset);
718
719 Byte* r = new Byte[size + remainder];
720
721 Util::Copy(r, data, size);
722
723 delete[] data;
724 data = r;
725 size += remainder;
726 }
727
729 {
730 if (endianness == Endianness::LE)
731 for (N i = 0; i < 4; ++i)
732 *(T*)&data[offset + i * sizeof(T)] = value[i];
733 else
734 for (N i = 0; i < 4; ++i)
735 for (N b = 0; b < sizeof(T); ++b)
736 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
737 }
738 else
739 {
740 if (endianness == Endianness::LE)
741 for (N i = 0; i < 4; ++i)
742 for (N b = 0; b < sizeof(T); ++b)
743 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
744 else
745 for (N i = 0; i < 4; ++i)
746 *(T*)&data[offset + i * sizeof(T)] = value[i];
747 }
748
749 offset += sizeof(T) * 4;
750 }
751
752 void WriteColor4(const Color4& value)
753 {
754 if (sizeof(float) * 4 > size - offset)
755 {
756 N remainder = sizeof(float) * 4 - (size - offset);
757
758 Byte* r = new Byte[size + remainder];
759
760 Util::Copy(r, data, size);
761
762 delete[] data;
763 data = r;
764 size += remainder;
765 }
766
768 {
769 if (endianness == Endianness::LE)
770 for (N i = 0; i < 4; ++i)
771 *(float*)&data[offset + i * sizeof(float)] = value[i];
772 else
773 for (N i = 0; i < 4; ++i)
774 for (N b = 0; b < sizeof(float); ++b)
775 data[offset + i * sizeof(float) + b] = value[sizeof(float) - i - 1];
776 }
777 else
778 {
779 if (endianness == Endianness::LE)
780 for (N i = 0; i < 4; ++i)
781 for (N b = 0; b < sizeof(float); ++b)
782 data[offset + i * sizeof(float) + b] = value[sizeof(float) - i - 1];
783 else
784 for (N i = 0; i < 4; ++i)
785 *(float*)&data[offset + i * sizeof(float)] = value[i];
786 }
787
788 offset += sizeof(float) * 4;
789 }
790
791 template<typename T>
792 void WriteQuat(const Quat<T>& value)
793 {
794 if (sizeof(T) * 4 > size - offset)
795 {
796 N remainder = sizeof(T) * 4 - (size - offset);
797
798 Byte* r = new Byte[size + remainder];
799
800 Util::Copy(r, data, size);
801
802 delete[] data;
803 data = r;
804 size += remainder;
805 }
806
808 {
809 if (endianness == Endianness::LE)
810 for (N i = 0; i < 4; ++i)
811 *(T*)&data[offset + i * sizeof(T)] = value[i];
812 else
813 for (N i = 0; i < 4; ++i)
814 for (N b = 0; b < sizeof(T); ++b)
815 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
816 }
817 else
818 {
819 if (endianness == Endianness::LE)
820 for (N i = 0; i < 4; ++i)
821 for (N b = 0; b < sizeof(T); ++b)
822 data[offset + i * sizeof(T) + b] = value[sizeof(T) - i - 1];
823 else
824 for (N i = 0; i < 4; ++i)
825 *(T*)&data[offset + i * sizeof(T)] = value[i];
826 }
827
828 offset += sizeof(T) * 4;
829 }
830
831 template<typename T>
832 void WriteMat2(const Mat2<T>& value)
833 {
834 if (sizeof(T) * 4 > size - offset)
835 {
836 N remainder = sizeof(T) * 4 - (size - offset);
837
838 Byte* r = new Byte[size + remainder];
839
840 Util::Copy(r, data, size);
841
842 delete[] data;
843 data = r;
844 size += remainder;
845 }
846
848 {
849 if (endianness == Endianness::LE)
850 for (N i = 0; i < 4; ++i)
851 *(T*)&data[offset + i * sizeof(T)] = value[i];
852 else
853 for (N i = 0; i < 4; ++i)
854 for (N b = 0; b < sizeof(T); ++b)
855 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - b - 1];
856 }
857 else
858 {
859 if (endianness == Endianness::LE)
860 for (N i = 0; i < 4; ++i)
861 for (N b = 0; b < sizeof(T); ++b)
862 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - b - 1];
863 else
864 for (N i = 0; i < 4; ++i)
865 *(T*)&data[offset + i * sizeof(T)] = value[i];
866 }
867
868 offset += sizeof(T) * 4;
869 }
870
871 template<typename T>
872 void WriteMat3(const Mat3<T>& value)
873 {
874 if (sizeof(T) * 9 > size - offset)
875 {
876 N remainder = sizeof(T) * 9 - (size - offset);
877
878 Byte* r = new Byte[size + remainder];
879
880 Util::Copy(r, data, size);
881
882 delete[] data;
883 data = r;
884 size += remainder;
885 }
886
888 {
889 if (endianness == Endianness::LE)
890 for (N i = 0; i < 9; ++i)
891 *(T*)&data[offset + i * sizeof(T)] = value[i];
892 else
893 for (N i = 0; i < 9; ++i)
894 for (N b = 0; b < sizeof(T); ++b)
895 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - b - 1];
896 }
897 else
898 {
899 if (endianness == Endianness::LE)
900 for (N i = 0; i < 9; ++i)
901 for (N b = 0; b < sizeof(T); ++b)
902 data[offset + i * sizeof(T) + b] = ((Byte*)&value[i])[sizeof(T) - b - 1];
903 else
904 for (N i = 0; i < 9; ++i)
905 *(T*)&data[offset + i * sizeof(T)] = value[i];
906 }
907
908 offset += sizeof(T) * 9;
909 }
910
911 template<typename T>
912 void WriteMat4(const Mat4<T>& value)
913 {
914 if (sizeof(T) * 16 > size - offset)
915 {
916 N remainder = sizeof(T) * 16 - (size - offset);
917
918 Byte* r = new Byte[size + remainder];
919
920 Util::Copy(r, data, size);
921
922 delete[] data;
923 data = r;
924 size += remainder;
925 }
926
928 {
929 if (endianness == Endianness::LE)
930 for (N y = 0; y < 4; ++y)
931 for (N x = 0; x < 4; ++x)
932 *(T*)&data[offset + y * sizeof(T) * 4 + x * sizeof(T)] = value[y][x];
933 else
934 for (N y = 0; y < 4; ++y)
935 for (N x = 0; x < 4; ++x)
936 for (N i = 0; i < sizeof(T); ++i)
937 data[offset + y * sizeof(T) * 4 + x * sizeof(T) + i] = ((Byte*)&value[y][x])[sizeof(T) - i - 1];
938 }
939 else
940 {
941 if (endianness == Endianness::LE)
942 for (N y = 0; y < 4; ++y)
943 for (N x = 0; x < 4; ++x)
944 for (N i = 0; i < sizeof(T); ++i)
945 data[offset + y * sizeof(T) * 4 + x * sizeof(T) + i] = ((Byte*)&value[y][x])[sizeof(T) - i - 1];
946 else
947 for (N y = 0; y < 4; ++y)
948 for (N x = 0; x < 4; ++x)
949 *(T*)&data[offset + y * sizeof(T) * 4 + x * sizeof(T)] = value[y][x];
950 }
951
952 offset += sizeof(T) * 16;
953 }
954
955 void WriteSer(const Serializer& ser)
956 {
957 if (ser.endianness != endianness)
958 return;
959
960 if (ser.Size() > size - offset)
961 {
962 N remainder = ser.Size() - (size - offset);
963
964 Byte* result = new Byte[size + remainder];
965
966 Util::Copy(result, data, size);
967
968 delete[] data;
969 data = result;
970 size += remainder;
971 }
972
973 Util::Copy(&data[offset], &ser[0], ser.Size());
974
975 offset += ser.Size();
976 }
977
978 void WritePadding(const N size)
979 {
980 if (size > this->size - offset)
981 {
982 N remainder = size - (this->size - offset);
983
984 Byte* r = new Byte[this->size + remainder];
985
986 Util::Copy(r, data, this->size);
987
988 delete[] data;
989 data = r;
990 this->size += remainder;
991 }
992
993 Util::Zero(&data[offset], size);
994
995 offset += size;
996 }
997
998 template<typename T>
999 void Write(const T value)
1000 {
1001 if (sizeof(T) > size - offset)
1002 {
1003 N remainder = sizeof(T) - (size - offset);
1004
1005 Byte* r = new Byte[size + remainder];
1006
1007 Util::Copy(r, data, size);
1008
1009 delete[] data;
1010 data = r;
1011 size += remainder;
1012 }
1013
1015 {
1016 if (endianness == Endianness::LE)
1017 *(T*)&data[offset] = value;
1018 else
1019 for (N i = 0; i < sizeof(T); ++i)
1020 data[offset + i] = ((Byte*)&value)[sizeof(T) - i - 1];
1021 }
1022 else
1023 {
1024 if (endianness == Endianness::LE)
1025 for (N i = 0; i < sizeof(T); ++i)
1026 data[offset + i] = ((Byte*)&value)[sizeof(T) - i - 1];
1027 else
1028 *(T*)&data[offset] = value;
1029 }
1030
1031 offset += sizeof(T);
1032 }
1033
1034 template<typename T, typename O>
1035 void ReadArray(T* const value, O* const size)
1036 {
1037 if (!*size)
1038 {
1039 *size = (O)Read<N>();
1040 return;
1041 }
1042
1043 for (N i = 0; i < *size; ++i)
1044 value[i] = Read<T>();
1045 }
1046
1047 template<typename T, typename O>
1048 Array<T, O> ReadArray(const O size = 0)
1049 {
1050 Array<T, O> result(size ? size : (O)Read<N>());
1051
1052 for (O i = 0; i < result.Size(); ++i)
1053 result[i] = Read<T>();
1054
1055 return result;
1056 }
1057
1058 template<typename T, typename O>
1059 Vector<T, O> ReadVector(const O size = 0)
1060 {
1061 Vector<T, O> result(size ? size : (O)Read<N>());
1062
1063 for (O i = 0; i < result.Size(); ++i)
1064 result[i] = Read<T>();
1065
1066 return result;
1067 }
1068
1069 template<typename T = Char_8, typename O = UInt_64>
1070 Str<T, O> ReadStr(O size = 0)
1071 {
1072 bool sizeKnown = size;
1073
1074 if (!sizeKnown)
1075 while (((T*)&data[offset])[size])
1076 ++size;
1077
1078 Str<T, O> result(size);
1079
1081 {
1082 if (endianness == Endianness::LE)
1083 Util::Copy(&result[0], &data[offset], result.Size(true));
1084 else
1085 for (N i = 0; i < size; ++i)
1086 for (N b = 0; b < sizeof(T); ++b)
1087 ((Byte*)&result[i])[b] = data[offset + sizeof(T) * i + b];
1088 }
1089 else
1090 {
1091 if (endianness == Endianness::LE)
1092 for (N i = 0; i < size; ++i)
1093 for (N b = 0; b < sizeof(T); ++b)
1094 ((Byte*)&result[i])[b] = data[offset + sizeof(T) * i + b];
1095 else
1096 Util::Copy(&result[0], &data[offset], result.Size(true));
1097 }
1098
1099 offset += result.Size(true);
1100
1101 if (!sizeKnown)
1102 offset++;
1103
1104 return result;
1105 }
1106
1111
1112 template<typename T>
1114 {
1115 return {Read<T>(), Read<T>()};
1116 }
1117
1118 template<typename T>
1120 {
1121 return {Read<T>(), Read<T>(), Read<T>()};
1122 }
1123
1125 {
1126 return {Read<float>(), Read<float>(), Read<float>()};
1127 }
1128
1129 template<typename T>
1131 {
1132 return {Read<T>(), Read<T>(), Read<T>(), Read<T>()};
1133 }
1134
1135 template<typename T>
1137 {
1138 return {Read<T>(), Read<T>(), Read<T>(), Read<T>()};
1139 }
1140
1142 {
1143 return {Read<float>(), Read<float>(), Read<float>(), Read<float>()};
1144 }
1145
1146 template<typename T>
1148 {
1149 return {Read<T>(), Read<T>(), Read<T>(), Read<T>()};
1150 }
1151
1152 template<typename T>
1154 {
1155 Mat2<T> result;
1156 for (N i = 0; i < 4; ++i)
1157 result[i] = Read<float>();
1158
1159 return result;
1160 }
1161
1162 template<typename T>
1164 {
1165 Mat3<T> result;
1166 for (N i = 0; i < 9; ++i)
1167 result[i] = Read<float>();
1168
1169 return result;
1170 }
1171
1172 template<typename T>
1174 {
1175 Mat4<T> result;
1176 for (N i = 0; i < 16; ++i)
1177 result[i] = Read<float>();
1178
1179 return result;
1180 }
1181
1182 template<typename T>
1184 {
1185 T value = (T)0;
1186
1188 {
1189 if (endianness == Endianness::LE)
1190 value = *(T*)&data[offset];
1191 else
1192 for (N i = 0; i < sizeof(T); ++i)
1193 ((Byte*)&value)[sizeof(T) - i - 1] = data[offset + i];
1194 }
1195 else
1196 {
1197 if (endianness == Endianness::LE)
1198 for (N i = 0; i < sizeof(T); ++i)
1199 ((Byte*)&value)[sizeof(T) - i - 1] = data[offset + i];
1200 else
1201 value = *(T*)&data[offset];
1202 }
1203
1204 offset += sizeof(T);
1205
1206 return value;
1207 }
1208
1209 void SetOffset(const N offset)
1210 {
1211 this->offset = offset;
1212 }
1213
1214 N GetOffset() const
1215 {
1216 return offset;
1217 }
1218
1219 void Resize(const N newSize)
1220 {
1221 Byte* result = new Byte[newSize];
1222 Util::Copy(result, data, newSize >= size ? size : newSize);
1223 delete[] data;
1224 data = result;
1225 size = newSize;
1226 }
1227
1228 N Size() const
1229 {
1230 return size;
1231 }
1232 };
1233}
Definition Array.h:16
N Size() const
Definition Array.h:413
static Endianness GetEndianness()
Definition CPU.cpp:29
Definition Color3.h:8
Definition Color4.h:9
Definition Mat2.h:10
Definition Mat3.h:11
Definition Mat4.h:13
Definition Quat.h:12
Definition Rect.h:12
Mat4< T > ReadMat4()
Definition Serializer.h:1173
Mat3< T > ReadMat3()
Definition Serializer.h:1163
Color4 ReadColor4()
Definition Serializer.h:1141
Quat< T > ReadQuat()
Definition Serializer.h:1147
Serializer & operator=(Serializer &&serializer) noexcept
Definition Serializer.h:77
~Serializer()
Definition Serializer.h:33
Serializer()
Definition Serializer.h:38
void WriteStr(const T *str, N inSize=0)
Definition Serializer.h:390
void WriteMat4(const Mat4< T > &value)
Definition Serializer.h:912
Serializer(const Serializer &serializer)
Definition Serializer.h:69
void SetOffset(const N offset)
Definition Serializer.h:1209
void WriteVersion(const Version &value)
Definition Serializer.h:514
Serializer(Serializer &&serializer) noexcept
Definition Serializer.h:60
Vector< T, O > ReadVector(const O size=0)
Definition Serializer.h:1059
Endianness GetEndianness() const
Definition Serializer.h:174
Array< T, O > ReadArray(const O size=0)
Definition Serializer.h:1048
void WriteQuat(const Quat< T > &value)
Definition Serializer.h:792
Serializer & operator=(const Serializer &serializer)
Definition Serializer.h:95
void WriteVec4(const Vec4< T > &value)
Definition Serializer.h:673
Serializer & operator+=(const N size)
Definition Serializer.h:129
Serializer & operator/=(const N size)
Definition Serializer.h:147
void WriteColor3(const Color3 &value)
Definition Serializer.h:633
void WriteSer(const Serializer &ser)
Definition Serializer.h:955
Vec3< T > ReadVec3()
Definition Serializer.h:1119
Color3 ReadColor3()
Definition Serializer.h:1124
Serializer & operator-=(const N size)
Definition Serializer.h:135
void WriteVec2(const Vec2< T > &value)
Definition Serializer.h:554
void Resize(const N newSize)
Definition Serializer.h:1219
void WriteStr(const Str< T, O > &str)
Definition Serializer.h:459
void Write(const T value)
Definition Serializer.h:999
void ReadArray(T *const value, O *const size)
Definition Serializer.h:1035
void WriteRect(const Rect< T > &value)
Definition Serializer.h:713
void WriteArray(const T *const value, const O size)
Definition Serializer.h:180
void WriteMat2(const Mat2< T > &value)
Definition Serializer.h:832
void SetEndianness(const Endianness newEndianness)
Definition Serializer.h:169
Version ReadVersion()
Definition Serializer.h:1107
Serializer(const Endianness endianness)
Definition Serializer.h:43
void WriteVector(const Vector< T, O > &value)
Definition Serializer.h:320
void WriteColor4(const Color4 &value)
Definition Serializer.h:752
void WriteArray(const Array< T, O > &value)
Definition Serializer.h:250
Serializer(const Endianness endianness, const Byte *const data, const N size, const N offset=0)
Definition Serializer.h:53
Serializer & operator*=(const N size)
Definition Serializer.h:141
bool operator!=(const Serializer &in) const
Definition Serializer.h:121
N Size() const
Definition Serializer.h:1228
Mat2< T > ReadMat2()
Definition Serializer.h:1153
Serializer(const Endianness endianness, const N size)
Definition Serializer.h:48
Serializer & operator%=(const N size)
Definition Serializer.h:153
Vec2< T > ReadVec2()
Definition Serializer.h:1113
N GetOffset() const
Definition Serializer.h:1214
bool operator==(const Serializer &in) const
Definition Serializer.h:113
void WriteVec3(const Vec3< T > &value)
Definition Serializer.h:594
T Read()
Definition Serializer.h:1183
Rect< T > ReadRect()
Definition Serializer.h:1136
Vec4< T > ReadVec4()
Definition Serializer.h:1130
Str< T, O > ReadStr(O size=0)
Definition Serializer.h:1070
void WritePadding(const N size)
Definition Serializer.h:978
void WriteMat3(const Mat3< T > &value)
Definition Serializer.h:872
Definition Str.h:29
N Size(bool inBytes=false) const
Definition Str.h:523
static void Copy(void *out, const void *in, UInt_64 size)
Definition Util.cpp:49
static void Zero(void *in, UInt_64 size)
Definition Util.cpp:91
static bool Compare(const void *a, const void *b, UInt_64 size)
Definition Util.cpp:5
Definition Vec2.h:13
Definition Vec3.h:14
Definition Vec4.h:15
Definition Vector.h:18
N Size() const
Definition Vector.h:240
A helper class for storing version major, minor and patch.
Definition Version.h:9
Definition Anchor.h:6
Endianness
Definition CPU.h:21
@ LE
Definition CPU.h:22
@ BE
Definition CPU.h:23
unsigned char Byte
Definition Types.h:39