WireFormatter.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2020 Embedded AMS B.V. - All Rights Reserved
 *
 *  This file is part of Embedded Proto.
 *
 *  Embedded Proto is open source software: you can redistribute it and/or 
 *  modify it under the terms of the GNU General Public License as published 
 *  by the Free Software Foundation, version 3 of the license.
 *
 *  Embedded Proto  is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Embedded Proto. If not, see <https://www.gnu.org/licenses/>.
 *
 *  For commercial and closed source application please visit:
 *  <https://EmbeddedProto.com/license/>.
 *
 *  Embedded AMS B.V.
 *  Info:
 *    info at EmbeddedProto dot com
 *
 *  Postal address:
 *    Johan Huizingalaan 763a
 *    1066 VH, Amsterdam
 *    the Netherlands
 */
 
#ifndef _WIRE_FORMATTER_H_
#define _WIRE_FORMATTER_H_
 
#include "WriteBufferInterface.h"
#include "ReadBufferInterface.h"
#include "Errors.h"
 
#include <cstdint>
#include <math.h> 
#include <type_traits>
#include <limits>
 
 
namespace EmbeddedProto 
{
 
  class WireFormatter 
  {
 
      static constexpr uint8_t VARINT_SHIFT_N_BITS = 7;
 
      static constexpr uint8_t VARINT_MSB_BYTE = 0x80;
 
 
      static constexpr int32_t constexpr_ceil(float num)
      {
          return (static_cast<float>(static_cast<int32_t>(num)) == num)
              ? static_cast<int32_t>(num)
              : static_cast<int32_t>(num) + ((num > 0) ? 1 : 0);
      }
 
    public:
      enum class WireType 
      {
        VARINT            = 0,  
        FIXED64           = 1,  
        LENGTH_DELIMITED  = 2,  
        START_GROUP       = 3,  
        END_GROUP         = 4,  
        FIXED32           = 5,  
      };
 
 
      template<class INT_TYPE>
      static constexpr auto ZigZagEncode(const INT_TYPE n) 
      {
        static_assert(std::is_same<INT_TYPE, int32_t>::value || 
                      std::is_same<INT_TYPE, int64_t>::value, "Wrong type passed to ZigZagEncode.");
 
        typedef typename std::make_unsigned<INT_TYPE>::type UINT_TYPE;
        constexpr uint8_t N_BITS_TO_ZIGZAG = std::numeric_limits<UINT_TYPE>::digits - 1;
 
        return (static_cast<UINT_TYPE>(n) << 1) ^ static_cast<UINT_TYPE>(n >> N_BITS_TO_ZIGZAG);
      }
 
 
      template<class UINT_TYPE>
      static constexpr auto ZigZagDecode(const UINT_TYPE n) 
      {
        static_assert(std::is_same<UINT_TYPE, uint32_t>::value || 
                      std::is_same<UINT_TYPE, uint64_t>::value, "Wrong type passed to ZigZagDecode.");
 
        typedef typename std::make_signed<UINT_TYPE>::type INT_TYPE;
 
        return static_cast<INT_TYPE>((n >> 1) ^ (~(n & 1) + 1));
      }
 
 
      static constexpr uint32_t MakeTag(const uint32_t field_number, const WireType type)
      {
        return ((field_number << 3) | static_cast<uint32_t>(type));
      }
 
      template<class UINT_TYPE>
      static Error SerialzieFixedNoTag(UINT_TYPE value, WriteBufferInterface& buffer) 
      {
        static_assert(std::is_same<UINT_TYPE, uint32_t>::value || 
                      std::is_same<UINT_TYPE, uint64_t>::value, "Wrong type passed to SerialzieFixedNoTag.");
 
        // Push the data little endian to the buffer.
        // TODO Define a little endian flag to support memcpy the data to the buffer.
 
        bool result = true;
 
        // Loop over all bytes in the integer.
        for(uint8_t i = 0; (i < std::numeric_limits<UINT_TYPE>::digits) && result; i += 8) {
          // Shift the value using the current value of i.
          result = buffer.push(static_cast<uint8_t>((value >> i) & 0x00FF));
        }
        return result ? Error::NO_ERRORS : Error::BUFFER_FULL;
      }
 
      template<class INT_TYPE>
      static Error SerialzieSFixedNoTag(INT_TYPE value, WriteBufferInterface& buffer)
      {
        static_assert(std::is_same<INT_TYPE, int32_t>::value || 
                      std::is_same<INT_TYPE, int64_t>::value, "Wrong type passed to SerialzieSFixedNoTag.");
 
        typedef typename std::make_unsigned<INT_TYPE>::type UINT_TYPE;
 
        return SerialzieFixedNoTag(static_cast<UINT_TYPE>(value), buffer);
      }
 
      static Error SerialzieFloatNoTag(float value, WriteBufferInterface& buffer)
      {
        // Cast the type to void and to a 32 fixed number
        void* pVoid = static_cast<void*>(&value);
        uint32_t* fixed = static_cast<uint32_t*>(pVoid);
        return SerialzieFixedNoTag(*fixed, buffer);
      }
 
      static Error SerialzieDoubleNoTag(double value, WriteBufferInterface& buffer)
      {
        // Cast the type to void and to a 64 fixed number
        void* pVoid = static_cast<void*>(&value);
        uint64_t* fixed = static_cast<uint64_t*>(pVoid);
        return SerialzieFixedNoTag(*fixed, buffer);
      }
      template<class INT_TYPE>
      static Error SerializeInt(uint32_t field_number, INT_TYPE value, WriteBufferInterface& buffer)
      {        
        typedef typename std::make_unsigned<INT_TYPE>::type UINT_TYPE;
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::VARINT), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerializeVarint(static_cast<UINT_TYPE>(value), buffer);
        }
        return return_value;
      }
 
      template<class UINT_TYPE>
      static Error SerializeUInt(uint32_t field_number, UINT_TYPE value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::VARINT), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerializeVarint(value, buffer);
        }
        return return_value;
      }
 
      template<class INT_TYPE>
      static Error SerializeSInt(uint32_t field_number, INT_TYPE value, WriteBufferInterface& buffer)
      {
         Error return_value = SerializeVarint(MakeTag(field_number, WireType::VARINT), buffer);
         if(Error::NO_ERRORS == return_value)
        {
          return_value = SerializeVarint(ZigZagEncode(value), buffer);
        }
        return return_value;
      }
      
      static Error SerializeFixed(uint32_t field_number, uint32_t value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::FIXED32), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerialzieFixedNoTag(value, buffer);
        }
        return return_value;
      }
 
      static Error SerializeFixed(uint32_t field_number, uint64_t value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::FIXED64), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerialzieFixedNoTag(value, buffer);
        }
        return return_value;
      }
 
      static Error SerializeSFixed(uint32_t field_number, int32_t value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::FIXED32), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerialzieSFixedNoTag(value, buffer);
        }
        return return_value;
      }
 
      static Error SerializeSFixed(uint32_t field_number, int64_t value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::FIXED64), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerialzieSFixedNoTag(value, buffer);
        }
        return return_value;
      }
 
      static Error SerializeFloat(uint32_t field_number, float value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::FIXED32), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerialzieFloatNoTag(value, buffer);
        }
        return return_value;
      }
 
      static Error SerializeDouble(uint32_t field_number, double value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::FIXED64), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerialzieDoubleNoTag(value, buffer);
        }
        return return_value;
      }
 
      static Error SerializeBool(uint32_t field_number, bool value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::VARINT), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          const uint8_t byte = value ? 0x01 : 0x00;
          return_value = buffer.push(byte) ? Error::NO_ERRORS : Error::BUFFER_FULL;
        }
        return return_value;
      }
 
      static Error SerializeEnum(uint32_t field_number, uint32_t value, WriteBufferInterface& buffer)
      {
        Error return_value = SerializeVarint(MakeTag(field_number, WireType::VARINT), buffer);
        if(Error::NO_ERRORS == return_value)
        {
          return_value = SerializeVarint(value, buffer);
        }
        return return_value;
      }
 
 
      static Error DeserializeTag(ReadBufferInterface& buffer, WireType& type, uint32_t& id) 
      {
        uint32_t temp_value;
        // Read the next varint considered to be a tag.
        Error return_value = DeserializeVarint(buffer, temp_value);
        
        if(Error::NO_ERRORS == return_value) 
        {
          // Next check the validity of the wire type.
          if((temp_value &  0x07) <= static_cast<uint32_t>(WireType::FIXED32))
          {
            // If reading the tag succeeded and the wire type is a valid one.
            type = static_cast<WireType>(temp_value &  0x07);
            id = (temp_value >> 3);
          }
          else 
          {
            return_value = Error::INVALID_WIRETYPE;
          }
        }
        return return_value;
      }
 
      template<class UINT_TYPE>
      static Error DeserializeUInt(ReadBufferInterface& buffer, UINT_TYPE& value) 
      {
        static_assert(std::is_same<UINT_TYPE, uint32_t>::value || 
                      std::is_same<UINT_TYPE, uint64_t>::value, "Wrong type passed to DeserializeUInt.");
        
        return DeserializeVarint(buffer, value);
      }
 
      template<class INT_TYPE>
      static Error DeserializeInt(ReadBufferInterface& buffer, INT_TYPE& value) 
      {
        static_assert(std::is_same<INT_TYPE, int32_t>::value || 
                      std::is_same<INT_TYPE, int64_t>::value, "Wrong type passed to DeserializeInt.");
        
        uint64_t uint_value;
        Error result = DeserializeVarint(buffer, uint_value);
        if(Error::NO_ERRORS == result) 
        {
          value = static_cast<INT_TYPE>(uint_value);
        }
        return result;
      }
 
      template<class INT_TYPE>
      static Error DeserializeSInt(ReadBufferInterface& buffer, INT_TYPE& value) 
      {
        static_assert(std::is_same<INT_TYPE, int32_t>::value || 
                      std::is_same<INT_TYPE, int64_t>::value, "Wrong type passed to DeserializeSInt.");
        
        uint64_t uint_value;
        Error result = DeserializeVarint(buffer, uint_value);
        if(Error::NO_ERRORS == result) 
        {
          value = ZigZagDecode(uint_value);
        }
        return result;
      }
 
      template<class TYPE>
      static Error DeserializeFixed(ReadBufferInterface& buffer, TYPE& value) 
      {
        static_assert(std::is_same<TYPE, uint32_t>::value || 
                      std::is_same<TYPE, uint64_t>::value, "Wrong type passed to DeserializeFixed.");
 
        // Deserialize the data little endian to the buffer.
        // TODO Define a little endian flag to support memcpy the data from the buffer.
 
        TYPE temp_value = 0;
        bool result(true);
        uint8_t byte = 0;
        for(uint8_t i = 0; (i < std::numeric_limits<TYPE>::digits) && result; 
            i += std::numeric_limits<uint8_t>::digits)  
        {
          result = buffer.pop(byte);
          if(result)
          {
            temp_value |= (static_cast<TYPE>(byte) << i);
          }
        }
 
        Error return_value = Error::NO_ERRORS;
        if(result)
        {
          value = temp_value;
        }
        else 
        {
          return_value = Error::END_OF_BUFFER;
        }
 
        return return_value;
      }
 
      template<class STYPE>
      static Error DeserializeSFixed(ReadBufferInterface& buffer, STYPE& value) 
      {
        static_assert(std::is_same<STYPE, int32_t>::value || 
                      std::is_same<STYPE, int64_t>::value, "Wrong type passed to DeserializeSFixed.");
 
        typedef typename std::make_unsigned<STYPE>::type USTYPE;
        USTYPE temp_unsigned_value = 0;
        Error result = DeserializeFixed(buffer, temp_unsigned_value);
        if(Error::NO_ERRORS == result)
        {
          value = static_cast<STYPE>(temp_unsigned_value);
        }
 
        return result;
      }
 
      static Error DeserializeFloat(ReadBufferInterface& buffer, float& value) 
      {
        uint32_t temp_value = 0;
        Error result = DeserializeFixed(buffer, temp_value);
        if(Error::NO_ERRORS == result) 
        {
          // Cast from unsigned int to a float.
          const void* pVoid = static_cast<const void*>(&temp_value);
          const float* pFloat = static_cast<const float*>(pVoid);
          value = *pFloat;
        }
        return result;
      }
 
      static Error DeserializeDouble(ReadBufferInterface& buffer, double& value) 
      {
        uint64_t temp_value = 0;
        Error result = DeserializeFixed(buffer, temp_value);
        if(Error::NO_ERRORS == result) 
        {
          // Cast from unsigned int to a double.
          const void* pVoid = static_cast<const void*>(&temp_value);
          const double* pDouble = static_cast<const double*>(pVoid);
          value = *pDouble;
        }
        return result;
      }
 
      static Error DeserializeBool(ReadBufferInterface& buffer, bool& value) 
      {
        uint8_t byte;
        Error result = Error::NO_ERRORS;
        if(buffer.pop(byte))
        {
          value = static_cast<bool>(byte);
        }
        else 
        {
          result = Error::END_OF_BUFFER;
        }
        return result;
      }
 
      template<class ENUM_TYPE>
      static Error DeserializeEnum(ReadBufferInterface& buffer, ENUM_TYPE& value) 
      {
        static_assert(std::is_enum<ENUM_TYPE>::value, "No enum given to DeserializeEnum parameter value.");
        uint64_t temp_value;
        Error result = DeserializeVarint(buffer, temp_value);
        if(Error::NO_ERRORS == result)
        {
          value = static_cast<ENUM_TYPE>(temp_value);
        }
        return result;
      }
 
 
 
      template<class UINT_TYPE>
      static Error SerializeVarint(UINT_TYPE value, WriteBufferInterface& buffer) 
      {
        static_assert(std::is_same<UINT_TYPE, uint32_t>::value || 
                      std::is_same<UINT_TYPE, uint64_t>::value, 
                      "Wrong type passed to SerializeVarint.");
 
        bool memory_free = true;
        while((value >= VARINT_MSB_BYTE) && memory_free) 
        {
          memory_free = buffer.push(static_cast<uint8_t>(value | VARINT_MSB_BYTE));
          value >>= VARINT_SHIFT_N_BITS;
        }
        memory_free = buffer.push(static_cast<uint8_t>(value));
 
        const Error return_value = memory_free ? Error::NO_ERRORS : Error::BUFFER_FULL;
        return return_value;
      }
 
 
      template<class UINT_TYPE>
      static Error DeserializeVarint(ReadBufferInterface& buffer, UINT_TYPE& value) 
      {
        static_assert(std::is_same<UINT_TYPE, uint32_t>::value || 
                      std::is_same<UINT_TYPE, uint64_t>::value, 
                      "Wrong type passed to DeserializeVarint.");
        
        // Calculate how many bytes there are in a varint 128 base encoded number. This should 
        // yield 5 for a 32bit number and 10 for a 64bit number.
        static constexpr uint8_t N_BYTES_IN_VARINT = static_cast<uint8_t>(constexpr_ceil(
                                                          std::numeric_limits<UINT_TYPE>::digits 
                                                        / static_cast<float>(VARINT_SHIFT_N_BITS)));
        
        UINT_TYPE temp_value = 0;
        uint8_t byte = 0;
        bool result = buffer.pop(byte);
        // Loop until the end of the encoded varint or until there is no more data in the buffer.
        for(uint8_t i = 0; (i < N_BYTES_IN_VARINT) && result; ++i) 
        {
          temp_value |= static_cast<UINT_TYPE>(byte & (~VARINT_MSB_BYTE)) << (i * VARINT_SHIFT_N_BITS);
          if(byte & VARINT_MSB_BYTE) 
          {
            // Continue
            result = buffer.pop(byte);
          }
          else
          {
            // The varint is complete
            break;
          }
        }
 
        Error return_value = Error::NO_ERRORS;
        if(result)
        {
          value = temp_value;
        }
        else 
        {
          return_value = Error::END_OF_BUFFER;
        }
 
        return return_value;
      }
 
 
  };
 
} // End of namespace EmbeddedProto.
#endif