EmbeddedProto 4.0.0b1__py3-none-any.whl

EmbeddedProto/src/EmbeddedProto/MessageInterface.h

@@ -0,0 +1,792 @@
+/*
+ *  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 _MESSAGE_INTERFACE_H_
+#define _MESSAGE_INTERFACE_H_
+
+#include "WireFormatter.h"
+#include "Fields.h"
+#include "Errors.h"
+#include "MessageState.h"
+#include "ReadBufferSection.h"
+
+#include <cstdint>
+
+
+namespace EmbeddedProto 
+{
+
+class MessageInterface : public ::EmbeddedProto::Field
+{
+  public:
+
+    MessageInterface() = default;
+
+    ~MessageInterface() = default;
+
+    //! \see Field::deserialize()
+    Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override = 0;
+
+    //! \see Field::deserialize()
+    Error deserialize_check_type(::EmbeddedProto::ReadBufferInterface& buffer, 
+                                 const ::EmbeddedProto::WireFormatter::WireType& wire_type) final;
+
+    //! Clear the content of this message and set it to it's default state.
+    /*!
+        The defaults are to be set according to the Protobuf standard.
+    */
+    void clear() override = 0;
+
+    //! Serialize this message as a delimited group (editions message_encoding =
+    //! DELIMITED).
+    /*!
+        Writes a START_GROUP tag, this message's fields inline, then an END_GROUP
+        tag. Because group framing carries no length prefix there is no size
+        pre-pass, which enables single-pass encoding of (nested) messages.
+
+        \param field_number The field number for the START/END group tags.
+        \param buffer The buffer to write to.
+        \return Error::NO_ERRORS when successful.
+    */
+    Error serialize_as_group(const uint32_t field_number, WriteBufferInterface& buffer) const
+    {
+      Error return_value = WireFormatter::SerializeVarint(
+          WireFormatter::MakeTag(field_number, WireFormatter::WireType::START_GROUP), buffer);
+      if(Error::NO_ERRORS == return_value)
+      {
+        return_value = this->serialize(buffer);
+      }
+      if(Error::NO_ERRORS == return_value)
+      {
+        return_value = WireFormatter::SerializeVarint(
+            WireFormatter::MakeTag(field_number, WireFormatter::WireType::END_GROUP), buffer);
+      }
+      return return_value;
+    }
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+    //! Deserialize message with partial state support.
+    /*!
+        This method deserializes the message in chunks, allowing deserialization to be paused
+        when the buffer ends and resumed with a fresh buffer.
+
+        A top-level message carries no length prefix, so this function cannot tell where the
+        input ends. After the last field it returns to the tag phase and reports
+        Error::END_OF_BUFFER when no next tag is available. Only the caller knows whether more
+        data will arrive:
+
+        \code
+        Error result = Error::END_OF_BUFFER;
+        while((Error::END_OF_BUFFER == result) && receive_next_chunk(buffer))
+        {
+          result = msg.deserialize_partial(buffer, state.root());
+        }
+        const bool complete = (Error::END_OF_BUFFER == result)
+                              && (FieldProcessingPhase::TAG == state.root().phase);
+        \endcode
+
+        \param buffer Read buffer (may be small).
+        \param state External state object (must persist between calls).
+        \return Error::END_OF_BUFFER with state.phase == FieldProcessingPhase::TAG when the buffer
+                ended at a field boundary. When the caller has no more input the message is
+                complete, otherwise call again with a fresh buffer.
+        \return Error::END_OF_BUFFER with any other phase when a field was cut, call again with a
+                fresh buffer.
+        \return Error::NO_ERRORS with state.phase == FieldProcessingPhase::COMPLETE when a
+                DELIMITED (group) message consumed its END_GROUP tag, see
+                deserialize_partial_as_group().
+        \return Other errors on failure (state should be reset).
+    */
+    virtual Error deserialize_partial(ReadBufferInterface& buffer,
+                                      MessageState& state) = 0;
+
+    //! Serialize message with partial state support.
+    /*!
+        This method serializes the message in chunks, allowing serialization to be paused
+        when the buffer becomes full and resumed with a fresh buffer.
+        
+        \param buffer Write buffer (may be small).
+        \param state External state object (must persist between calls).
+        \return Error::NO_ERRORS when complete.
+        \return Error::BUFFER_FULL when buffer full, call again with fresh buffer.
+        \return Other errors on failure (state should be reset).
+    */
+    virtual Error serialize_partial(WriteBufferInterface& buffer,
+                                    MessageState& state) const = 0;
+
+    Error serialize_partial_as_field(uint32_t field_number,
+                                     WriteBufferInterface& buffer,
+                                     MessageState& state,
+                                     bool optional) const override
+    {
+      Error return_value = Error::NO_ERRORS;
+
+      // The size of this nested message is calculated once, when the field is entered,
+      // and kept in the state. Resuming after a full buffer reuses it instead of
+      // walking the whole subtree again for every chunk. Whether the field is emitted
+      // at all is decided here as well, so no later phase depends on the stored size.
+      if(::EmbeddedProto::FieldProcessingPhase::TAG == state.phase)
+      {
+        state.size_value = serialized_size();
+
+        // Skip serializing empty fields for non-optional fields (proto3 default behavior)
+        if((!optional) && (0U == state.size_value))
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+        }
+      }
+
+      // Handle TAG and SIZE phases using helper method
+      if((::EmbeddedProto::FieldProcessingPhase::TAG == state.phase) || (::EmbeddedProto::FieldProcessingPhase::SIZE == state.phase))
+      {
+        return_value = serialize_partial_tag_and_size(field_number, state.size_value, buffer, state, optional);
+      }
+
+      // A zero sized field never reaches the data phase, serialize_partial_tag_and_size()
+      // marks it complete, so the size no longer has to be checked here.
+      if(::EmbeddedProto::FieldProcessingPhase::DATA == state.phase)
+      {
+        if(nullptr != state.child)
+        {
+          return_value = this->serialize_partial(buffer, *state.child);
+          if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::COMPLETE == state.child->phase))
+          {
+            state.bytes_remaining = 0U;
+            state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          }
+        }
+        else
+        {
+          return_value = Error::NESTING_TOO_DEEP;
+        }
+      }
+
+      return return_value;
+    }
+
+    //! Serialize this message as a delimited group with partial state support.
+    /*!
+        DELIMITED (group) framing has no length prefix, so there is no SIZE phase.
+        The phases used are TAG (write START_GROUP) -> DATA (stream the child) ->
+        SIZE (reused to write END_GROUP) -> COMPLETE. Each tag is written
+        atomically; on a full buffer the phase is left unchanged so the call
+        resumes from the same point with a fresh buffer.
+
+        \param field_number The field number for the START/END group tags.
+        \param buffer The (possibly small) write buffer.
+        \param state The state for this group field; state.child streams the body.
+        \return Error::NO_ERRORS when complete, Error::BUFFER_FULL to resume.
+    */
+    Error serialize_partial_as_group(uint32_t field_number,
+                                     WriteBufferInterface& buffer,
+                                     MessageState& state) const
+    {
+      Error return_value = Error::NO_ERRORS;
+
+      // Phase TAG: write the START_GROUP tag.
+      if(::EmbeddedProto::FieldProcessingPhase::TAG == state.phase)
+      {
+        const uint32_t tag = WireFormatter::MakeTag(field_number, WireFormatter::WireType::START_GROUP);
+        if(buffer.get_available_size() >= WireFormatter::VarintSize(tag))
+        {
+          return_value = WireFormatter::SerializeVarint(tag, buffer);
+          if(Error::NO_ERRORS == return_value)
+          {
+            state.phase = ::EmbeddedProto::FieldProcessingPhase::DATA;
+          }
+        }
+        else
+        {
+          return_value = Error::BUFFER_FULL;
+        }
+      }
+
+      // Phase DATA: stream the child message's fields.
+      if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::DATA == state.phase))
+      {
+        if(nullptr != state.child)
+        {
+          return_value = this->serialize_partial(buffer, *state.child);
+          if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::COMPLETE == state.child->phase))
+          {
+            // Body complete; the END_GROUP tag still has to be written. Reuse the
+            // (otherwise unused) SIZE phase to mark "END_GROUP pending".
+            state.phase = ::EmbeddedProto::FieldProcessingPhase::SIZE;
+          }
+        }
+        else
+        {
+          return_value = Error::NESTING_TOO_DEEP;
+        }
+      }
+
+      // Phase SIZE (reused): write the END_GROUP tag.
+      if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::SIZE == state.phase))
+      {
+        const uint32_t tag = WireFormatter::MakeTag(field_number, WireFormatter::WireType::END_GROUP);
+        if(buffer.get_available_size() >= WireFormatter::VarintSize(tag))
+        {
+          return_value = WireFormatter::SerializeVarint(tag, buffer);
+          if(Error::NO_ERRORS == return_value)
+          {
+            state.bytes_remaining = 0U;
+            state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          }
+        }
+        else
+        {
+          return_value = Error::BUFFER_FULL;
+        }
+      }
+
+      return return_value;
+    }
+
+    //! Deserialize a length-delimited nested message field with partial state support.
+    /*!
+        Unlike a top-level message the nested message has a known size. Once the declared
+        number of bytes has been consumed the nested Error::END_OF_BUFFER is mapped to
+        Error::NO_ERRORS and this field is marked COMPLETE. Error::END_OF_BUFFER from this
+        function therefore always means more data is needed.
+
+        \see Field::deserialize_partial_as_field()
+    */
+    Error deserialize_partial_as_field(ReadBufferInterface& buffer,
+                                       MessageState& state) override;
+
+    //! Deserialize a delimited (group) message field with partial state support.
+    /*!
+        The opening START_GROUP tag has been consumed by the caller (phase DATA).
+        The child is streamed until it consumes its matching END_GROUP, at which
+        point the child returns Error::NO_ERRORS with phase COMPLETE and this field
+        is marked COMPLETE. Error::END_OF_BUFFER means more data is needed.
+    */
+    Error deserialize_partial_as_group(ReadBufferInterface& buffer,
+                                       MessageState& state);
+
+    //! When partially deserializing skip bytes in the buffer of an unknown field.
+    Error skip_unknown_field_partial(::EmbeddedProto::ReadBufferInterface& buffer,
+                                     MessageState& state) const;
+
+    //! When partially deserializing skip an unknown DELIMITED (group) field.
+    /*!
+        The START_GROUP tag has been consumed by the caller (phase DATA). The fields
+        inside the group are skipped one at a time until the matching END_GROUP tag is
+        consumed, at which point the phase is COMPLETE. Nested groups are counted, not
+        recursed into, so the skip takes no level of the state stack. The progress is
+        kept in the otherwise unused members of the group state itself, see
+        SKIP_GROUP_WIRE_TYPE_SHIFT. Returns END_OF_BUFFER when the buffer runs out
+        inside the group, to be resumed with the next buffer.
+    */
+    Error skip_group_partial(::EmbeddedProto::ReadBufferInterface& buffer,
+                             MessageState& state) const;
+#endif
+
+  protected:
+    //! When deserializing skip the bytes in the buffer of an unknown field.
+    /*!
+        This function is used when a field with an unknown id is encountered to move through the
+        buffer to the next tag.
+    */
+    Error skip_unknown_field(::EmbeddedProto::ReadBufferInterface& buffer,
+                             const ::EmbeddedProto::WireFormatter::WireType& wire_type) const;
+
+    Error skip_varint(::EmbeddedProto::ReadBufferInterface& buffer) const;
+    Error skip_fixed32(::EmbeddedProto::ReadBufferInterface& buffer) const;
+    Error skip_fixed64(::EmbeddedProto::ReadBufferInterface& buffer) const;
+    Error skip_length_delimited(::EmbeddedProto::ReadBufferInterface& buffer) const;
+
+    //! Skip an unknown DELIMITED (group) field up to its matching END_GROUP.
+    Error skip_group(::EmbeddedProto::ReadBufferInterface& buffer) const;
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+    //! Layout of the group state while skipping an unknown DELIMITED (group) field.
+    /*!
+        The state of the unknown field keeps wire_type START_GROUP and phase DATA, which
+        routes it into skip_group_partial(). The members a group has no other use for
+        track the field currently being skipped inside the group:
+        - element_index holds the nesting depth of groups inside the unknown group,
+        - bytes_remaining holds the bytes still to skip of the inner field,
+        - size_value holds the wire type and phase of the inner field, packed as
+          (wire_type << SKIP_GROUP_WIRE_TYPE_SHIFT) | phase.
+        The initial size_value of zero decodes to phase TAG, the first inner tag.
+    */
+    static constexpr uint32_t SKIP_GROUP_WIRE_TYPE_SHIFT = 8U;
+
+    //! Mask of one packed inner field of the size_value, see SKIP_GROUP_WIRE_TYPE_SHIFT.
+    static constexpr uint32_t SKIP_GROUP_FIELD_MASK = 0xFFU;
+
+    //! Pack the wire type and phase of the inner field into size_value.
+    static constexpr uint32_t pack_skip_group_field(const WireFormatter::WireType wire_type,
+                                                    const FieldProcessingPhase phase)
+    {
+      return (static_cast<uint32_t>(wire_type) << SKIP_GROUP_WIRE_TYPE_SHIFT)
+             | static_cast<uint32_t>(phase);
+    }
+
+    //! Unpack the wire type of the inner field from size_value.
+    static constexpr WireFormatter::WireType skip_group_field_wire_type(const uint32_t size_value)
+    {
+      return static_cast<WireFormatter::WireType>((size_value >> SKIP_GROUP_WIRE_TYPE_SHIFT)
+                                                  & SKIP_GROUP_FIELD_MASK);
+    }
+
+    //! Unpack the phase of the inner field from size_value.
+    static constexpr FieldProcessingPhase skip_group_field_phase(const uint32_t size_value)
+    {
+      return static_cast<FieldProcessingPhase>(size_value & SKIP_GROUP_FIELD_MASK);
+    }
+#endif
+
+};
+
+
+  // Definitions of the member functions declared above. The library is header only, so they are
+  // inline.
+
+  inline Error MessageInterface::deserialize_check_type(::EmbeddedProto::ReadBufferInterface& buffer,
+                                                 const ::EmbeddedProto::WireFormatter::WireType& wire_type)
+  {
+    Error return_value = ::EmbeddedProto::WireFormatter::WireType::LENGTH_DELIMITED == wire_type 
+                         ? Error::NO_ERRORS : Error::INVALID_WIRETYPE;
+    if(Error::NO_ERRORS == return_value)  
+    {
+      uint32_t size = 0;
+      return_value = ::EmbeddedProto::WireFormatter::DeserializeVarint(buffer, size);
+      ::EmbeddedProto::ReadBufferSection bufferSection(buffer, size);
+      if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+      {
+        return_value = deserialize(bufferSection);
+        if((Error::END_OF_BUFFER == return_value) && (0U == size))
+        {
+          // A size of zero is a valid empty message (all fields default). The nested
+          // deserialize finds no tag in the empty section and reports END_OF_BUFFER,
+          // which is the expected clean end here and not a truncated message.
+          return_value = Error::NO_ERRORS;
+        }
+        else if((Error::NO_ERRORS == return_value) && (0U != bufferSection.get_size()))
+        {
+          // The nested deserialize only stops before the end of its section after
+          // consuming an END_GROUP tag. That tag closes group framing and is malformed
+          // inside a length-delimited field. Accepting it would leave the rest of the
+          // section to be read as fields of this message.
+          return_value = Error::INVALID_WIRETYPE;
+        }
+        else
+        {
+          // Any other result is passed on as is.
+        }
+      }
+    }
+    return return_value;
+  }
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+  inline Error MessageInterface::deserialize_partial_as_field(::EmbeddedProto::ReadBufferInterface& buffer,
+                                                       MessageState& state)
+  {
+    Error return_value = Error::NO_ERRORS;
+
+    if(::EmbeddedProto::FieldProcessingPhase::SIZE == state.phase)
+    {
+      return_value = deserialize_partial_size_phase(buffer, state);
+    }
+
+    if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::DATA == state.phase))
+    {
+      if(nullptr != state.child)
+      {
+        // The section is clamped to what is currently in the buffer, which may be
+        // less than the declared nested message size. Track progress against the
+        // declared size using the number of bytes actually consumed.
+        ::EmbeddedProto::ReadBufferSection section(buffer, state.bytes_remaining);
+        const uint32_t section_size_before = section.get_max_size();
+        return_value = this->deserialize_partial(section, *state.child);
+        const uint32_t bytes_consumed = section_size_before - section.get_size();
+        state.bytes_remaining -= bytes_consumed;
+
+        if((Error::NO_ERRORS == return_value)
+           && (::EmbeddedProto::FieldProcessingPhase::COMPLETE == state.child->phase))
+        {
+          // The child only returns NO_ERRORS in the COMPLETE phase after consuming an
+          // END_GROUP tag. That tag closes group framing, which is handled by
+          // deserialize_partial_as_group. Inside a length-delimited field it is
+          // malformed input, accepting it would end the nested message early with
+          // bytes of the section left unread.
+          return_value = Error::INVALID_WIRETYPE;
+        }
+
+        if(0U == state.bytes_remaining)
+        {
+          // The whole nested message has been consumed. The child reports
+          // END_OF_BUFFER once its bounded section runs out; for a fully received
+          // nested message that simply means it is complete.
+          if(Error::END_OF_BUFFER == return_value)
+          {
+            return_value = Error::NO_ERRORS;
+          }
+          if(Error::NO_ERRORS == return_value)
+          {
+            state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+            state.child->reset();
+          }
+        }
+      }
+      else
+      {
+        return_value = Error::NESTING_TOO_DEEP;
+      }
+    }
+
+    return return_value;
+  }
+
+  inline Error MessageInterface::deserialize_partial_as_group(::EmbeddedProto::ReadBufferInterface& buffer,
+                                                       MessageState& state)
+  {
+    Error return_value = Error::NO_ERRORS;
+
+    // Groups have no SIZE phase. The caller consumed the START_GROUP tag and set
+    // the phase to DATA.
+    if(::EmbeddedProto::FieldProcessingPhase::DATA == state.phase)
+    {
+      if(nullptr != state.child)
+      {
+        // Stream the child's fields directly from the buffer. The child's partial
+        // deserialize stops (reporting completion) when it consumes its matching
+        // END_GROUP; otherwise it returns END_OF_BUFFER to resume later with the
+        // child state preserved.
+        return_value = this->deserialize_partial(buffer, *state.child);
+        if((Error::NO_ERRORS == return_value)
+           && (::EmbeddedProto::FieldProcessingPhase::COMPLETE == state.child->phase))
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          state.child->reset();
+        }
+      }
+      else
+      {
+        return_value = Error::NESTING_TOO_DEEP;
+      }
+    }
+
+    return return_value;
+  }
+
+  inline Error MessageInterface::skip_unknown_field_partial(::EmbeddedProto::ReadBufferInterface& buffer,
+                                                     MessageState& state) const
+  {
+    Error return_value = Error::STATE_MISMATCH;
+
+    if(::EmbeddedProto::WireFormatter::WireType::VARINT == state.wire_type)
+    {
+      if(::EmbeddedProto::FieldProcessingPhase::DATA == state.phase)
+      {
+        return_value = skip_varint(buffer);
+        if(Error::NO_ERRORS == return_value)
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+        }
+      }
+    }
+    else if(::EmbeddedProto::WireFormatter::WireType::FIXED32 == state.wire_type)
+    {
+      if(::EmbeddedProto::FieldProcessingPhase::DATA == state.phase)
+      {
+        if(0U == state.bytes_remaining)
+        {
+          state.bytes_remaining = 4U;
+        }
+
+        const uint32_t bytes_to_advance = (state.bytes_remaining < buffer.get_size())
+          ? state.bytes_remaining
+          : buffer.get_size();
+
+        buffer.advance(bytes_to_advance);
+        state.bytes_remaining -= bytes_to_advance;
+
+        if(0U == state.bytes_remaining)
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          return_value = Error::NO_ERRORS;
+        }
+        else
+        {
+          return_value = Error::END_OF_BUFFER;
+        }
+      }
+    }
+    else if(::EmbeddedProto::WireFormatter::WireType::FIXED64 == state.wire_type)
+    {
+      if(::EmbeddedProto::FieldProcessingPhase::DATA == state.phase)
+      {
+        if(0U == state.bytes_remaining)
+        {
+          state.bytes_remaining = 8U;
+        }
+
+        const uint32_t bytes_to_advance = (state.bytes_remaining < buffer.get_size())
+          ? state.bytes_remaining
+          : buffer.get_size();
+
+        buffer.advance(bytes_to_advance);
+        state.bytes_remaining -= bytes_to_advance;
+
+        if(0U == state.bytes_remaining)
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          return_value = Error::NO_ERRORS;
+        }
+        else
+        {
+          return_value = Error::END_OF_BUFFER;
+        }
+      }
+    }
+    else if(::EmbeddedProto::WireFormatter::WireType::LENGTH_DELIMITED == state.wire_type)
+    {
+      return_value = Error::NO_ERRORS;
+
+      if(::EmbeddedProto::FieldProcessingPhase::SIZE == state.phase)
+      {
+        return_value = deserialize_partial_size_phase(buffer, state);
+      }
+
+      if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::DATA == state.phase))
+      {
+        const uint32_t bytes_to_advance = (state.bytes_remaining < buffer.get_size())
+          ? state.bytes_remaining
+          : buffer.get_size();
+
+        buffer.advance(bytes_to_advance);
+        state.bytes_remaining -= bytes_to_advance;
+
+        if(0U == state.bytes_remaining)
+        {
+          state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          return_value = Error::NO_ERRORS;
+        }
+        else
+        {
+          return_value = Error::END_OF_BUFFER;
+        }
+      }
+    }
+    else if(::EmbeddedProto::WireFormatter::WireType::START_GROUP == state.wire_type)
+    {
+      // An unknown DELIMITED field: skip the whole group up to its END_GROUP.
+      if(::EmbeddedProto::FieldProcessingPhase::DATA == state.phase)
+      {
+        return_value = skip_group_partial(buffer, state);
+      }
+    }
+
+    return return_value;
+  }
+
+  inline Error MessageInterface::skip_group_partial(::EmbeddedProto::ReadBufferInterface& buffer,
+                                                    MessageState& state) const
+  {
+    Error return_value = Error::NO_ERRORS;
+
+    // The field inside the group currently being skipped, restored from the members of
+    // the group state, see SKIP_GROUP_WIRE_TYPE_SHIFT. It is cleared after every field,
+    // so a resume always continues where the previous buffer ran out: at the next tag
+    // or inside a field value.
+    MessageState field;
+    field.wire_type = skip_group_field_wire_type(state.size_value);
+    field.phase = skip_group_field_phase(state.size_value);
+    field.bytes_remaining = state.bytes_remaining;
+
+    bool continue_skipping = true;
+    while(continue_skipping)
+    {
+      if(::EmbeddedProto::FieldProcessingPhase::TAG == field.phase)
+      {
+        return_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, field.wire_type,
+                                                                      field.field_id);
+        if(Error::NO_ERRORS == return_value)
+        {
+          if(::EmbeddedProto::WireFormatter::WireType::START_GROUP == field.wire_type)
+          {
+            // A nested group, count it and go on with the tags inside it.
+            ++state.element_index;
+          }
+          else if(::EmbeddedProto::WireFormatter::WireType::END_GROUP == field.wire_type)
+          {
+            if(0U == state.element_index)
+            {
+              // The END_GROUP matching the unknown field, the skip is complete.
+              state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+              continue_skipping = false;
+            }
+            else
+            {
+              // The END_GROUP of a nested group.
+              --state.element_index;
+            }
+          }
+          else
+          {
+            field.phase = (::EmbeddedProto::WireFormatter::WireType::LENGTH_DELIMITED == field.wire_type)
+              ? ::EmbeddedProto::FieldProcessingPhase::SIZE
+              : ::EmbeddedProto::FieldProcessingPhase::DATA;
+          }
+        }
+      }
+
+      if(continue_skipping && (Error::NO_ERRORS == return_value)
+         && (::EmbeddedProto::FieldProcessingPhase::TAG != field.phase))
+      {
+        return_value = skip_unknown_field_partial(buffer, field);
+        if((Error::NO_ERRORS == return_value)
+           && (::EmbeddedProto::FieldProcessingPhase::COMPLETE == field.phase))
+        {
+          field.reset();
+        }
+      }
+
+      if(Error::NO_ERRORS != return_value)
+      {
+        continue_skipping = false;
+      }
+    }
+
+    // Store the inner field for the next buffer, or clear it when the group is complete.
+    if(::EmbeddedProto::FieldProcessingPhase::COMPLETE == state.phase)
+    {
+      state.size_value = 0U;
+      state.bytes_remaining = 0U;
+      state.element_index = 0U;
+    }
+    else
+    {
+      state.size_value = pack_skip_group_field(field.wire_type, field.phase);
+      state.bytes_remaining = field.bytes_remaining;
+    }
+
+    return return_value;
+  }
+#endif
+
+
+  inline Error MessageInterface::skip_unknown_field(::EmbeddedProto::ReadBufferInterface& buffer,
+                                             const ::EmbeddedProto::WireFormatter::WireType& wire_type) const
+  {
+    Error return_value = Error::NO_ERRORS;
+
+    // Depending on the wire type select one of its valid variable types and deserialize the value.
+    switch(wire_type) {
+      case ::EmbeddedProto::WireFormatter::WireType::VARINT:
+        return_value = skip_varint(buffer);
+        break;
+
+      case ::EmbeddedProto::WireFormatter::WireType::FIXED64:
+        return_value = skip_fixed64(buffer);
+        break;
+
+      case ::EmbeddedProto::WireFormatter::WireType::LENGTH_DELIMITED:
+        return_value = skip_length_delimited(buffer);
+        break;
+
+      case ::EmbeddedProto::WireFormatter::WireType::FIXED32:
+        return_value = skip_fixed32(buffer);
+        break;
+
+      case ::EmbeddedProto::WireFormatter::WireType::START_GROUP:
+        // An unknown DELIMITED field: skip the whole group up to its END_GROUP.
+        return_value = skip_group(buffer);
+        break;
+
+      default:
+        // We should never get here. DeserializeTag catches this case.
+        break;
+    }
+
+    return return_value;
+  }
+
+  inline Error MessageInterface::skip_group(::EmbeddedProto::ReadBufferInterface& buffer) const
+  {
+    // The opening START_GROUP tag has already been consumed. Read and discard
+    // fields until the matching END_GROUP. Nested groups are skipped recursively
+    // (skip_unknown_field routes START_GROUP back here), so the first END_GROUP
+    // seen at this level is the matching one.
+    Error return_value = Error::NO_ERRORS;
+    bool done = false;
+    while((!done) && (Error::NO_ERRORS == return_value))
+    {
+      ::EmbeddedProto::WireFormatter::WireType wire_type;
+      uint32_t id = 0;
+      return_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id);
+      if(Error::NO_ERRORS == return_value)
+      {
+        if(::EmbeddedProto::WireFormatter::WireType::END_GROUP == wire_type)
+        {
+          done = true;
+        }
+        else
+        {
+          return_value = skip_unknown_field(buffer, wire_type);
+        }
+      }
+    }
+    return return_value;
+  }
+
+
+  inline Error MessageInterface::skip_varint(::EmbeddedProto::ReadBufferInterface& buffer) const
+  {
+    // Use a 64 bit variable to decode the maximum possible number of bytes. As we do not know
+    // the actual type.
+    uint64_t dummy;
+    return ::EmbeddedProto::WireFormatter::DeserializeVarint(buffer, dummy);
+  }
+
+  inline Error MessageInterface::skip_fixed32(::EmbeddedProto::ReadBufferInterface& buffer) const
+  {
+    float dummy;
+    return ::EmbeddedProto::WireFormatter::DeserializeFloat(buffer, dummy);
+  }
+
+  inline Error MessageInterface::skip_fixed64(::EmbeddedProto::ReadBufferInterface& buffer) const
+  {
+    double dummy;
+    return ::EmbeddedProto::WireFormatter::DeserializeDouble(buffer, dummy);
+  }
+
+  inline Error MessageInterface::skip_length_delimited(::EmbeddedProto::ReadBufferInterface& buffer) const
+  {
+    // First read the number of bytes 
+    uint32_t n_bytes = 0;
+    const Error return_value = ::EmbeddedProto::WireFormatter::DeserializeVarint(buffer, n_bytes);
+    if(Error::NO_ERRORS == return_value)
+    {
+      buffer.advance(n_bytes);
+    }
+    return return_value;
+  }
+
+} // End of namespace EmbeddedProto
+
+#endif // _MESSAGE_INTERFACE_H_