EmbeddedProto 4.0.0b1__py3-none-any.whl

EmbeddedProto/src/EmbeddedProto/MessageSizeCalculator.h

@@ -0,0 +1,109 @@
+/*
+ *  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_SIZE_CALCULATOR_H_
+#define _MESSAGE_SIZE_CALCULATOR_H_
+
+#include "WriteBufferInterface.h"
+
+#include <cstdint>
+#include <limits> 
+
+
+namespace EmbeddedProto 
+{
+  //! This class is used in a message to calculate the current serialized size.
+  /*!
+      To calculate the size of a message given the current data a dummy serialization is performed.
+      This class mimics the buffer in which the data is stored. Instead of storing it, only the 
+      size is incremented for the bytes pushed. No actual data is pushed into a buffer.
+
+      \see MessageInterface::serialized_size()  
+  */
+  class MessageSizeCalculator : public WriteBufferInterface
+  {
+    public:
+      MessageSizeCalculator() = default;
+      ~MessageSizeCalculator() = default;
+      
+      //! Reset the size count of the buffer.
+      void clear() override 
+      { 
+        size_ = 0; 
+      }
+
+      //! Obtain the total number of bytes currently stored in the buffer.
+      uint32_t get_size() const override 
+      { 
+        return size_; 
+      }
+
+      //! To continue serialization return the maximum number that fits in a 32bit unsigned int.
+      uint32_t get_max_size() const override 
+      { 
+        return std::numeric_limits<uint32_t>::max(); 
+      }
+
+      //! To continue serialization return the maximum number that fits in a 32bit unsigned int.
+      uint32_t get_available_size() const override 
+      { 
+        return std::numeric_limits<uint32_t>::max(); 
+      }
+
+      //! For calculating the size we just increment the counter and always return true.
+      bool push(const uint8_t byte) override
+      {
+        // Ignore the unused parameter
+        (void)byte;
+        ++size_;
+        return true;
+      }
+
+      //! Keep the pointer and length form of push() reachable next to the override below.
+      using WriteBufferInterface::push;
+
+      //! Increment the size with the number of bytes in the view.
+      bool push(const const_bytes_view& bytes) override
+      {
+        size_ += bytes.size;
+        return true;
+      }
+
+      //! Only the count matters here, so account for the bytes without receiving them.
+      bool count_only(const uint32_t number_of_bytes) override
+      {
+        size_ += number_of_bytes;
+        return true;
+      }
+
+
+    private:
+
+      //! The calculated size of the buffer.
+      uint32_t size_ = 0;
+
+  }; // End of class MessageSizeCalculator
+
+} // End of namespace EmbeddedProto
+
+#endif 

EmbeddedProto/src/EmbeddedProto/MessageState.h

@@ -0,0 +1,207 @@
+/*
+ *  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_STATE_H_
+#define _MESSAGE_STATE_H_
+
+#include "WireFormatter.h"
+
+#include <array>
+#include <cstdint>
+
+namespace EmbeddedProto 
+{
+
+  //! Phase of field processing for partial serialization/deserialization.
+  enum class FieldProcessingPhase : uint8_t 
+  {
+    TAG = 0,       //<! Reading/writing field tag (field number + wire type)
+    SIZE = 1,      //<! Reading/writing length prefix (for LENGTH_DELIMITED fields)
+    DATA = 2,      //<! Reading/writing actual field data
+    COMPLETE = 3   //<! Done with this field, ready for next
+  };
+
+  //! State for partial serialization/deserialization of a single message.
+  /*!
+      This structure tracks the current state of a message during partial 
+      serialization or deserialization. It is used for both operations to 
+      maintain consistency.
+  */
+  struct MessageState 
+  {
+      //! Default phase for a new field operation.
+      static constexpr::EmbeddedProto::FieldProcessingPhase INITIAL_PHASE = ::EmbeddedProto::FieldProcessingPhase::TAG;
+
+      //! Default wire type value.
+      static constexpr WireFormatter::WireType INITIAL_WIRE_TYPE = WireFormatter::WireType::VARINT;
+
+      //! Current phase of field processing.
+     ::EmbeddedProto::FieldProcessingPhase phase = INITIAL_PHASE;
+      
+      //! Field number from protobuf definition (1-based, from tag or next to serialize).
+      uint32_t field_id = 0;
+      
+      //! Wire type from tag (deserialization only, but stored here for simplicity).
+      WireFormatter::WireType wire_type = INITIAL_WIRE_TYPE;
+      
+      //! For repeated fields: index of current element (0-based).
+      uint32_t element_index = 0;
+      
+      //! For length-delimited fields: bytes remaining to read/write.
+      uint32_t bytes_remaining = 0;
+      
+      //! For length-delimited fields: the size once calculated when serializing or read when deserializing.
+      uint32_t size_value = 0;
+      
+      //! Pointer to child state for nested messages (null if leaf).
+      MessageState* child = nullptr;
+      
+      //! Default constructor.
+      MessageState() = default;
+      
+
+      //! Reset this state and every state below it to the initial values.
+      /*!
+          A state is reused whenever a message starts over at its level, for instance for
+          the next element of a repeated message field. The nested messages of that element
+          used the states further down the chain, so those are reset as well. Otherwise a
+          stale COMPLETE phase two levels down silently skips the nested message of the
+          next element. The child pointers themselves are kept, they are set at construction.
+      */
+      void reset()
+      {
+        for(MessageState* state = this; nullptr != state; state = state->child)
+        {
+          state->phase = INITIAL_PHASE;
+          state->field_id = 0;
+          state->wire_type = INITIAL_WIRE_TYPE;
+          state->element_index = 0;
+          state->bytes_remaining = 0;
+          state->size_value = 0;
+        }
+      }
+      
+    protected:
+      // Protected copy/move to prevent slicing - state should be managed via MessageStateStack
+      MessageState(const MessageState&) = default;
+      MessageState(MessageState&&) = default;
+      MessageState& operator=(const MessageState&) = default;
+      MessageState& operator=(MessageState&&) = default;
+  };
+
+  //! Fixed-size stack of MessageState objects for nested message handling.
+  /*!
+      This template class provides a compile-time fixed array of MessageState 
+      objects, linked together to support nested message serialization and 
+      deserialization.
+      
+      \tparam DEPTH The maximum nesting depth this stack can handle.
+  */
+  template<uint32_t DEPTH>
+  class MessageStateStack 
+  {
+      static_assert(DEPTH > 0U, "MessageStateStack needs a DEPTH of at least one: the root message "
+                                "state lives at index zero and the constructor links DEPTH - 1 child states.");
+
+    public:
+      //! Constructor - links states together in parent-child chain.
+      MessageStateStack() 
+      {
+        // Link states together: parent -> child
+        // states_[0] is the root (outermost message)
+        // states_[DEPTH-1] is the deepest possible nested message
+        for(uint32_t i = 0; i < DEPTH - 1; ++i) 
+        {
+          states_[i].child = &states_[i + 1];
+        }
+        // states_[DEPTH-1].child remains nullptr (leaf)
+      }
+      
+      //! Default destructor.
+      ~MessageStateStack() = default;
+      
+      //! Get the root state (for the outermost message).
+      /*!
+          \return Reference to the root MessageState.
+      */
+      MessageState& root() 
+      { 
+        return states_[0]; 
+      }
+      
+      //! Get the root state (for the outermost message) - const version.
+      /*!
+          \return Const reference to the root MessageState.
+      */
+      const MessageState& root() const 
+      { 
+        return states_[0]; 
+      }
+      
+      //! Get the state at a specific depth.
+      /*!
+          \param depth 0 = root, 1 = first nested level, etc.
+          \return Reference to the MessageState at the specified depth.
+      */
+      MessageState& at(uint32_t depth) 
+      { 
+        return states_[depth]; 
+      }
+      
+      //! Get the state at a specific depth - const version.
+      /*!
+          \param depth 0 = root, 1 = first nested level, etc.
+          \return Const reference to the MessageState at the specified depth.
+      */
+      const MessageState& at(uint32_t depth) const 
+      { 
+        return states_[depth]; 
+      }
+      
+      //! Reset all states to initial values.
+      /*!
+          The root state resets every state below it through the child chain, so one call
+          covers the whole stack.
+      */
+      void reset() 
+      {
+        states_[0].reset();
+      }
+      
+      //! Get the maximum depth this stack can handle.
+      /*!
+          \return The template parameter DEPTH value.
+      */
+      static constexpr uint32_t max_depth() 
+      { 
+        return DEPTH; 
+      }
+      
+    private:
+      //! The array of message states.
+      std::array<MessageState, DEPTH> states_{};
+  };
+
+} // namespace EmbeddedProto
+
+#endif // End of _MESSAGE_STATE_H_

EmbeddedProto/src/EmbeddedProto/ReadBufferFixedSize.h

@@ -0,0 +1,204 @@
+/*
+ *  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 _READ_BUFFER_FIXED_H_
+#define _READ_BUFFER_FIXED_H_
+
+#include "ReadBufferInterface.h"
+#include <array>
+#include <cstring>
+#include <initializer_list>
+
+namespace EmbeddedProto 
+{
+
+  //! This template class implements the ReadBufferInterface.
+  /*!
+      The template sets the number of bytes which fit in the buffer.
+  */
+  template<uint32_t BUFFER_SIZE>
+  class ReadBufferFixedSize : public ::EmbeddedProto::ReadBufferInterface
+  {
+    public:
+      //! The default constructor which initializes everything at zero.
+      ReadBufferFixedSize() = default;
+
+      ReadBufferFixedSize(std::initializer_list<uint8_t> init_list)
+      {
+        // TODO static_assert(init_list.size() <= BUFFER_SIZE, "Initializer does not fit in buffer."); 
+        set_bytes_written(init_list.size());
+        std::copy(init_list.begin(), init_list.end(), data_.begin());
+      }
+
+      //! The default destructor.
+      ~ReadBufferFixedSize() = default;
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::get_size()
+      uint32_t get_size() const override
+      {
+        return write_index_ - read_index_;
+      }
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::get_max_size()
+      uint32_t get_max_size() const override
+      {
+        return BUFFER_SIZE;
+      }
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::peek(uint8_t& byte)
+      bool peek(uint8_t& byte) const override
+      {
+        const bool return_value = write_index_ > read_index_;
+        if(return_value)
+        {
+          byte = data_[read_index_];
+        }
+        return return_value;
+      }
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::peek(const int32_t n, uint8_t& byte)
+      bool peek(const uint32_t n_bytes, uint8_t& byte) const override
+      {
+        const bool return_value = write_index_ > (read_index_ + n_bytes);
+        if(return_value)
+        {
+          byte = data_[read_index_ + n_bytes];
+        }
+        return return_value;
+      }
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::advance()
+      bool advance() override
+      {
+        const bool return_value = write_index_ > read_index_;
+        if(return_value)
+        {
+          ++read_index_;
+        }
+        return return_value;
+      }
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::advance(const uint32_t N)
+      bool advance(const uint32_t n_bytes) override
+      {
+        const uint32_t new_read_index = read_index_ + n_bytes;
+        const bool return_value = write_index_ >= new_read_index;
+        if(return_value)
+        {
+          read_index_ = new_read_index;
+        }
+        return return_value;
+      }
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::pop()
+      bool pop(uint8_t& byte) override
+      {
+        const bool return_value = write_index_ > read_index_;
+        if(return_value)
+        {
+          byte = data_[read_index_];
+          ++read_index_;
+        }
+        return return_value;
+      }
+
+      //! Keep the single byte forms of peek() reachable next to the override below.
+      using ReadBufferInterface::peek;
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::peek(const bytes_view&)
+      bool peek(const bytes_view& dest) const override
+      {
+        const bool return_value = (write_index_ - read_index_) >= dest.size;
+        if(return_value)
+        {
+          memcpy(dest.data, data_.data() + read_index_, dest.size);
+        }
+        return return_value;
+      }
+
+      //! Keep the pointer and length form of pop() reachable next to the override below.
+      using ReadBufferInterface::pop;
+
+      //! \see ::EmbeddedProto::ReadBufferInterface::pop(const bytes_view&)
+      bool pop(const bytes_view& dest) override
+      {
+        // All-or-nothing: only copy and advance when the whole block is present.
+        const bool return_value = (write_index_ - read_index_) >= dest.size;
+        if(return_value)
+        {
+          memcpy(dest.data, data_.data() + read_index_, dest.size);
+          read_index_ += dest.size;
+        }
+        return return_value;
+      }
+
+      //! Return a pointer to the data array. Use set_bytes_written() when adding data to the array.
+      uint8_t* get_data()
+      {
+        return data_.data();
+      }
+
+      //! Set the amount of bytes copied to the buffer when using get_data_array().
+      void set_bytes_written(const uint32_t n_bytes)
+      {
+        write_index_ = std::min(n_bytes, BUFFER_SIZE);
+      }
+
+      //! Clear all indices, in effect allowing the data to be overwritten.
+      void clear()
+      {
+        read_index_ = 0;
+        write_index_ = 0;
+      }
+
+      //! Push a signle byte of data into the buffer.
+      /*!
+        \tip If you receive a whole message at once consider using get_data_array() in combination 
+             with set_bytes_written().
+      */
+      bool push(const uint8_t& byte)
+      {
+        const bool return_value = BUFFER_SIZE > write_index_;
+        if(return_value)
+        {
+          data_[write_index_] = byte;
+          ++write_index_;
+        }
+        return return_value;
+      }
+
+    private:
+
+      //! The array in which the data received over uart is stored.
+      std::array<uint8_t, BUFFER_SIZE> data_ = {0};
+
+      //! The number of bytes currently received and stored in the data array.
+      uint32_t write_index_ = 0;
+
+      //! The number of bytes read from the data array.
+      uint32_t read_index_ = 0;
+  };
+
+} // namespace EmbeddedProto
+
+#endif // End of _READ_BUFFER_FIXED_H_

EmbeddedProto/src/EmbeddedProto/ReadBufferInterface.h

@@ -0,0 +1,181 @@
+/*
+ *  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 _READ_BUFFER_INTERFACE_H_
+#define _READ_BUFFER_INTERFACE_H_
+
+#include "Defines.h"
+
+#include <cstdint>
+
+
+namespace EmbeddedProto 
+{
+  //! The pure virtual definition of a message buffer to read from.
+  /*!
+      The buffer deals with bytes (uint8_t) only.
+  */
+  class ReadBufferInterface
+  {
+    public:
+
+      ReadBufferInterface() = default;
+
+#ifdef VIRTUAL_DESTRUCTORS_ENABLED
+      virtual ~ReadBufferInterface() = default;
+#else
+    protected:
+      //! Protected and non-virtual by default, see VIRTUAL_DESTRUCTORS_ENABLED in Defines.h.
+      ~ReadBufferInterface() = default;
+
+    public:
+#endif
+
+      //! Obtain the total number of bytes currently stored in the buffer.
+      virtual uint32_t get_size() const = 0;
+
+      //! Obtain the total number of bytes which can at most be stored in the buffer.
+      virtual uint32_t get_max_size() const = 0;
+
+      //! Obtain the value of the oldest byte in the buffer.
+      /*!
+          This function will not alter the buffer read index.
+          
+          The parameter byte will not be set if the buffer was empty.
+
+          \param[out] byte When the buffer is not empty this variable will hold the oldest value.
+          \return True when the buffer was not empty.
+      */
+      virtual bool peek(uint8_t& byte) const = 0;
+
+
+      //! Obtain the value of a byte which will be returned after calling pop() N times.
+      /*!
+          This function will not alter the buffer read index.
+          
+          The parameter byte will not be set if the buffer was empty.
+
+          \param[in] n_bytes The number of bytes to read a head.
+          \param[out] byte When the buffer is not empty this variable will hold the oldest value.
+          \return True not exceesing the buffer limits.
+      */
+      virtual bool peek(const uint32_t n_bytes, uint8_t& byte) const = 0;
+
+      //! Advances the internal read index by one when the buffer is not empty.
+      /*!
+          \return True when the buffer was not empty.
+      */
+      virtual bool advance() = 0;
+
+      //! Advances the internal read index by the given value.
+      /*!
+          The advance is limited to the number of bytes in the buffer.
+          \param[in] n_bytes The number of bytes to advance the read index.
+          \return True when the buffer held the n_bytes or more.
+      */
+      virtual bool advance(const uint32_t n_bytes) = 0;
+
+      //! Obtain the value of the oldest byte in the buffer and remove it from the buffer.
+      /*!
+          This function will alter the internal read index.
+
+          The parameter byte will not be set if the buffer was empty.
+
+          \param[out] byte When the buffer is not empty this variable will hold the oldest value.
+          \return True when the buffer was not empty.
+      */
+      virtual bool pop(uint8_t& byte) = 0;
+
+      //! Copy a block of bytes out of the buffer, advancing the read index.
+      /*!
+          This is the batched counterpart of pop(uint8_t&): it lets callers read
+          a whole fixed-width value, a run of them or a string payload in one
+          virtual call instead of one call per byte.
+
+          The operation is all-or-nothing: when fewer than dest.size bytes are
+          available nothing is copied and the read index is left unmoved, matching
+          the advance(n_bytes) / pop() semantics which never partially consume the
+          buffer.
+
+          The default implementation pops the bytes one at a time. Concrete buffers
+          are encouraged to override it with a single block copy (e.g. memcpy) so
+          the batching actually reduces the number of operations.
+
+          \param[out] dest A view on the destination array, dest.size bytes are copied into it.
+          \return True when dest.size bytes were available and copied into dest.
+      */
+      virtual bool pop(const bytes_view& dest)
+      {
+        bool result = get_size() >= dest.size;
+        for(uint32_t i = 0; result && (i < dest.size); ++i)
+        {
+          result = pop(dest.data[i]);
+        }
+        return result;
+      }
+
+      //! Copy a block of bytes out of the buffer without advancing the read index.
+      /*!
+          This is the batched counterpart of peek(n_bytes, byte): the bytes stay in
+          the buffer, so a caller which may consume only part of the block, such as a
+          callback field offering a window, reads it in one virtual call and calls
+          advance() for the part it accepted.
+
+          All-or-nothing like pop(const bytes_view&): when fewer than dest.size bytes
+          are available nothing is copied.
+
+          The default implementation peeks the bytes one at a time. Concrete buffers
+          are encouraged to override it with a single block copy.
+
+          \param[out] dest A view on the destination array, dest.size bytes are copied into it.
+          \return True when dest.size bytes were available and copied into dest.
+      */
+      virtual bool peek(const bytes_view& dest) const
+      {
+        bool result = get_size() >= dest.size;
+        for(uint32_t i = 0; result && (i < dest.size); ++i)
+        {
+          result = peek(i, dest.data[i]);
+        }
+        return result;
+      }
+
+      //! Copy a block of bytes out of the buffer, pointer and length form of pop(const bytes_view&).
+      /*!
+          \deprecated Use the array_view overload pop(const bytes_view&), a view keeps the
+                      pointer and its bound together.
+          \param[out] dest   Destination array which must be able to hold length bytes.
+          \param[in]  length The number of bytes to copy out of the buffer.
+          \return True when length bytes were available and copied into dest.
+      */
+      [[deprecated("use the array_view overload pop(const bytes_view&)")]]
+      virtual bool pop(uint8_t* dest, const uint32_t length)
+      {
+        return pop(bytes_view{dest, length});
+      }
+
+  };
+
+} // End of namespace EmbeddedProto
+
+#endif // End of _READ_BUFFER_INTERFACE_H_