Skip to content

Commit 1a5b4b3

Browse files
kwolekrkwolekr
committedOct 15, 2015
Add BufReader and vector-based serialization methods
·
5.11.00.4.14
1 parent e067cea commit 1a5b4b3

File tree

3 files changed

+573
-2
lines changed

3 files changed

+573
-2
lines changed
 

Diff for: ‎src/unittest/test_serialization.cpp

+263
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,9 @@ class TestSerialization : public TestBase {
4040
void testDeSerializeLongString();
4141
void testStreamRead();
4242
void testStreamWrite();
43+
void testVecPut();
44+
void testStringLengthLimits();
45+
void testBufReader();
4346

4447
std::string teststring2;
4548
std::wstring teststring2_w;
@@ -64,6 +67,9 @@ void TestSerialization::runTests(IGameDef *gamedef)
6467
TEST(testSerializeHex);
6568
TEST(testStreamRead);
6669
TEST(testStreamWrite);
70+
TEST(testVecPut);
71+
TEST(testStringLengthLimits);
72+
TEST(testBufReader);
6773
}
6874

6975
////////////////////////////////////////////////////////////////////////////////
@@ -369,6 +375,263 @@ void TestSerialization::testStreamWrite()
369375
}
370376

371377

378+
void TestSerialization::testVecPut()
379+
{
380+
std::vector<u8> buf;
381+
382+
putU8(&buf, 0x11);
383+
putU16(&buf, 0x2233);
384+
putU32(&buf, 0x44556677);
385+
putU64(&buf, 0x8899AABBCCDDEEFF);
386+
387+
putS8(&buf, -128);
388+
putS16(&buf, 30000);
389+
putS32(&buf, -6);
390+
putS64(&buf, -43);
391+
392+
putF1000(&buf, 53.53467f);
393+
putF1000(&buf, -300000.32f);
394+
putF1000(&buf, F1000_MIN);
395+
putF1000(&buf, F1000_MAX);
396+
397+
putString(&buf, "foobar!");
398+
399+
putV2S16(&buf, v2s16(500, 500));
400+
putV3S16(&buf, v3s16(4207, 604, -30));
401+
putV2S32(&buf, v2s32(1920, 1080));
402+
putV3S32(&buf, v3s32(-400, 6400054, 290549855));
403+
putV2F1000(&buf, v2f(500.65661f, 350.34567f));
404+
405+
putWideString(&buf, L"\x02~woof~\x5455");
406+
407+
putV3F1000(&buf, v3f(500, 10024.2f, -192.54f));
408+
putARGB8(&buf, video::SColor(255, 128, 50, 128));
409+
410+
putLongString(&buf, "some longer string here");
411+
412+
putU16(&buf, 0xF00D);
413+
414+
UASSERT(buf.size() == sizeof(test_serialized_data));
415+
UASSERT(!memcmp(&buf[0], test_serialized_data, sizeof(test_serialized_data)));
416+
}
417+
418+
419+
void TestSerialization::testStringLengthLimits()
420+
{
421+
std::vector<u8> buf;
422+
std::string too_long(STRING_MAX_LEN + 1, 'A');
423+
std::string way_too_large(LONG_STRING_MAX_LEN + 1, 'B');
424+
std::wstring too_long_wide(WIDE_STRING_MAX_LEN + 1, L'C');
425+
426+
EXCEPTION_CHECK(SerializationError, putString(&buf, too_long));
427+
428+
putLongString(&buf, too_long);
429+
too_long.resize(too_long.size() - 1);
430+
putString(&buf, too_long);
431+
432+
EXCEPTION_CHECK(SerializationError, putWideString(&buf, too_long_wide));
433+
too_long_wide.resize(too_long_wide.size() - 1);
434+
putWideString(&buf, too_long_wide);
435+
}
436+
437+
438+
void TestSerialization::testBufReader()
439+
{
440+
u8 u8_data;
441+
u16 u16_data;
442+
u32 u32_data;
443+
u64 u64_data;
444+
s8 s8_data;
445+
s16 s16_data;
446+
s32 s32_data;
447+
s64 s64_data;
448+
f32 f32_data, f32_data2, f32_data3, f32_data4;
449+
video::SColor scolor_data;
450+
v2s16 v2s16_data;
451+
v3s16 v3s16_data;
452+
v2s32 v2s32_data;
453+
v3s32 v3s32_data;
454+
v2f v2f_data;
455+
v3f v3f_data;
456+
std::string string_data;
457+
std::wstring widestring_data;
458+
std::string longstring_data;
459+
u8 raw_data[10] = {0};
460+
461+
BufReader buf(test_serialized_data, sizeof(test_serialized_data));
462+
463+
// Try reading data like normal
464+
UASSERT(buf.getU8() == 0x11);
465+
UASSERT(buf.getU16() == 0x2233);
466+
UASSERT(buf.getU32() == 0x44556677);
467+
UASSERT(buf.getU64() == 0x8899AABBCCDDEEFF);
468+
UASSERT(buf.getS8() == -128);
469+
UASSERT(buf.getS16() == 30000);
470+
UASSERT(buf.getS32() == -6);
471+
UASSERT(buf.getS64() == -43);
472+
UASSERT(buf.getF1000() == 53.534f);
473+
UASSERT(buf.getF1000() == -300000.32f);
474+
UASSERT(buf.getF1000() == F1000_MIN);
475+
UASSERT(buf.getF1000() == F1000_MAX);
476+
UASSERT(buf.getString() == "foobar!");
477+
UASSERT(buf.getV2S16() == v2s16(500, 500));
478+
UASSERT(buf.getV3S16() == v3s16(4207, 604, -30));
479+
UASSERT(buf.getV2S32() == v2s32(1920, 1080));
480+
UASSERT(buf.getV3S32() == v3s32(-400, 6400054, 290549855));
481+
UASSERT(buf.getV2F1000() == v2f(500.656f, 350.345f));
482+
UASSERT(buf.getWideString() == L"\x02~woof~\x5455");
483+
UASSERT(buf.getV3F1000() == v3f(500, 10024.2f, -192.54f));
484+
UASSERT(buf.getARGB8() == video::SColor(255, 128, 50, 128));
485+
UASSERT(buf.getLongString() == "some longer string here");
486+
487+
// Verify the offset and data is unchanged after a failed read
488+
size_t orig_pos = buf.pos;
489+
u32_data = 0;
490+
UASSERT(buf.getU32NoEx(&u32_data) == false);
491+
UASSERT(buf.pos == orig_pos);
492+
UASSERT(u32_data == 0);
493+
494+
// Now try the same for a failed string read
495+
UASSERT(buf.getStringNoEx(&string_data) == false);
496+
UASSERT(buf.pos == orig_pos);
497+
UASSERT(string_data == "");
498+
499+
// Now try the same for a failed string read
500+
UASSERT(buf.getWideStringNoEx(&widestring_data) == false);
501+
UASSERT(buf.pos == orig_pos);
502+
UASSERT(widestring_data == L"");
503+
504+
UASSERT(buf.getU16() == 0xF00D);
505+
506+
UASSERT(buf.remaining() == 0);
507+
508+
// Check to make sure these each blow exceptions as they're supposed to
509+
EXCEPTION_CHECK(SerializationError, buf.getU8());
510+
EXCEPTION_CHECK(SerializationError, buf.getU16());
511+
EXCEPTION_CHECK(SerializationError, buf.getU32());
512+
EXCEPTION_CHECK(SerializationError, buf.getU64());
513+
514+
EXCEPTION_CHECK(SerializationError, buf.getS8());
515+
EXCEPTION_CHECK(SerializationError, buf.getS16());
516+
EXCEPTION_CHECK(SerializationError, buf.getS32());
517+
EXCEPTION_CHECK(SerializationError, buf.getS64());
518+
519+
EXCEPTION_CHECK(SerializationError, buf.getF1000());
520+
EXCEPTION_CHECK(SerializationError, buf.getARGB8());
521+
522+
EXCEPTION_CHECK(SerializationError, buf.getV2S16());
523+
EXCEPTION_CHECK(SerializationError, buf.getV3S16());
524+
EXCEPTION_CHECK(SerializationError, buf.getV2S32());
525+
EXCEPTION_CHECK(SerializationError, buf.getV3S32());
526+
EXCEPTION_CHECK(SerializationError, buf.getV2F1000());
527+
EXCEPTION_CHECK(SerializationError, buf.getV3F1000());
528+
529+
EXCEPTION_CHECK(SerializationError, buf.getString());
530+
EXCEPTION_CHECK(SerializationError, buf.getWideString());
531+
EXCEPTION_CHECK(SerializationError, buf.getLongString());
532+
EXCEPTION_CHECK(SerializationError,
533+
buf.getRawData(raw_data, sizeof(raw_data)));
534+
535+
// See if we can skip backwards
536+
buf.pos = 5;
537+
UASSERT(buf.getRawDataNoEx(raw_data, 3) == true);
538+
UASSERT(raw_data[0] == 0x66);
539+
UASSERT(raw_data[1] == 0x77);
540+
UASSERT(raw_data[2] == 0x88);
541+
542+
UASSERT(buf.getU32() == 0x99AABBCC);
543+
UASSERT(buf.pos == 12);
544+
545+
// Now let's try it all over again using the NoEx variants
546+
buf.pos = 0;
547+
548+
UASSERT(buf.getU8NoEx(&u8_data));
549+
UASSERT(buf.getU16NoEx(&u16_data));
550+
UASSERT(buf.getU32NoEx(&u32_data));
551+
UASSERT(buf.getU64NoEx(&u64_data));
552+
553+
UASSERT(buf.getS8NoEx(&s8_data));
554+
UASSERT(buf.getS16NoEx(&s16_data));
555+
UASSERT(buf.getS32NoEx(&s32_data));
556+
UASSERT(buf.getS64NoEx(&s64_data));
557+
558+
UASSERT(buf.getF1000NoEx(&f32_data));
559+
UASSERT(buf.getF1000NoEx(&f32_data2));
560+
UASSERT(buf.getF1000NoEx(&f32_data3));
561+
UASSERT(buf.getF1000NoEx(&f32_data4));
562+
563+
UASSERT(buf.getStringNoEx(&string_data));
564+
UASSERT(buf.getV2S16NoEx(&v2s16_data));
565+
UASSERT(buf.getV3S16NoEx(&v3s16_data));
566+
UASSERT(buf.getV2S32NoEx(&v2s32_data));
567+
UASSERT(buf.getV3S32NoEx(&v3s32_data));
568+
UASSERT(buf.getV2F1000NoEx(&v2f_data));
569+
UASSERT(buf.getWideStringNoEx(&widestring_data));
570+
UASSERT(buf.getV3F1000NoEx(&v3f_data));
571+
UASSERT(buf.getARGB8NoEx(&scolor_data));
572+
573+
UASSERT(buf.getLongStringNoEx(&longstring_data));
574+
575+
// and make sure we got the correct data
576+
UASSERT(u8_data == 0x11);
577+
UASSERT(u16_data == 0x2233);
578+
UASSERT(u32_data == 0x44556677);
579+
UASSERT(u64_data == 0x8899AABBCCDDEEFF);
580+
UASSERT(s8_data == -128);
581+
UASSERT(s16_data == 30000);
582+
UASSERT(s32_data == -6);
583+
UASSERT(s64_data == -43);
584+
UASSERT(f32_data == 53.534f);
585+
UASSERT(f32_data2 == -300000.32f);
586+
UASSERT(f32_data3 == F1000_MIN);
587+
UASSERT(f32_data4 == F1000_MAX);
588+
UASSERT(string_data == "foobar!");
589+
UASSERT(v2s16_data == v2s16(500, 500));
590+
UASSERT(v3s16_data == v3s16(4207, 604, -30));
591+
UASSERT(v2s32_data == v2s32(1920, 1080));
592+
UASSERT(v3s32_data == v3s32(-400, 6400054, 290549855));
593+
UASSERT(v2f_data == v2f(500.656f, 350.345f));
594+
UASSERT(widestring_data == L"\x02~woof~\x5455");
595+
UASSERT(v3f_data == v3f(500, 10024.2f, -192.54f));
596+
UASSERT(scolor_data == video::SColor(255, 128, 50, 128));
597+
UASSERT(longstring_data == "some longer string here");
598+
599+
UASSERT(buf.remaining() == 2);
600+
UASSERT(buf.getRawDataNoEx(raw_data, 3) == false);
601+
UASSERT(buf.remaining() == 2);
602+
UASSERT(buf.getRawDataNoEx(raw_data, 2) == true);
603+
UASSERT(raw_data[0] == 0xF0);
604+
UASSERT(raw_data[1] == 0x0D);
605+
UASSERT(buf.remaining() == 0);
606+
607+
// Make sure no more available data causes a failure
608+
UASSERT(!buf.getU8NoEx(&u8_data));
609+
UASSERT(!buf.getU16NoEx(&u16_data));
610+
UASSERT(!buf.getU32NoEx(&u32_data));
611+
UASSERT(!buf.getU64NoEx(&u64_data));
612+
613+
UASSERT(!buf.getS8NoEx(&s8_data));
614+
UASSERT(!buf.getS16NoEx(&s16_data));
615+
UASSERT(!buf.getS32NoEx(&s32_data));
616+
UASSERT(!buf.getS64NoEx(&s64_data));
617+
618+
UASSERT(!buf.getF1000NoEx(&f32_data));
619+
UASSERT(!buf.getARGB8NoEx(&scolor_data));
620+
621+
UASSERT(!buf.getV2S16NoEx(&v2s16_data));
622+
UASSERT(!buf.getV3S16NoEx(&v3s16_data));
623+
UASSERT(!buf.getV2S32NoEx(&v2s32_data));
624+
UASSERT(!buf.getV3S32NoEx(&v3s32_data));
625+
UASSERT(!buf.getV2F1000NoEx(&v2f_data));
626+
UASSERT(!buf.getV3F1000NoEx(&v3f_data));
627+
628+
UASSERT(!buf.getStringNoEx(&string_data));
629+
UASSERT(!buf.getWideStringNoEx(&widestring_data));
630+
UASSERT(!buf.getLongStringNoEx(&longstring_data));
631+
UASSERT(!buf.getRawDataNoEx(raw_data, sizeof(raw_data)));
632+
}
633+
634+
372635
const u8 TestSerialization::test_serialized_data[12 * 13] = {
373636
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
374637
0xdd, 0xee, 0xff, 0x80, 0x75, 0x30, 0xff, 0xff, 0xff, 0xfa, 0xff, 0xff,

Diff for: ‎src/util/serialize.cpp

+71
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,77 @@ with this program; if not, write to the Free Software Foundation, Inc.,
2828
#include <iomanip>
2929
#include <vector>
3030

31+
SerializationError eof_ser_err("Attempted read past end of data");
32+
33+
////
34+
//// BufReader
35+
////
36+
37+
bool BufReader::getStringNoEx(std::string *val)
38+
{
39+
u16 num_chars;
40+
if (!getU16NoEx(&num_chars))
41+
return false;
42+
43+
if (pos + num_chars > size) {
44+
pos -= sizeof(num_chars);
45+
return false;
46+
}
47+
48+
val->assign((const char *)data + pos, num_chars);
49+
pos += num_chars;
50+
51+
return true;
52+
}
53+
54+
bool BufReader::getWideStringNoEx(std::wstring *val)
55+
{
56+
u16 num_chars;
57+
if (!getU16NoEx(&num_chars))
58+
return false;
59+
60+
if (pos + num_chars * 2 > size) {
61+
pos -= sizeof(num_chars);
62+
return false;
63+
}
64+
65+
for (size_t i = 0; i != num_chars; i++) {
66+
val->push_back(readU16(data + pos));
67+
pos += 2;
68+
}
69+
70+
return true;
71+
}
72+
73+
bool BufReader::getLongStringNoEx(std::string *val)
74+
{
75+
u32 num_chars;
76+
if (!getU32NoEx(&num_chars))
77+
return false;
78+
79+
if (pos + num_chars > size) {
80+
pos -= sizeof(num_chars);
81+
return false;
82+
}
83+
84+
val->assign((const char *)data + pos, num_chars);
85+
pos += num_chars;
86+
87+
return true;
88+
}
89+
90+
bool BufReader::getRawDataNoEx(void *val, size_t len)
91+
{
92+
if (pos + len > size)
93+
return false;
94+
95+
memcpy(val, data + pos, len);
96+
pos += len;
97+
98+
return true;
99+
}
100+
101+
31102
////
32103
//// String
33104
////

Diff for: ‎src/util/serialize.h

+239-2
Original file line numberDiff line numberDiff line change
@@ -21,14 +21,17 @@ with this program; if not, write to the Free Software Foundation, Inc.,
2121
#define UTIL_SERIALIZE_HEADER
2222

2323
#include "../irrlichttypes_bloated.h"
24+
#include "../exceptions.h" // for SerializationError
2425
#include "../debug.h" // for assert
26+
2527
#include "config.h"
2628
#if HAVE_ENDIAN_H
27-
#include <endian.h>
28-
#include <string.h> // for memcpy
29+
#include <endian.h>
2930
#endif
31+
#include <string.h> // for memcpy
3032
#include <iostream>
3133
#include <string>
34+
#include <vector>
3235

3336
#define FIXEDPOINT_FACTOR 1000.0f
3437

@@ -405,4 +408,238 @@ bool serializeStructToString(std::string *out,
405408
bool deSerializeStringToStruct(std::string valstr,
406409
std::string format, void *out, size_t olen);
407410

411+
////
412+
//// BufReader
413+
////
414+
415+
extern SerializationError eof_ser_err;
416+
417+
#define MAKE_BUFREADER_GETNOEX_FXN(T, N, S) \
418+
inline bool get ## N ## NoEx(T *val) \
419+
{ \
420+
if (pos + S > size) \
421+
return false; \
422+
*val = read ## N(data + pos); \
423+
pos += S; \
424+
return true; \
425+
}
426+
427+
#define MAKE_BUFREADER_GET_FXN(T, N) \
428+
inline T get ## N() \
429+
{ \
430+
T val; \
431+
if (!get ## N ## NoEx(&val)) \
432+
throw eof_ser_err; \
433+
return val; \
434+
}
435+
436+
class BufReader {
437+
public:
438+
BufReader(const u8 *data_, size_t size_) :
439+
data(data_),
440+
size(size_),
441+
pos(0)
442+
{
443+
}
444+
445+
MAKE_BUFREADER_GETNOEX_FXN(u8, U8, 1);
446+
MAKE_BUFREADER_GETNOEX_FXN(u16, U16, 2);
447+
MAKE_BUFREADER_GETNOEX_FXN(u32, U32, 4);
448+
MAKE_BUFREADER_GETNOEX_FXN(u64, U64, 8);
449+
MAKE_BUFREADER_GETNOEX_FXN(s8, S8, 1);
450+
MAKE_BUFREADER_GETNOEX_FXN(s16, S16, 2);
451+
MAKE_BUFREADER_GETNOEX_FXN(s32, S32, 4);
452+
MAKE_BUFREADER_GETNOEX_FXN(s64, S64, 8);
453+
MAKE_BUFREADER_GETNOEX_FXN(f32, F1000, 4);
454+
MAKE_BUFREADER_GETNOEX_FXN(v2s16, V2S16, 4);
455+
MAKE_BUFREADER_GETNOEX_FXN(v3s16, V3S16, 6);
456+
MAKE_BUFREADER_GETNOEX_FXN(v2s32, V2S32, 8);
457+
MAKE_BUFREADER_GETNOEX_FXN(v3s32, V3S32, 12);
458+
MAKE_BUFREADER_GETNOEX_FXN(v2f, V2F1000, 8);
459+
MAKE_BUFREADER_GETNOEX_FXN(v3f, V3F1000, 12);
460+
MAKE_BUFREADER_GETNOEX_FXN(video::SColor, ARGB8, 4);
461+
462+
bool getStringNoEx(std::string *val);
463+
bool getWideStringNoEx(std::wstring *val);
464+
bool getLongStringNoEx(std::string *val);
465+
bool getRawDataNoEx(void *data, size_t len);
466+
467+
MAKE_BUFREADER_GET_FXN(u8, U8);
468+
MAKE_BUFREADER_GET_FXN(u16, U16);
469+
MAKE_BUFREADER_GET_FXN(u32, U32);
470+
MAKE_BUFREADER_GET_FXN(u64, U64);
471+
MAKE_BUFREADER_GET_FXN(s8, S8);
472+
MAKE_BUFREADER_GET_FXN(s16, S16);
473+
MAKE_BUFREADER_GET_FXN(s32, S32);
474+
MAKE_BUFREADER_GET_FXN(s64, S64);
475+
MAKE_BUFREADER_GET_FXN(f32, F1000);
476+
MAKE_BUFREADER_GET_FXN(v2s16, V2S16);
477+
MAKE_BUFREADER_GET_FXN(v3s16, V3S16);
478+
MAKE_BUFREADER_GET_FXN(v2s32, V2S32);
479+
MAKE_BUFREADER_GET_FXN(v3s32, V3S32);
480+
MAKE_BUFREADER_GET_FXN(v2f, V2F1000);
481+
MAKE_BUFREADER_GET_FXN(v3f, V3F1000);
482+
MAKE_BUFREADER_GET_FXN(video::SColor, ARGB8);
483+
MAKE_BUFREADER_GET_FXN(std::string, String);
484+
MAKE_BUFREADER_GET_FXN(std::wstring, WideString);
485+
MAKE_BUFREADER_GET_FXN(std::string, LongString);
486+
487+
inline void getRawData(void *val, size_t len)
488+
{
489+
if (!getRawDataNoEx(val, len))
490+
throw eof_ser_err;
491+
}
492+
493+
inline size_t remaining()
494+
{
495+
assert(pos <= size);
496+
return size - pos;
497+
}
498+
499+
const u8 *data;
500+
size_t size;
501+
size_t pos;
502+
};
503+
504+
#undef MAKE_BUFREADER_GET_FXN
505+
#undef MAKE_BUFREADER_GETNOEX_FXN
506+
507+
508+
////
509+
//// Vector-based write routines
510+
////
511+
512+
inline void putU8(std::vector<u8> *dest, u8 val)
513+
{
514+
dest->push_back((val >> 0) & 0xFF);
515+
}
516+
517+
inline void putU16(std::vector<u8> *dest, u16 val)
518+
{
519+
dest->push_back((val >> 8) & 0xFF);
520+
dest->push_back((val >> 0) & 0xFF);
521+
}
522+
523+
inline void putU32(std::vector<u8> *dest, u32 val)
524+
{
525+
dest->push_back((val >> 24) & 0xFF);
526+
dest->push_back((val >> 16) & 0xFF);
527+
dest->push_back((val >> 8) & 0xFF);
528+
dest->push_back((val >> 0) & 0xFF);
529+
}
530+
531+
inline void putU64(std::vector<u8> *dest, u64 val)
532+
{
533+
dest->push_back((val >> 56) & 0xFF);
534+
dest->push_back((val >> 48) & 0xFF);
535+
dest->push_back((val >> 40) & 0xFF);
536+
dest->push_back((val >> 32) & 0xFF);
537+
dest->push_back((val >> 24) & 0xFF);
538+
dest->push_back((val >> 16) & 0xFF);
539+
dest->push_back((val >> 8) & 0xFF);
540+
dest->push_back((val >> 0) & 0xFF);
541+
}
542+
543+
inline void putS8(std::vector<u8> *dest, s8 val)
544+
{
545+
putU8(dest, val);
546+
}
547+
548+
inline void putS16(std::vector<u8> *dest, s16 val)
549+
{
550+
putU16(dest, val);
551+
}
552+
553+
inline void putS32(std::vector<u8> *dest, s32 val)
554+
{
555+
putU32(dest, val);
556+
}
557+
558+
inline void putS64(std::vector<u8> *dest, s64 val)
559+
{
560+
putU64(dest, val);
561+
}
562+
563+
inline void putF1000(std::vector<u8> *dest, f32 val)
564+
{
565+
putS32(dest, val * FIXEDPOINT_FACTOR);
566+
}
567+
568+
inline void putV2S16(std::vector<u8> *dest, v2s16 val)
569+
{
570+
putS16(dest, val.X);
571+
putS16(dest, val.Y);
572+
}
573+
574+
inline void putV3S16(std::vector<u8> *dest, v3s16 val)
575+
{
576+
putS16(dest, val.X);
577+
putS16(dest, val.Y);
578+
putS16(dest, val.Z);
579+
}
580+
581+
inline void putV2S32(std::vector<u8> *dest, v2s32 val)
582+
{
583+
putS32(dest, val.X);
584+
putS32(dest, val.Y);
585+
}
586+
587+
inline void putV3S32(std::vector<u8> *dest, v3s32 val)
588+
{
589+
putS32(dest, val.X);
590+
putS32(dest, val.Y);
591+
putS32(dest, val.Z);
592+
}
593+
594+
inline void putV2F1000(std::vector<u8> *dest, v2f val)
595+
{
596+
putF1000(dest, val.X);
597+
putF1000(dest, val.Y);
598+
}
599+
600+
inline void putV3F1000(std::vector<u8> *dest, v3f val)
601+
{
602+
putF1000(dest, val.X);
603+
putF1000(dest, val.Y);
604+
putF1000(dest, val.Z);
605+
}
606+
607+
inline void putARGB8(std::vector<u8> *dest, video::SColor val)
608+
{
609+
putU32(dest, val.color);
610+
}
611+
612+
inline void putString(std::vector<u8> *dest, const std::string &val)
613+
{
614+
if (val.size() > STRING_MAX_LEN)
615+
throw SerializationError("String too long");
616+
617+
putU16(dest, val.size());
618+
dest->insert(dest->end(), val.begin(), val.end());
619+
}
620+
621+
inline void putWideString(std::vector<u8> *dest, const std::wstring &val)
622+
{
623+
if (val.size() > WIDE_STRING_MAX_LEN)
624+
throw SerializationError("String too long");
625+
626+
putU16(dest, val.size());
627+
for (size_t i = 0; i != val.size(); i++)
628+
putU16(dest, val[i]);
629+
}
630+
631+
inline void putLongString(std::vector<u8> *dest, const std::string &val)
632+
{
633+
if (val.size() > LONG_STRING_MAX_LEN)
634+
throw SerializationError("String too long");
635+
636+
putU32(dest, val.size());
637+
dest->insert(dest->end(), val.begin(), val.end());
638+
}
639+
640+
inline void putRawData(std::vector<u8> *dest, const void *src, size_t len)
641+
{
642+
dest->insert(dest->end(), (u8 *)src, (u8 *)src + len);
643+
}
644+
408645
#endif

0 commit comments

Comments
 (0)
Please sign in to comment.