include/library/serialization.hpp

   1 #ifndef _library__serialization__hpp__included__
   2 #define _library__serialization__hpp__included__
   3
   4 #include <cstdint>
   5 #include <cstdlib>
   6 #include <map>
   7
   8 namespace serialization
   9 {
  10 template<size_t n> struct unsigned_of {};
  11 template<> struct unsigned_of<1> { typedef uint8_t t; };
  12 template<> struct unsigned_of<2> { typedef uint16_t t; };
  13 template<> struct unsigned_of<4> { typedef uint32_t t; };
  14 template<> struct unsigned_of<8> { typedef uint64_t t; };
  15
  16 template<typename T1, bool be>
  17 void write_common(uint8_t* target, T1 value)
  18 {
  19         for(size_t i = 0; i < sizeof(T1); i++)
  20                 if(be)
  21                         target[i] = static_cast<typename unsigned_of<sizeof(T1)>::t>(value) >> 8 * (sizeof(T1) - i - 1);
  22                 else
  23                         target[i] = static_cast<typename unsigned_of<sizeof(T1)>::t>(value) >> 8 * i;
  24 }
  25
  26 template<typename T1, bool be>
  27 T1 read_common(const uint8_t* source)
  28 {
  29         typename unsigned_of<sizeof(T1)>::t value = 0;
  30         for(size_t i = 0; i < sizeof(T1); i++)
  31                 if(be)
  32                         value |= static_cast<typename unsigned_of<sizeof(T1)>::t>(source[i]) << 8 * (sizeof(T1) - i - 1);
  33                 else
  34                         value |= static_cast<typename unsigned_of<sizeof(T1)>::t>(source[i]) << 8 * i;
  35         return static_cast<T1>(value);
  36 }
  37
  38 inline void s8b(void* t, int8_t v)
  39 {
  40         write_common< int8_t, true>(reinterpret_cast<uint8_t*>(t), v);
  41 }
  42 inline void s8l(void* t, int8_t v)
  43 {
  44         write_common< int8_t, false>(reinterpret_cast<uint8_t*>(t), v);
  45 }
  46 inline void u8b(void* t, uint8_t v)
  47 {
  48         write_common< uint8_t, true>(reinterpret_cast<uint8_t*>(t), v);
  49 }
  50 inline void u8l(void* t, uint8_t v)
  51 {
  52         write_common< uint8_t, false>(reinterpret_cast<uint8_t*>(t), v);
  53 }
  54 inline void s16b(void* t, int16_t v)
  55 {
  56         write_common< int16_t, true>(reinterpret_cast<uint8_t*>(t), v);
  57 }
  58 inline void s16l(void* t, int16_t v)
  59 {
  60         write_common< int16_t, false>(reinterpret_cast<uint8_t*>(t), v);
  61 }
  62 inline void u16b(void* t, uint16_t v)
  63 {
  64         write_common<uint16_t, true>(reinterpret_cast<uint8_t*>(t), v);
  65 }
  66 inline void u16l(void* t, uint16_t v)
  67 {
  68         write_common<uint16_t, false>(reinterpret_cast<uint8_t*>(t), v);
  69 }
  70 inline void s32b(void* t, int32_t v)
  71 {
  72         write_common< int32_t, true>(reinterpret_cast<uint8_t*>(t), v);
  73 }
  74 inline void s32l(void* t, int32_t v)
  75 {
  76         write_common< int32_t, false>(reinterpret_cast<uint8_t*>(t), v);
  77 }
  78 inline void u32b(void* t, uint32_t v)
  79 {
  80         write_common<uint32_t, true>(reinterpret_cast<uint8_t*>(t), v);
  81 }
  82 inline void u32l(void* t, uint32_t v)
  83 {
  84         write_common<uint32_t, false>(reinterpret_cast<uint8_t*>(t), v);
  85 }
  86 inline void s64b(void* t, int64_t v)
  87 {
  88         write_common< int64_t, true>(reinterpret_cast<uint8_t*>(t), v);
  89 }
  90 inline void s64l(void* t, int64_t v)
  91 {
  92         write_common< int64_t, false>(reinterpret_cast<uint8_t*>(t), v);
  93 }
  94 inline void u64b(void* t, uint64_t v)
  95 {
  96         write_common<uint64_t, true>(reinterpret_cast<uint8_t*>(t), v);
  97 }
  98 inline void u64l(void* t, uint64_t v)
  99 {
 100         write_common<uint64_t, false>(reinterpret_cast<uint8_t*>(t), v);
 101 }
 102 inline int8_t s8b(const void* t)
 103 {
 104         return read_common< int8_t, true>(reinterpret_cast<const uint8_t*>(t));
 105 }
 106 inline int8_t s8l(const void* t)
 107 {
 108         return read_common< int8_t, false>(reinterpret_cast<const uint8_t*>(t));
 109 }
 110 inline uint8_t u8b(const void* t)
 111 {
 112         return read_common< uint8_t, true>(reinterpret_cast<const uint8_t*>(t));
 113 }
 114 inline uint8_t u8l(const void* t)
 115 {
 116         return read_common< uint8_t, false>(reinterpret_cast<const uint8_t*>(t));
 117 }
 118 inline int16_t s16b(const void* t)
 119 {
 120         return read_common< int16_t, true>(reinterpret_cast<const uint8_t*>(t));
 121 }
 122 inline int16_t s16l(const void* t)
 123 {
 124         return read_common< int16_t, false>(reinterpret_cast<const uint8_t*>(t));
 125 }
 126 inline uint16_t u16b(const void* t)
 127 {
 128         return read_common<uint16_t, true>(reinterpret_cast<const uint8_t*>(t));
 129 }
 130 inline uint16_t u16l(const void* t)
 131 {
 132         return read_common<uint16_t, false>(reinterpret_cast<const uint8_t*>(t));
 133 }
 134 inline int32_t s32b(const void* t)
 135 {
 136         return read_common< int32_t, true>(reinterpret_cast<const uint8_t*>(t));
 137 }
 138 inline int32_t s32l(const void* t)
 139 {
 140         return read_common< int32_t, false>(reinterpret_cast<const uint8_t*>(t));
 141 }
 142 inline uint32_t u32b(const void* t)
 143 {
 144         return read_common<uint32_t, true>(reinterpret_cast<const uint8_t*>(t));
 145 }
 146 inline uint32_t u32l(const void* t)
 147 {
 148         return read_common<uint32_t, false>(reinterpret_cast<const uint8_t*>(t));
 149 }
 150 inline int64_t s64b(const void* t)
 151 {
 152         return read_common< int64_t, true>(reinterpret_cast<const uint8_t*>(t));
 153 }
 154 inline int64_t s64l(const void* t)
 155 {
 156         return read_common< int64_t, false>(reinterpret_cast<const uint8_t*>(t));
 157 }
 158 inline uint64_t u64b(const void* t)
 159 {
 160         return read_common<uint64_t, true>(reinterpret_cast<const uint8_t*>(t));
 161 }
 162 inline uint64_t u64l(const void* t)
 163 {
 164         return read_common<uint64_t, false>(reinterpret_cast<const uint8_t*>(t));
 165 }
 166
 167 template<typename T> void swap_endian(T& value)
 168 {
 169         char* _value = reinterpret_cast<char*>(&value);
 170         for(size_t i = 0; i < sizeof(T)/2; i++)
 171                 std::swap(_value[i], _value[sizeof(T)-i-1]);
 172 }
 173
 174 template<typename T> void swap_endian(T& value, int endian)
 175 {
 176         short _magic = 258;
 177         char magic = *reinterpret_cast<char*>(&_magic);
 178         bool do_swap = (endian == -1 && magic == 1) || (endian == 1 && magic == 2);
 179         if(do_swap)
 180                 swap_endian(value);
 181 }
 182
 183 template<typename T> T read_endian(const void* value, int endian)
 184 {
 185         T val;
 186         memcpy(&val, value, sizeof(T));
 187         swap_endian(val, endian);
 188         return val;
 189 }
 190
 191 template<typename T> void write_endian(void* value, const T& val, int endian)
 192 {
 193         memcpy(value, &val, sizeof(T));
 194         swap_endian(*reinterpret_cast<T*>(value), endian);
 195 }
 196 }
 197
 198 #endif