Usermode/Applications/axwin4_src/Common/serialisation.cpp

   1 /*
   2  * Acess2 GUI v4
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * serialisation.cpp
   6  * - IPC Serialisation
   7  */
   8 #include <serialisation.hpp>
   9 #include <cstddef>
  10 #include <stdexcept>
  11 #include <acess/sys.h>  // SysDebug
  12
  13 namespace AxWin {
  14
  15 CDeserialiser::CDeserialiser(size_t Length, const uint8_t *Buffer):
  16         m_length(Length),
  17         m_data(Buffer),
  18         m_offset(0)
  19 {
  20 }
  21
  22 bool CDeserialiser::IsConsumed() const
  23 {
  24         return m_offset == m_length;
  25 }
  26
  27 ::uint8_t CDeserialiser::ReadU8()
  28 {
  29         RangeCheck("CDeserialiser::ReadU8", 1);
  30         uint8_t rv = m_data[m_offset];
  31         m_offset ++;
  32         return rv;
  33 }
  34
  35 ::uint16_t CDeserialiser::ReadU16()
  36 {
  37         RangeCheck("CDeserialiser::ReadU16", 2);
  38         uint16_t rv = m_data[m_offset] | ((uint16_t)m_data[m_offset+1] << 8);
  39         m_offset += 2;
  40         return rv;
  41 }
  42
  43 ::int16_t CDeserialiser::ReadS16()
  44 {
  45         uint16_t rv_u = ReadU16();
  46         if( rv_u < 0x8000 )
  47                 return rv_u;
  48         else
  49                 return ~rv_u + 1;
  50 }
  51
  52 const ::std::string CDeserialiser::ReadString()
  53 {
  54         RangeCheck("CDeserialiser::ReadString(len)", 1);
  55         uint8_t len = m_data[m_offset];
  56         m_offset ++;
  57
  58         RangeCheck("CDeserialiser::ReadString(data)", len);
  59         ::std::string ret( reinterpret_cast<const char*>(m_data+m_offset), len );
  60         m_offset += len;
  61         return ret;
  62 }
  63
  64 void CDeserialiser::RangeCheck(const char *Method, size_t bytes) throw(::std::out_of_range)
  65 {
  66         if( m_offset + bytes > m_length ) {
  67                 ::_SysDebug("%s - out of range %i+%i >= %i", Method, m_offset, bytes, m_length);
  68                 throw ::std::out_of_range(Method);
  69         }
  70 }
  71
  72 CSerialiser::CSerialiser()
  73 {
  74 }
  75
  76 void CSerialiser::WriteU8(::uint8_t Value)
  77 {
  78         m_data.push_back(Value);
  79 }
  80
  81 void CSerialiser::WriteU16(::uint16_t Value)
  82 {
  83         m_data.push_back(Value & 0xFF);
  84         m_data.push_back(Value >> 8);
  85 }
  86
  87 void CSerialiser::WriteS16(::int16_t Value)
  88 {
  89         if( Value < 0 )
  90         {
  91                 ::uint16_t rawval = 0x10000 - (::int32_t)Value;
  92                 WriteU16(rawval);
  93         }
  94         else
  95         {
  96                 WriteU16(Value);
  97         }
  98 }
  99
 100 void CSerialiser::WriteBuffer(size_t n, const void* val)
 101 {
 102         const uint8_t*  val8 = static_cast<const uint8_t*>(val);
 103         if( n > 0xFFFF )
 104                 throw ::std::length_error("CSerialiser::WriteBuffer");
 105         m_data.reserve( m_data.size() + 2 + n );
 106         WriteU16(n);
 107         for( size_t i = 0; i < n; i ++ )
 108                 m_data.push_back(val8[i]);
 109 }
 110
 111 void CSerialiser::WriteString(const char* val, size_t n)
 112 {
 113         if( n > 0xFF )
 114                 throw ::std::length_error("CSerialiser::WriteString");
 115         m_data.reserve( m_data.size() + 1 + n );
 116         WriteU8(n);
 117         for( size_t i = 0; i < n; i ++ )
 118                 m_data.push_back(val[i]);
 119 }
 120
 121 void CSerialiser::WriteSub(const CSerialiser& val)
 122 {
 123         // TODO: Append reference to sub-buffer contents
 124         m_data.reserve( m_data.size() + val.m_data.size() );
 125         for( auto byte : val.m_data )
 126                 m_data.push_back( byte );
 127 }
 128
 129 const ::std::vector<uint8_t>& CSerialiser::Compact()
 130 {
 131         return m_data;
 132 }
 133
 134 };      // namespace AxWin
 135