EmbeddedProto 4.0.0b1__py3-none-any.whl

EmbeddedProto/src/EmbeddedProto/Fields.h

@@ -0,0 +1,832 @@
+/*
+ *  Copyright (C) 2020-2026 Embedded AMS B.V. - All Rights Reserved
+ *
+ *  This file is part of Embedded Proto.
+ *
+ *  Embedded Proto is dual licensed. You may use it under the terms of the
+ *  GNU General Public License version 3 (GPLv3) as published by the Free
+ *  Software Foundation, or under a commercial license from Embedded AMS B.V.
+ *
+ *  Under the GPLv3 you must release the source code of
+ *  any product you distribute that includes Embedded Proto or code
+ *  generated by it. A commercial license removes that obligation.
+ *  See <https://embeddedproto.com/pricing/>.
+ *
+ *  Embedded Proto is distributed WITHOUT ANY WARRANTY; without even the
+ *  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the LICENSE file in the root of the repository for details.
+ *
+ *  SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-EmbeddedProto-Commercial
+ *
+ *  Embedded AMS B.V., Hoorn, the Netherlands - info at EmbeddedProto dot com
+ */
+
+#ifndef _FIELDS_H_
+#define _FIELDS_H_
+
+#include "Errors.h"
+#include "Defines.h"
+#include "WireFormatter.h"
+#include "WriteBufferInterface.h"
+#include "ReadBufferInterface.h"
+#include "MessageSizeCalculator.h"
+#include "MessageState.h"
+
+#include <cstdint>
+
+#ifdef MSG_TO_STRING
+#include <cstdio>
+#endif
+
+namespace EmbeddedProto 
+{
+
+  class Field 
+  {
+    public:
+      enum class FieldTypes
+      {
+        int32,
+        int64, 
+        uint32, 
+        uint64, 
+        sint32, 
+        sint64, 
+        boolean, 
+        enumeration,
+        fixed64, 
+        sfixed64, 
+        doublefixed,
+        string, 
+        bytes, 
+        message,
+        repeated,
+        fixed32, 
+        sfixed32, 
+        floatfixed
+      };
+
+
+      Field() = default;
+
+#ifdef VIRTUAL_DESTRUCTORS_ENABLED
+      virtual ~Field() = default;
+#else
+    protected:
+      //! Protected and non-virtual by default, see VIRTUAL_DESTRUCTORS_ENABLED in Defines.h.
+      ~Field() = default;
+
+    public:
+#endif
+
+      virtual Error serialize(WriteBufferInterface& buffer) const = 0;
+
+      //! Deserialize this field from the bytes in the given buffer.
+      /*!
+        \param buffer data from which the field should be obtained.
+        \return NO_ERROR if everything went ok.
+      */      
+      virtual Error deserialize(ReadBufferInterface& buffer) = 0;
+
+      //! Deserialize this field but also check if given wire type matches the field type.
+      /*!
+        \param buffer data from which the field should be obtained.
+        \param wire_type The wire type obtained from the tag used to match with this field type.
+        \return NO_ERROR if everything went ok.
+      */
+      virtual Error deserialize_check_type(ReadBufferInterface& buffer,
+                                           const ::EmbeddedProto::WireFormatter::WireType& wire_type) = 0;
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+      //! Serialize this field with partial state support for LENGTH_DELIMITED fields.
+      /*!
+          Handles TAG->SIZE->DATA state machine for length-delimited field types.
+          \param field_number The field number for the tag.
+          \param buffer The buffer to write to.
+          \param state External state object tracking serialization progress.
+          \param optional If true, serialize even if size is zero.
+          \return NO_ERRORS if successful, BUFFER_FULL if buffer full.
+      */
+      virtual Error serialize_partial_as_field(uint32_t field_number,
+                                               WriteBufferInterface& buffer,
+                                               MessageState& state,
+                                               bool optional) const = 0;
+
+      //! Deserialize this field with partial state support for LENGTH_DELIMITED fields.
+      /*! 
+          Handles SIZE->DATA state machine for length-delimited field types.
+          \param buffer The buffer to read from.
+          \param state External state object tracking deserialization progress.
+          \return NO_ERRORS when field reaches COMPLETE.
+      */
+      virtual Error deserialize_partial_as_field(ReadBufferInterface& buffer,
+                                                 MessageState& state) = 0;
+#endif
+
+      //! Calculate the size of this message when serialized.
+      /*!
+          \return The number of bytes this message will require once serialized.
+      */
+      uint32_t serialized_size() const;
+
+      //! Serialize this field with LENGTH_DELIMITED wire type.
+      /*!
+          Writes [tag][size][data] to the buffer.
+          \param field_number The field number for the tag.
+          \param size The size of the data to be written.
+          \param buffer The buffer to write to.
+          \param optional If true, serialize even if size is zero.
+          \return NO_ERRORS if successful.
+      */
+      Error serialize_len(const uint32_t field_number,
+                          const uint32_t size,
+                          WriteBufferInterface& buffer,
+                          const bool optional) const;
+
+      //! Serialize this field with VARINT, FIXED32, or FIXED64 wire type.
+      /*!
+          Writes [tag][data] to the buffer.
+          \param field_number The field number for the tag.
+          \param wire_type The wire type (VARINT, FIXED32, or FIXED64).
+          \param is_default True if the field has its default value.
+          \param buffer The buffer to write to.
+          \param optional If true, serialize even if value is default.
+          \return NO_ERRORS if successful.
+      */
+      Error serialize_scalar(const uint32_t field_number,
+                             const WireFormatter::WireType wire_type,
+                             const bool is_default,
+                             WriteBufferInterface& buffer,
+                             const bool optional) const;
+
+      //! Reset the field to it's initial value.
+      virtual void clear() = 0;
+
+    protected:
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+      //! Helper method for TAG and SIZE phases of partial serialization.
+      /*!
+          Handles the shared TAG and SIZE phases for LENGTH_DELIMITED fields.
+          \param field_number The field number for the tag.
+          \param size The size of the data to be written.
+          \param buffer The buffer to write to.
+          \param state External state object tracking serialization progress.
+          \param optional If true, serialize even if size is zero.
+          \return NO_ERRORS when phase reaches DATA, other errors on failure.
+      */
+      Error serialize_partial_tag_and_size(uint32_t field_number,
+                                           uint32_t size,
+                                           WriteBufferInterface& buffer,
+                                           MessageState& state,
+                                           bool optional) const;
+
+      //! Helper method for SIZE phase of partial deserialization.
+      /*! 
+          Handles the shared SIZE phase for LENGTH_DELIMITED fields.
+          \param buffer The buffer to read from.
+          \param state External state object tracking deserialization progress.
+          \return NO_ERRORS when phase reaches DATA, other errors on failure.
+      */
+      Error deserialize_partial_size_phase(ReadBufferInterface& buffer,
+                                           MessageState& state) const;
+#endif
+
+#ifdef MSG_TO_STRING
+      //! Write all the data in this field to a human readable string.
+      /*!
+          \param str A string view object with a pointer to the current location in the character array and its maximum length.
+          \param indent_level How many spaces should be added before this field.
+          \param name A pointer to the name of this field.
+          \param first_field A boolean indicating if this is the first field we serialize in this message.
+          \return A string view struct detail how many bytes are left in the string and a pointer to the point where to continue.
+      */
+      virtual ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const = 0;
+
+#endif // End of MSG_TO_STRING
+  };
+
+  template<Field::FieldTypes FIELDTYPE, class VARIABLE_TYPE, WireFormatter::WireType WIRETYPE, uint32_t MAX_SER_SIZE>
+  class FieldTemplate
+  {
+    public:
+      using TYPE = VARIABLE_TYPE;
+      using CLASS_TYPE = FieldTemplate<FIELDTYPE, VARIABLE_TYPE, WIRETYPE, MAX_SER_SIZE>;
+
+      FieldTemplate() = default;
+      FieldTemplate(const VARIABLE_TYPE& v) : value_(v) { };
+      FieldTemplate(const VARIABLE_TYPE&& v) : value_(v) { };
+      FieldTemplate(const CLASS_TYPE& ft) : value_(ft.value_) { };
+
+      ~FieldTemplate() = default;
+
+      inline Error serialize_with_id(uint32_t field_number, WriteBufferInterface& buffer, const bool optional) const
+      {
+        Error return_value = Error::NO_ERRORS;
+
+        // For non-optional fields, skip serialization if value equals default (zero/false)
+        if(optional || (static_cast<VARIABLE_TYPE>(0) != value_))
+        {
+          return_value = WireFormatter::SerializeVarint(WireFormatter::MakeTag(field_number, WIRETYPE), buffer);
+          if(Error::NO_ERRORS == return_value)
+          {
+            return_value = serialize(buffer);
+          }
+        }
+
+        return return_value;
+      }
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+      inline Error serialize_partial_with_id(uint32_t field_number,
+                                             WriteBufferInterface& buffer,
+                                             MessageState& state,
+                                             bool optional) const
+      {
+        Error return_value = Error::NO_ERRORS;
+
+        // For non-optional fields, skip serialization if value equals default (zero/false)
+        if(optional || (static_cast<VARIABLE_TYPE>(0) != value_))
+        {
+          if(::EmbeddedProto::FieldProcessingPhase::TAG == state.phase)
+          {
+            // For scalar fields, we need atomic write of tag+value
+            // Check if we have enough space for both tag and value
+            const uint32_t tag_size = WireFormatter::VarintSize(WireFormatter::MakeTag(field_number, WIRETYPE));
+            const uint32_t value_size = this->serialized_size();
+            const uint32_t required_space = tag_size + value_size;
+
+            // The tag and value are written as a pair on the strength of this check, see
+            // WriteBufferInterface::get_available_size(). When the pair does not fit the
+            // state is left untouched so the retry starts at the tag again.
+            if(buffer.get_available_size() < required_space)
+            {
+              return_value = Error::BUFFER_FULL;
+            }
+            else
+            {
+              return_value = WireFormatter::SerializeVarint(WireFormatter::MakeTag(field_number, WIRETYPE), buffer);
+              if(Error::NO_ERRORS == return_value)
+              {
+                state.phase = ::EmbeddedProto::FieldProcessingPhase::DATA;
+              }
+              else
+              {
+                // Defensive: a conforming buffer accepts the tag after the space check
+                // above. The state is untouched so a retry starts at the tag again.
+                return_value = Error::BUFFER_FULL;
+              }
+            }
+          }
+
+          if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::DATA == state.phase))
+          {
+            // Write value - this should always fit if TAG phase succeeded
+            return_value = serialize(buffer);
+            if(Error::NO_ERRORS == return_value)
+            {
+              state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+            }
+            else
+            {
+              // Defensive: a conforming buffer accepts the value after the space check
+              // in the TAG phase, so this branch cannot be reached. Should a buffer
+              // over-report its free space the tag is already in the buffer and cannot
+              // be taken back, a retry from the TAG phase writes it a second time.
+              state.phase = ::EmbeddedProto::FieldProcessingPhase::TAG;
+              return_value = Error::BUFFER_FULL;
+            }
+          }
+        }
+        else
+        {
+          // Field has default value - skip to complete
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+        }
+
+        return return_value;
+      }
+#endif
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+      //! Deserialize scalar/enum with expected wire type in partial mode.
+      inline Error deserialize_partial_check_type(ReadBufferInterface& buffer,
+                                                  MessageState& state,
+                                                  const ::EmbeddedProto::WireFormatter::WireType expected_wire_type)
+      {
+        Error return_value = Error::NO_ERRORS;
+
+        if(::EmbeddedProto::FieldProcessingPhase::DATA != state.phase)
+        {
+          return_value = Error::STATE_MISMATCH;
+        }
+        else if(expected_wire_type != state.wire_type)
+        {
+          return_value = Error::INVALID_WIRETYPE;
+        }
+        else
+        {
+          return_value = deserialize(buffer);
+          if(Error::NO_ERRORS == return_value)
+          {
+            state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          }
+        }
+
+        return return_value;
+      }
+#endif
+
+      inline Error serialize(WriteBufferInterface& buffer) const
+      {
+        return serialize_<FIELDTYPE>(buffer);
+      }
+
+      inline Error deserialize(ReadBufferInterface& buffer)
+      {
+        return deserialize_<FIELDTYPE>(buffer);
+      }
+
+      //! \see Field::deserialize()
+      inline Error deserialize_check_type(ReadBufferInterface& buffer, 
+                                   const ::EmbeddedProto::WireFormatter::WireType& wire_type)
+      {
+        Error return_value = WIRETYPE == wire_type ? Error::NO_ERRORS : Error::INVALID_WIRETYPE;
+        if(Error::NO_ERRORS == return_value) 
+        {
+          return_value = deserialize(buffer);
+        }
+        return return_value;
+      }
+
+      inline void set(const VARIABLE_TYPE& v) { value_ = v; }      
+      inline void set(const VARIABLE_TYPE&& v) { value_ = v; }
+
+      inline void set(const CLASS_TYPE& ft) { value_ = ft.value_; }
+      inline void set(const CLASS_TYPE&& ft) { value_ = ft.value_; }
+      
+      inline CLASS_TYPE& operator=(const VARIABLE_TYPE& v) 
+      { 
+        value_ = v;
+        return *this;
+      }
+      inline CLASS_TYPE& operator=(const VARIABLE_TYPE&& v) 
+      { 
+        value_ = v;
+        return *this;
+      }
+      inline CLASS_TYPE& operator=(const CLASS_TYPE& ft)
+      { 
+        value_ = ft.value_; 
+        return *this; 
+      }
+      inline CLASS_TYPE& operator=(const CLASS_TYPE&& ft) noexcept
+      { 
+        value_ = ft.value_;
+        return *this;
+      }
+
+      inline const VARIABLE_TYPE& get() const { return value_; }
+      inline VARIABLE_TYPE& get() { return value_; }
+
+      //! This is the conversion operator. 
+      /*! 
+        Sonar would like this to be explicit but this is not practial in normal usage with other 
+        integer and floating point types.
+      */
+      inline operator VARIABLE_TYPE() const { return value_; } //NOSONAR
+
+      inline bool operator==(const VARIABLE_TYPE& rhs) { return value_ == rhs; }
+      inline bool operator!=(const VARIABLE_TYPE& rhs) { return value_ != rhs; }
+      inline bool operator>(const VARIABLE_TYPE& rhs) { return value_ > rhs; }
+      inline bool operator<(const VARIABLE_TYPE& rhs) { return value_ < rhs; }
+      inline bool operator>=(const VARIABLE_TYPE& rhs) { return value_ >= rhs; }
+      inline bool operator<=(const VARIABLE_TYPE& rhs) { return value_ <= rhs; }
+
+      template<Field::FieldTypes FIELDTYPE_RHS, class TYPE_RHS, WireFormatter::WireType WIRETYPE_RHS, uint32_t SIZE_RHS>
+      inline bool operator==(const FieldTemplate<FIELDTYPE_RHS, TYPE_RHS, WIRETYPE_RHS, SIZE_RHS>& rhs) { return value_ == rhs.get(); }
+      template<Field::FieldTypes FIELDTYPE_RHS, class TYPE_RHS, WireFormatter::WireType WIRETYPE_RHS, uint32_t SIZE_RHS>
+      inline bool operator!=(const FieldTemplate<FIELDTYPE_RHS, TYPE_RHS, WIRETYPE_RHS, SIZE_RHS>& rhs) { return value_ != rhs.get(); }
+      template<Field::FieldTypes FIELDTYPE_RHS, class TYPE_RHS, WireFormatter::WireType WIRETYPE_RHS, uint32_t SIZE_RHS>
+      inline bool operator>(const FieldTemplate<FIELDTYPE_RHS, TYPE_RHS, WIRETYPE_RHS, SIZE_RHS>& rhs) { return value_ > rhs.get(); }
+      template<Field::FieldTypes FIELDTYPE_RHS, class TYPE_RHS, WireFormatter::WireType WIRETYPE_RHS, uint32_t SIZE_RHS>
+      inline bool operator<(const FieldTemplate<FIELDTYPE_RHS, TYPE_RHS, WIRETYPE_RHS, SIZE_RHS>& rhs) { return value_ < rhs.get(); }
+      template<Field::FieldTypes FIELDTYPE_RHS, class TYPE_RHS, WireFormatter::WireType WIRETYPE_RHS, uint32_t SIZE_RHS>
+      inline bool operator>=(const FieldTemplate<FIELDTYPE_RHS, TYPE_RHS, WIRETYPE_RHS, SIZE_RHS>& rhs) { return value_ >= rhs.get(); }
+      template<Field::FieldTypes FIELDTYPE_RHS, class TYPE_RHS, WireFormatter::WireType WIRETYPE_RHS, uint32_t SIZE_RHS>
+      inline bool operator<=(const FieldTemplate<FIELDTYPE_RHS, TYPE_RHS, WIRETYPE_RHS, SIZE_RHS>& rhs) { return value_ <= rhs.get(); }
+
+      inline void clear() { value_ = static_cast<VARIABLE_TYPE>(0); }
+
+      inline uint32_t serialized_size() const
+      {
+        ::EmbeddedProto::MessageSizeCalculator calcBuffer;
+        this->serialize(calcBuffer);
+        return calcBuffer.get_size();
+      }
+
+      //! When serialized with the most unfavrouble value how much bytes does this field need.
+      /*!
+        This function takes into account the field number and tag combination.
+        \param[in] field_number We need to include the field number. This because large field numbers require more bytes.
+        \return The number of bytes required at most.
+      */
+      static inline constexpr uint32_t max_serialized_size(const uint32_t field_number)
+      {
+        return MAX_SER_SIZE + WireFormatter::VarintSize(WireFormatter::MakeTag(field_number, WIRETYPE));
+      }
+
+      static inline constexpr uint32_t max_serialized_size()
+      {
+        return MAX_SER_SIZE;
+      }
+
+#ifdef MSG_TO_STRING
+
+      //! Write all the data in this field to a human readable string.
+      /*!
+          \param str A string view object with a pointer to the current location in the character array and its maximum length.
+          \param indent_level How many spaces should be added before this field.
+          \param name A pointer to the name of this field.
+          \param first_field A boolean indicating if this is the first field we serialize in this message.
+          \return A string view struct detail how many bytes are left in the string and a pointer to the point where to continue.
+      */
+      ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const
+      {
+        ::EmbeddedProto::string_view left_chars = str;
+        int32_t n_chars_used = 0;
+
+        if(!first_field)
+        {
+          // Add a comma behind the previous field.
+          n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n");
+          if(0 < n_chars_used) {
+            // Update the character pointer and characters left in the array.
+            const int32_t actual_chars_used = EmbeddedProto::min(n_chars_used, left_chars.size);
+            left_chars.data += actual_chars_used;
+            left_chars.size -= actual_chars_used;
+          }
+        }
+
+        n_chars_used = 0;
+
+        if(nullptr != name)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": ", indent_level, " ", name);
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s", indent_level, " ");
+        }
+
+        if(0 < n_chars_used)
+        {
+          // Update the character pointer and characters left in the array.
+          const int32_t actual_chars_used = EmbeddedProto::min(n_chars_used, left_chars.size);
+          left_chars.data += actual_chars_used;
+          left_chars.size -= actual_chars_used;
+        }
+
+        if constexpr((Field::FieldTypes::int32 == FIELDTYPE) ||
+                     (Field::FieldTypes::sint32 == FIELDTYPE) ||
+                     (Field::FieldTypes::sfixed32 == FIELDTYPE))
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%d", get());
+        }
+        else if constexpr((Field::FieldTypes::int64 == FIELDTYPE) ||
+                          (Field::FieldTypes::sint64 == FIELDTYPE) ||
+                          (Field::FieldTypes::sfixed64 == FIELDTYPE))
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%ld", get());
+        }
+        else if constexpr((Field::FieldTypes::uint32 == FIELDTYPE) ||
+                          (Field::FieldTypes::fixed32 == FIELDTYPE))
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%u", get());
+        }        
+        else if constexpr((Field::FieldTypes::uint64 == FIELDTYPE) ||
+                          (Field::FieldTypes::fixed64 == FIELDTYPE))
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%lu", get());
+        }
+        else if constexpr(Field::FieldTypes::boolean == FIELDTYPE)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%s", 
+                                  get() ? "true" : "false");
+        }
+        else if constexpr(Field::FieldTypes::enumeration == FIELDTYPE)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%d", 
+                                  static_cast<uint32_t>(get()));
+        }
+        else if constexpr(Field::FieldTypes::floatfixed == FIELDTYPE)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%f", get());
+        }
+        else if constexpr(Field::FieldTypes::doublefixed == FIELDTYPE)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%lf", get());
+        }
+        else
+        {
+          // Should never get here.
+        }
+
+        if(0 < n_chars_used) {
+          // Update the character pointer and characters left in the array.
+          const int32_t actual_chars_used = EmbeddedProto::min(n_chars_used, left_chars.size);
+          left_chars.data += actual_chars_used;
+          left_chars.size -= actual_chars_used;
+        }
+
+        return left_chars;
+      }
+
+#endif // End of MSG_TO_STRING
+
+    private:
+
+      VARIABLE_TYPE value_;
+
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::int32 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeVarint(static_cast<uint32_t>(get()), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::int64 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeVarint(static_cast<uint64_t>(get()), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::uint32 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeVarint(get(), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::uint64 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeVarint(get(), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sint32 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeVarint(WireFormatter::ZigZagEncode(get()), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sint64 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeVarint(WireFormatter::ZigZagEncode(get()), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::boolean == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const 
+      { 
+        const uint8_t byte = get() ? 0x01 : 0x00;
+        return buffer.push(byte) ? Error::NO_ERRORS : Error::BUFFER_FULL; 
+      }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::enumeration == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeVarint(static_cast<uint32_t>(get()), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::fixed32 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeFixedNoTag(get(), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::fixed64 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerializeFixedNoTag(get(), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sfixed32 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerialzieSFixedNoTag(get(), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sfixed64 == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerialzieSFixedNoTag(get(), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::floatfixed == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerialzieFloatNoTag(get(), buffer); }
+
+      template<Field::FieldTypes SER_FIELDTYPE, typename std::enable_if<Field::FieldTypes::doublefixed == SER_FIELDTYPE, bool>::type = true>
+      inline Error serialize_(WriteBufferInterface& buffer) const { return WireFormatter::SerialzieDoubleNoTag(get(), buffer); }
+
+
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::int32 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeInt(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::int64 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeInt(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::uint32 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeUInt(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::uint64 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeUInt(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sint32 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeSInt(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sint64 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeSInt(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::boolean == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeBool(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::enumeration == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer)
+      { 
+        uint32_t value = 0;
+        const Error return_value = WireFormatter::DeserializeVarint(buffer, value);
+        if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+        {
+          value_ = static_cast<VARIABLE_TYPE>(value);
+        }
+        return return_value;
+      }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::fixed32 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeFixed(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::fixed64 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeFixed(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sfixed32 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeSFixed(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::sfixed64 == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeSFixed(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::floatfixed == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeFloat(buffer, get()); }
+
+      template<Field::FieldTypes DES_FIELDTYPE, typename std::enable_if<Field::FieldTypes::doublefixed == DES_FIELDTYPE, bool>::type = true>
+      inline Error deserialize_(ReadBufferInterface& buffer) { return WireFormatter::DeserializeDouble(buffer, get()); }
+
+  };
+
+
+  using int32 = FieldTemplate<Field::FieldTypes::int32, int32_t, WireFormatter::WireType::VARINT, 5>;
+  using int64 = FieldTemplate<Field::FieldTypes::int64, int64_t, WireFormatter::WireType::VARINT, 10>;
+  using uint32 = FieldTemplate<Field::FieldTypes::uint32, uint32_t, WireFormatter::WireType::VARINT, 5>; 
+  using uint64 = FieldTemplate<Field::FieldTypes::uint64, uint64_t, WireFormatter::WireType::VARINT, 10>; 
+  using sint32 = FieldTemplate<Field::FieldTypes::sint32, int32_t, WireFormatter::WireType::VARINT, 5>; 
+  using sint64 = FieldTemplate<Field::FieldTypes::sint64, int64_t, WireFormatter::WireType::VARINT, 10>; 
+  using boolean = FieldTemplate<Field::FieldTypes::boolean, bool, WireFormatter::WireType::VARINT, 1>; 
+  using fixed32 = FieldTemplate<Field::FieldTypes::fixed32, uint32_t, WireFormatter::WireType::FIXED32, 4>; 
+  using fixed64 = FieldTemplate<Field::FieldTypes::fixed64, uint64_t, WireFormatter::WireType::FIXED64, 8>; 
+  using sfixed32 = FieldTemplate<Field::FieldTypes::sfixed32, int32_t, WireFormatter::WireType::FIXED32, 4>; 
+  using sfixed64 = FieldTemplate<Field::FieldTypes::sfixed64, int64_t, WireFormatter::WireType::FIXED64, 8>; 
+  using floatfixed = FieldTemplate<Field::FieldTypes::floatfixed, float, WireFormatter::WireType::FIXED32, 4>; 
+  using doublefixed = FieldTemplate<Field::FieldTypes::doublefixed, double, WireFormatter::WireType::FIXED64, 8>;
+
+  template<class ENUM_TYPE, uint32_t MAX_SER_SIZE>
+  using enumeration = FieldTemplate<Field::FieldTypes::enumeration, ENUM_TYPE, WireFormatter::WireType::VARINT, MAX_SER_SIZE>;
+
+
+  // Definitions of the member functions declared above. The library is header only, so they are
+  // inline.
+
+  inline uint32_t Field::serialized_size() const
+  {
+    ::EmbeddedProto::MessageSizeCalculator calcBuffer;
+    this->serialize(calcBuffer);
+    return calcBuffer.get_size();
+  }
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+  inline Error Field::serialize_partial_tag_and_size(uint32_t field_number,
+                                             uint32_t size,
+                                             WriteBufferInterface& buffer,
+                                             MessageState& state,
+                                             bool optional) const
+  {
+    static_cast<void>(optional);
+    Error return_value = Error::NO_ERRORS;
+
+    if(::EmbeddedProto::FieldProcessingPhase::TAG == state.phase)
+    {
+      // Check if we have enough space for both tag and size atomically
+      const uint32_t tag = WireFormatter::MakeTag(field_number, WireFormatter::WireType::LENGTH_DELIMITED);
+      const uint32_t tag_size = WireFormatter::VarintSize(tag);
+      const uint32_t size_size = WireFormatter::VarintSize(size);
+      const uint32_t required_space = tag_size + size_size;
+
+      if(buffer.get_available_size() < required_space)
+      {
+        // Not enough space for atomic tag+size operation - rollback
+        return_value = Error::BUFFER_FULL;
+        return return_value;
+      }
+
+      // Write tag
+      return_value = WireFormatter::SerializeVarint(tag, buffer);
+      if(Error::NO_ERRORS == return_value)
+      {
+        state.phase = ::EmbeddedProto::FieldProcessingPhase::SIZE;
+      }
+    }
+
+    if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::SIZE == state.phase))
+    {
+      // Write size
+      return_value = WireFormatter::SerializeVarint(size, buffer);
+      if(Error::NO_ERRORS == return_value)
+      {
+        state.bytes_remaining = size;
+        // For empty fields, skip DATA phase and go directly to COMPLETE
+        if(0 == size)
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+        }
+        else
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::DATA;
+        }
+      }
+    }
+
+    return return_value;
+  }
+
+  inline Error Field::deserialize_partial_size_phase(ReadBufferInterface& buffer,
+                                              MessageState& state) const
+  {
+    Error return_value = Error::NO_ERRORS;
+
+    if(::EmbeddedProto::FieldProcessingPhase::SIZE == state.phase)
+    {
+      uint32_t size = 0;
+      return_value = WireFormatter::DeserializeVarint(buffer, size);
+      if(Error::NO_ERRORS == return_value)
+      {
+        state.size_value = size;
+        state.bytes_remaining = size;
+        state.phase = ::EmbeddedProto::FieldProcessingPhase::DATA;
+      }
+      else
+      {
+        // Keep state unchanged on incomplete/failed size decode.
+      }
+    }
+    else
+    {
+      return_value = Error::STATE_MISMATCH;
+    }
+
+    return return_value;
+  }
+#endif
+
+  inline Error Field::serialize_len(const uint32_t field_number,
+                             const uint32_t size,
+                             WriteBufferInterface& buffer,
+                             const bool optional) const
+  {
+    Error return_value = Error::NO_ERRORS;
+
+    // Skip serializing empty fields for non-optional fields (proto3 default behavior)
+    if(optional || (0 != size))
+    {
+      return_value = WireFormatter::SerializeVarint(
+          WireFormatter::MakeTag(field_number, WireFormatter::WireType::LENGTH_DELIMITED),
+          buffer);
+
+      if(Error::NO_ERRORS == return_value)
+      {
+        return_value = WireFormatter::SerializeVarint(size, buffer);
+
+        if(Error::NO_ERRORS == return_value)
+        {
+          // Check if there's enough space for the data after writing tag and size
+          if(size <= buffer.get_available_size())
+          {
+            // Only call serialize if there's actual data to write. When the buffer
+            // only counts bytes the payload size is already known, serializing it
+            // would just count the same bytes a second time.
+            if((0U < size) && !buffer.count_only(size))
+            {
+              return_value = serialize(buffer);
+            }
+          }
+          else
+          {
+            return_value = Error::BUFFER_FULL;
+          }
+        }
+      }
+    }
+
+    return return_value;
+  }
+
+  inline Error Field::serialize_scalar(const uint32_t field_number,
+                                const WireFormatter::WireType wire_type,
+                                const bool is_default,
+                                WriteBufferInterface& buffer, 
+                                const bool optional) const
+  {
+    Error return_value = Error::NO_ERRORS;
+    
+    if(optional || !is_default)
+    {
+      return_value = WireFormatter::SerializeVarint(
+          WireFormatter::MakeTag(field_number, wire_type), 
+          buffer);
+      
+      if(Error::NO_ERRORS == return_value)
+      {
+        return_value = serialize(buffer);
+      }
+    }
+    
+    return return_value;
+  }
+
+} // End of namespace EmbeddedProto.
+#endif