/*
-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 <iostream>
#include <string>
-#include "../exceptions.h"
-#include "pointer.h"
inline void writeU64(u8 *data, u64 i)
{
data[0] = ((i>> 0)&0xff);
}
-inline u64 readU64(u8 *data)
+inline u64 readU64(const u8 *data)
{
return ((u64)data[0]<<56) | ((u64)data[1]<<48)
| ((u64)data[2]<<40) | ((u64)data[3]<<32)
| ((u64)data[6]<<8) | ((u64)data[7]<<0);
}
-inline u32 readU32(u8 *data)
+inline u32 readU32(const u8 *data)
{
return (data[0]<<24) | (data[1]<<16) | (data[2]<<8) | (data[3]<<0);
}
-inline u16 readU16(u8 *data)
+inline u16 readU16(const u8 *data)
{
return (data[0]<<8) | (data[1]<<0);
}
-inline u8 readU8(u8 *data)
+inline u8 readU8(const u8 *data)
{
return (data[0]<<0);
}
inline void writeS32(u8 *data, s32 i){
writeU32(data, (u32)i);
}
-inline s32 readS32(u8 *data){
+inline s32 readS32(const u8 *data){
return (s32)readU32(data);
}
inline void writeS16(u8 *data, s16 i){
writeU16(data, (u16)i);
}
-inline s16 readS16(u8 *data){
+inline s16 readS16(const u8 *data){
return (s16)readU16(data);
}
inline void writeS8(u8 *data, s8 i){
writeU8(data, (u8)i);
}
-inline s8 readS8(u8 *data){
+inline s8 readS8(const u8 *data){
return (s8)readU8(data);
}
inline void writeF1000(u8 *data, f32 i){
writeS32(data, i*1000);
}
-inline f32 readF1000(u8 *data){
+inline f32 readF1000(const u8 *data){
return (f32)readS32(data)/1000.;
}
writeS32(&data[4], p.Y);
writeS32(&data[8], p.Z);
}
-inline v3s32 readV3S32(u8 *data)
+inline v3s32 readV3S32(const u8 *data)
{
v3s32 p;
p.X = readS32(&data[0]);
writeF1000(&data[4], p.Y);
writeF1000(&data[8], p.Z);
}
-inline v3f readV3F1000(u8 *data)
+inline v3f readV3F1000(const u8 *data)
{
v3f p;
p.X = (float)readF1000(&data[0]);
writeF1000(&data[0], p.X);
writeF1000(&data[4], p.Y);
}
-inline v2f readV2F1000(u8 *data)
+inline v2f readV2F1000(const u8 *data)
{
v2f p;
p.X = (float)readF1000(&data[0]);
writeS16(&data[2], p.Y);
}
-inline v2s16 readV2S16(u8 *data)
+inline v2s16 readV2S16(const u8 *data)
{
v2s16 p;
p.X = readS16(&data[0]);
writeS32(&data[2], p.Y);
}
-inline v2s32 readV2S32(u8 *data)
+inline v2s32 readV2S32(const u8 *data)
{
v2s32 p;
p.X = readS32(&data[0]);
writeS16(&data[4], p.Z);
}
-inline v3s16 readV3S16(u8 *data)
+inline v3s16 readV3S16(const u8 *data)
{
v3s16 p;
p.X = readS16(&data[0]);
writeU8(&data[3], p.getBlue());
}
-inline video::SColor readARGB8(u8 *data)
+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(
+ readU8(&data[0]),
+ readU8(&data[1]),
+ readU8(&data[2]),
+ readU8(&data[3])
+ );
return p;
}
*/
// 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);
projects / dragonfireclient.git / blobdiff