/*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
#ifndef UTIL_SERIALIZE_HEADER
#define UTIL_SERIALIZE_HEADER
-#include "../irrlichttypes.h"
#include "../irrlichttypes_bloated.h"
-#include "../irr_v2d.h"
-#include "../irr_v3d.h"
+#include "config.h"
+#if HAVE_ENDIAN_H
+#include <endian.h>
+#include <string.h> // for memcpy
+#endif
#include <iostream>
#include <string>
-#include "../exceptions.h"
-#include "pointer.h"
+
+#define FIXEDPOINT_FACTOR 1000.0f
+#define FIXEDPOINT_INVFACTOR (1.0f/FIXEDPOINT_FACTOR)
+
+#if HAVE_ENDIAN_H
+// use machine native byte swapping routines
+// Note: memcpy below is optimized out by modern compilers
+
+inline void writeU64(u8* data, u64 i)
+{
+ u64 val = htobe64(i);
+ memcpy(data, &val, 8);
+}
+
+inline void writeU32(u8* data, u32 i)
+{
+ u32 val = htobe32(i);
+ memcpy(data, &val, 4);
+}
+
+inline void writeU16(u8* data, u16 i)
+{
+ u16 val = htobe16(i);
+ memcpy(data, &val, 2);
+}
+
+inline u64 readU64(const u8* data)
+{
+ u64 val;
+ memcpy(&val, data, 8);
+ return be64toh(val);
+}
+
+inline u32 readU32(const u8* data)
+{
+ u32 val;
+ memcpy(&val, data, 4);
+ return be32toh(val);
+}
+
+inline u16 readU16(const u8* data)
+{
+ u16 val;
+ memcpy(&val, data, 2);
+ return be16toh(val);
+}
+
+#else
+// generic byte-swapping implementation
inline void writeU64(u8 *data, u64 i)
{
data[1] = ((i>> 0)&0xff);
}
-inline void writeU8(u8 *data, u8 i)
-{
- data[0] = ((i>> 0)&0xff);
-}
-
inline u64 readU64(const u8 *data)
{
return ((u64)data[0]<<56) | ((u64)data[1]<<48)
return (data[0]<<8) | (data[1]<<0);
}
+#endif
+
+inline void writeU8(u8 *data, u8 i)
+{
+ data[0] = ((i>> 0)&0xff);
+}
+
inline u8 readU8(const u8 *data)
{
return (data[0]<<0);
}
inline void writeF1000(u8 *data, f32 i){
- writeS32(data, i*1000);
+ writeS32(data, i*FIXEDPOINT_FACTOR);
}
inline f32 readF1000(const u8 *data){
- return (f32)readS32(data)/1000.;
+ return (f32)readS32(data)*FIXEDPOINT_INVFACTOR;
}
inline void writeV3S32(u8 *data, v3s32 p)
inline void writeV2S32(u8 *data, v2s32 p)
{
writeS32(&data[0], p.X);
- writeS32(&data[2], p.Y);
+ writeS32(&data[4], p.Y);
}
inline v2s32 readV2S32(const u8 *data)
{
v2s32 p;
p.X = readS32(&data[0]);
- p.Y = readS32(&data[2]);
+ p.Y = readS32(&data[4]);
return p;
}
inline void writeARGB8(u8 *data, video::SColor p)
{
- writeU8(&data[0], p.getAlpha());
- writeU8(&data[1], p.getRed());
- writeU8(&data[2], p.getGreen());
- writeU8(&data[3], p.getBlue());
+ writeU32(data, p.color);
}
inline video::SColor readARGB8(const u8 *data)
{
- video::SColor p;
- p.setAlpha(readU8(&data[0]));
- p.setRed(readU8(&data[1]));
- p.setGreen(readU8(&data[2]));
- p.setBlue(readU8(&data[3]));
+ video::SColor p(readU32(data));
return p;
}
inline void writeU8(std::ostream &os, u8 p)
{
- char buf[1] = {0};
+ char buf[1];
writeU8((u8*)buf, p);
os.write(buf, 1);
}
inline void writeU16(std::ostream &os, u16 p)
{
- char buf[2] = {0};
+ char buf[2];
writeU16((u8*)buf, p);
os.write(buf, 2);
}
inline void writeU32(std::ostream &os, u32 p)
{
- char buf[4] = {0};
+ char buf[4];
writeU32((u8*)buf, p);
os.write(buf, 4);
}
inline void writeS32(std::ostream &os, s32 p)
{
- char buf[4] = {0};
- writeS32((u8*)buf, p);
- os.write(buf, 4);
+ writeU32(os, (u32) p);
}
inline s32 readS32(std::istream &is)
{
- char buf[4] = {0};
- is.read(buf, 4);
- return readS32((u8*)buf);
+ return (s32)readU32(is);
}
inline void writeS16(std::ostream &os, s16 p)
{
- char buf[2] = {0};
- writeS16((u8*)buf, p);
- os.write(buf, 2);
+ writeU16(os, (u16) p);
}
inline s16 readS16(std::istream &is)
{
- char buf[2] = {0};
- is.read(buf, 2);
- return readS16((u8*)buf);
+ return (s16)readU16(is);
}
inline void writeS8(std::ostream &os, s8 p)
{
- char buf[1] = {0};
- writeS8((u8*)buf, p);
- os.write(buf, 1);
+ writeU8(os, (u8) p);
}
inline s8 readS8(std::istream &is)
{
- char buf[1] = {0};
- is.read(buf, 1);
- return readS8((u8*)buf);
+ return (s8)readU8(is);
}
inline void writeF1000(std::ostream &os, f32 p)
{
- char buf[4] = {0};
+ char buf[4];
writeF1000((u8*)buf, p);
os.write(buf, 4);
}
inline void writeV2F1000(std::ostream &os, v2f p)
{
- char buf[8] = {0};
+ char buf[8];
writeV2F1000((u8*)buf, p);
os.write(buf, 8);
}
inline void writeV2S16(std::ostream &os, v2s16 p)
{
- char buf[4] = {0};
+ char buf[4];
writeV2S16((u8*)buf, p);
os.write(buf, 4);
}
return readV2S16((u8*)buf);
}
+inline void writeV2S32(std::ostream &os, v2s32 p)
+{
+ char buf[8];
+ writeV2S32((u8*)buf, p);
+ os.write(buf, 8);
+}
+inline v2s32 readV2S32(std::istream &is)
+{
+ char buf[8] = {0};
+ is.read(buf, 8);
+ return readV2S32((u8*)buf);
+}
+
inline void writeV3S16(std::ostream &os, v3s16 p)
{
- char buf[6] = {0};
+ char buf[6];
writeV3S16((u8*)buf, p);
os.write(buf, 6);
}
inline void writeARGB8(std::ostream &os, video::SColor p)
{
- char buf[4] = {0};
+ char buf[4];
writeARGB8((u8*)buf, p);
os.write(buf, 4);
}
*/
// Creates a string with the length as the first two bytes
-inline std::string serializeString(const std::string &plain)
-{
- //assert(plain.size() <= 65535);
- if(plain.size() > 65535)
- throw SerializationError("String too long for serializeString");
- char buf[2];
- writeU16((u8*)&buf[0], plain.size());
- std::string s;
- s.append(buf, 2);
- s.append(plain);
- return s;
-}
+std::string serializeString(const std::string &plain);
// Creates a string with the length as the first two bytes from wide string
-inline std::string serializeWideString(const std::wstring &plain)
-{
- //assert(plain.size() <= 65535);
- if(plain.size() > 65535)
- throw SerializationError("String too long for serializeString");
- char buf[2];
- writeU16((u8*)buf, plain.size());
- std::string s;
- s.append(buf, 2);
- for(u32 i=0; i<plain.size(); i++)
- {
- writeU16((u8*)buf, plain[i]);
- s.append(buf, 2);
- }
- return s;
-}
+std::string serializeWideString(const std::wstring &plain);
// Reads a string with the length as the first two bytes
-inline std::string deSerializeString(std::istream &is)
-{
- char buf[2];
- is.read(buf, 2);
- if(is.gcount() != 2)
- throw SerializationError("deSerializeString: size not read");
- u16 s_size = readU16((u8*)buf);
- if(s_size == 0)
- return "";
- Buffer<char> buf2(s_size);
- is.read(&buf2[0], s_size);
- std::string s;
- s.reserve(s_size);
- s.append(&buf2[0], s_size);
- return s;
-}
+std::string deSerializeString(std::istream &is);
// Reads a wide string with the length as the first two bytes
-inline std::wstring deSerializeWideString(std::istream &is)
-{
- char buf[2];
- is.read(buf, 2);
- if(is.gcount() != 2)
- throw SerializationError("deSerializeString: size not read");
- u16 s_size = readU16((u8*)buf);
- if(s_size == 0)
- return L"";
- std::wstring s;
- s.reserve(s_size);
- for(u32 i=0; i<s_size; i++)
- {
- is.read(&buf[0], 2);
- wchar_t c16 = readU16((u8*)buf);
- s.append(&c16, 1);
- }
- return s;
-}
+std::wstring deSerializeWideString(std::istream &is);
// Creates a string with the length as the first four bytes
-inline std::string serializeLongString(const std::string &plain)
-{
- char buf[4];
- writeU32((u8*)&buf[0], plain.size());
- std::string s;
- s.append(buf, 4);
- s.append(plain);
- return s;
-}
+std::string serializeLongString(const std::string &plain);
// Reads a string with the length as the first four bytes
-inline std::string deSerializeLongString(std::istream &is)
-{
- char buf[4];
- is.read(buf, 4);
- if(is.gcount() != 4)
- throw SerializationError("deSerializeLongString: size not read");
- u32 s_size = readU32((u8*)buf);
- if(s_size == 0)
- return "";
- Buffer<char> buf2(s_size);
- is.read(&buf2[0], s_size);
- std::string s;
- s.reserve(s_size);
- s.append(&buf2[0], s_size);
- return s;
-}
+std::string deSerializeLongString(std::istream &is);
// Creates a string encoded in JSON format (almost equivalent to a C string literal)
std::string serializeJsonString(const std::string &plain);
// Reads a string encoded in JSON format
std::string deSerializeJsonString(std::istream &is);
+// Creates a string containing comma delimited values of a struct whose layout is
+// described by the parameter format
+bool serializeStructToString(std::string *out,
+ std::string format, void *value);
+
+// Reads a comma delimited string of values into a struct whose layout is
+// decribed by the parameter format
+bool deSerializeStringToStruct(std::string valstr,
+ std::string format, void *out, size_t olen);
+
#endif
projects / minetest.git / blobdiff