EmbeddedProto 4.0.0b1__py3-none-any.whl

EmbeddedProto/src/EmbeddedProto/BytesStringCallback.h

@@ -0,0 +1,476 @@
+/*
+ *  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 _BYTES_STRING_CALLBACK_H_
+#define _BYTES_STRING_CALLBACK_H_
+
+#include "FieldStringBytes.h"
+#include "Functional.h"
+#include "Errors.h"
+#include "Defines.h"
+#include "WireFormatter.h"
+
+#include <cstdint>
+#include <type_traits>
+
+
+namespace EmbeddedProto
+{
+
+  //! A bytes/string field whose payload is streamed to/from the user in windows, not stored.
+  /*!
+      BytesStringCallback is the storage type of a singular bytes or string field
+      with the callbackStorage option. It keeps no value resident: the value moves
+      across the interface seam a window at a time, so a large blob (a firmware
+      image, a log, a picture) streams through the message in slices that never
+      add up to a whole value:
+
+        - on deserialize, every freshly parsed window is offered to the user
+          deserialize chunk callback, which returns how many elements it accepted;
+        - on serialize, a writable window is handed to the user serialize chunk
+          callback, which fills it and returns how many elements it produced.
+
+      No offset is passed. A stateful callback tracks its own position.
+
+      Serialize needs the total length up front for the LEN prefix, so the user
+      declares it once with set_length() before the first window is pulled. The
+      prefix is then written from that length and serialized_size() reports it
+      without pulling any data. Deserialize needs no such declaration, the wire
+      carries the length.
+
+      The buffer interfaces hand out no contiguous memory, so every window is
+      staged in memory the user binds with set_window(): a view over an array the
+      platform owns, a static array, a DMA buffer or a scratch region shared
+      between fields. Its size is the largest window a callback is offered. The
+      field itself holds only the view, not the window, so the message size does
+      not depend on the platform. One window serves both directions, a field never
+      serializes and deserializes at the same time. A window of one element gives
+      byte-by-byte streaming when that is all the user wants. The class derives
+      from internal::BaseStringBytes and satisfies the same static_assert the
+      customStorage mechanism checks.
+
+      \tparam DATA_TYPE The element type: char for a string field, uint8_t for a
+                        bytes field.
+  */
+  template<class DATA_TYPE>
+  class BytesStringCallback : public internal::BaseStringBytes
+  {
+    static_assert(std::is_same<uint8_t, DATA_TYPE>::value || std::is_same<char, DATA_TYPE>::value,
+                  "This class only supports uint8_t or chars.");
+
+    public:
+
+      //! The window handed to a callback: string_view for a string field, bytes_view for a bytes field.
+      using VIEW = array_view<DATA_TYPE>;
+
+      //! Chunk callback shared by both directions, see set_on_serialize_chunk() and set_on_deserialize_chunk().
+      using ChunkCallback = Functional<uint32_t(VIEW)>;
+
+      BytesStringCallback() = default;
+      ~BytesStringCallback() = default;
+
+      // --- Binding (reference-taking, no ownership) --------------------------
+
+      //! Bind the callback that fills windows during serialization.
+      /*!
+        The callback receives a writable window of up to the bound window's size
+        and returns how many it produced, at most the window size. Zero before the
+        declared length is reached ends the stream early, which is reported as
+        CALLBACK_SIZE_MISMATCH. The callback is not called once the declared
+        length is reached.
+      */
+      void set_on_serialize_chunk(const ChunkCallback& callback) { on_serialize_chunk_ = callback; }
+
+      //! Bind the callback that receives windows during deserialization.
+      /*!
+        The callback receives a window of freshly parsed elements it should read
+        and not modify, and returns how many it accepted. Returning less than the
+        window size stops the field: deserialization returns CALLBACK_STOPPED.
+        Under partial deserialization the accepted elements are consumed and the
+        state stays resumable, so a caller may retry after the callback has room
+        again.
+      */
+      void set_on_deserialize_chunk(const ChunkCallback& callback) { on_deserialize_chunk_ = callback; }
+
+      //! Bind the memory the windows are staged in; its size is the largest window a callback is offered.
+      /*!
+        The view does not own the array, which must outlive every serialize or
+        deserialize call, like the bound callbacks. Streaming without a window
+        bound is CALLBACK_NOT_SET.
+      */
+      void set_window(const VIEW& window) { window_ = window; }
+
+      //! Remove the bound window.
+      void clear_window() { window_ = VIEW{nullptr, 0U}; }
+
+      //! Check whether a usable window is bound.
+      bool is_window_set() const { return (nullptr != window_.data) && (0U < window_.size); }
+
+      //! Remove the bound serialize chunk callback.
+      void clear_on_serialize_chunk() { on_serialize_chunk_.clear(); }
+
+      //! Remove the bound deserialize chunk callback.
+      void clear_on_deserialize_chunk() { on_deserialize_chunk_.clear(); }
+
+      //! Check whether a serialize chunk callback is bound.
+      bool is_on_serialize_chunk_set() const { return on_serialize_chunk_.is_set(); }
+
+      //! Check whether a deserialize chunk callback is bound.
+      bool is_on_deserialize_chunk_set() const { return on_deserialize_chunk_.is_set(); }
+
+      //! Declare the total number of elements the serialize chunk callback will produce, written as the LEN prefix.
+      void set_length(const uint32_t length) { length_ = length; }
+
+      //! Require a binding for the direction being used.
+      /*!
+        When strict, deserializing without a chunk callback bound returns
+        CALLBACK_NOT_SET instead of silently discarding the value.
+      */
+      void set_strict(bool strict) { strict_ = strict; }
+
+      //! Whether strict (require-binding) mode is enabled.
+      bool is_strict() const { return strict_; }
+
+      //! Copy the bindings, the window and the declared length from another chunked field (used by the generated message copy/assignment).
+      /*!
+        \return Always NO_ERRORS, for signature compatibility with FieldStringBytes::set().
+      */
+      Error set(const BytesStringCallback<DATA_TYPE>& rhs)
+      {
+        on_serialize_chunk_ = rhs.on_serialize_chunk_;
+        on_deserialize_chunk_ = rhs.on_deserialize_chunk_;
+        window_ = rhs.window_;
+        length_ = rhs.length_;
+        strict_ = rhs.strict_;
+        return Error::NO_ERRORS;
+      }
+
+      // --- FieldStringBytes-shaped interface ---------------------------------
+
+      //! The declared payload length written as the LEN prefix, see set_length().
+      uint32_t get_length() const { return length_; }
+
+      //! Streaming is effectively unbounded; report a large sentinel so capacity checks never fire.
+      uint32_t get_max_length() const { return UINT32_MAX; }
+
+      //! The number of elements the bound window holds, the largest window a callback is offered (0 when unbound).
+      uint32_t get_window_size() const { return is_window_set() ? window_.size : 0U; }
+
+      //! Required of a customStorage bytes/string type.
+      /*!
+        A stream has no finite serialized size, so report the unbounded sentinel; a
+        message with a chunked field therefore cannot be statically buffer-sized,
+        which is inherent to streaming.
+      */
+      static constexpr uint32_t max_serialized_size(const uint32_t field_number)
+      {
+        static_cast<void>(field_number);
+        return UINT32_MAX;
+      }
+
+      //! Pull the payload in windows from the bound callback and write it (no tag, no size; the caller frames it with serialize_len).
+      /*!
+          Windows are pulled until exactly get_length() elements are written. A
+          non-empty value with no callback or no window bound cannot be produced:
+          CALLBACK_NOT_SET.
+      */
+      Error serialize(WriteBufferInterface& buffer) const override
+      {
+        Error return_value = Error::NO_ERRORS;
+        uint32_t remaining = length_;
+        if(0U == remaining)
+        {
+          // Nothing declared to emit; the caller wrote an empty (or no) prefix.
+        }
+        else if(!on_serialize_chunk_.is_set() || !is_window_set())
+        {
+          return_value = Error::CALLBACK_NOT_SET;
+        }
+        else
+        {
+          while((0U < remaining) && (Error::NO_ERRORS == return_value))
+          {
+            return_value = pull_window(buffer, remaining);
+          }
+        }
+        return return_value;
+      }
+
+      //! Read the LEN prefix, then offer each parsed window to the bound callback (drain-and-discard when unbound and not strict).
+      Error deserialize(ReadBufferInterface& buffer) override
+      {
+        uint32_t remaining = 0U;
+        Error return_value = WireFormatter::DeserializeVarint(buffer, remaining);
+        while((0U < remaining) && (Error::NO_ERRORS == return_value))
+        {
+          return_value = offer_window(buffer, remaining);
+        }
+        return return_value;
+      }
+
+      //! Validate the wire type is length-delimited, then deserialize.
+      Error deserialize_check_type(::EmbeddedProto::ReadBufferInterface& buffer,
+                                   const ::EmbeddedProto::WireFormatter::WireType& wire_type) override
+      {
+        Error return_value = ::EmbeddedProto::WireFormatter::WireType::LENGTH_DELIMITED == wire_type
+                             ? Error::NO_ERRORS : Error::INVALID_WIRETYPE;
+        if(Error::NO_ERRORS == return_value)
+        {
+          return_value = this->deserialize(buffer);
+        }
+        return return_value;
+      }
+
+#ifdef PARTIAL_SERIALIZATION_ENABLED
+      //! Resumable window-serialize for the partial engine.
+      /*!
+          The TAG and SIZE phases write the tag and the declared length, so the
+          field survives a write buffer that splits before the payload. The DATA
+          phase pulls one window at a time, never larger than the room left in the
+          buffer, so a produced window is never lost on a BUFFER_FULL resume. The
+          callback's own cursor is the resumable state.
+      */
+      Error serialize_partial_as_field(uint32_t field_number,
+                                       WriteBufferInterface& buffer,
+                                       MessageState& state,
+                                       bool optional) const override
+      {
+        Error return_value = Error::NO_ERRORS;
+        if(::EmbeddedProto::FieldProcessingPhase::DATA != state.phase)
+        {
+          return_value = serialize_partial_tag_and_size(field_number, length_, buffer, state, optional);
+        }
+
+        if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::DATA == state.phase))
+        {
+          if(!on_serialize_chunk_.is_set() || !is_window_set())
+          {
+            return_value = Error::CALLBACK_NOT_SET;
+          }
+          else
+          {
+            while((0U < state.bytes_remaining) && (Error::NO_ERRORS == return_value))
+            {
+              return_value = pull_window(buffer, state.bytes_remaining);
+            }
+            if(0U == state.bytes_remaining)
+            {
+              state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+            }
+          }
+        }
+        return return_value;
+      }
+
+      //! Resumable window-deserialize for the partial engine.
+      /*!
+          The SIZE phase reads the LEN prefix into state.bytes_remaining; the DATA
+          phase offers windows to the callback, decrementing bytes_remaining, and
+          returns END_OF_BUFFER (leaving the phase at DATA) when the read buffer
+          drains mid-value so the next call resumes where it stopped. A window is
+          at most what the buffer holds, so a refill boundary simply ends a window.
+      */
+      Error deserialize_partial_as_field(ReadBufferInterface& buffer,
+                                         MessageState& state) override
+      {
+        Error return_value = Error::NO_ERRORS;
+        if((::EmbeddedProto::FieldProcessingPhase::SIZE != state.phase) && (::EmbeddedProto::FieldProcessingPhase::DATA != state.phase))
+        {
+          return_value = Error::STATE_MISMATCH;
+        }
+
+        if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::SIZE == state.phase))
+        {
+          return_value = deserialize_partial_size_phase(buffer, state);
+        }
+
+        if((Error::NO_ERRORS == return_value) && (::EmbeddedProto::FieldProcessingPhase::DATA == state.phase))
+        {
+          while((0U < state.bytes_remaining) && (Error::NO_ERRORS == return_value))
+          {
+            return_value = offer_window(buffer, state.bytes_remaining);
+          }
+          if(0U == state.bytes_remaining)
+          {
+            state.phase = ::EmbeddedProto::FieldProcessingPhase::COMPLETE;
+          }
+        }
+        return return_value;
+      }
+#endif // PARTIAL_SERIALIZATION_ENABLED
+
+      //! Forget the declared length; the bindings and the window are kept.
+      void clear() override { length_ = 0U; }
+
+#ifdef MSG_TO_STRING
+      //! A callback field holds no resident value to print, so leave the string unchanged.
+      ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override
+      {
+        static_cast<void>(indent_level);
+        static_cast<void>(name);
+        static_cast<void>(first_field);
+        return str;
+      }
+#endif // MSG_TO_STRING
+
+    private:
+
+      //! Pull one window from the serialize callback and push it into the buffer.
+      /*!
+          The window offered is the smallest of the bound window, the elements
+          still to write and the room left in the buffer, so what the callback
+          produces always fits. No room at all is BUFFER_FULL before anything is pulled.
+
+          \param[in] buffer The buffer to write to.
+          \param[in,out] remaining The number of elements still to write, decremented by what was produced.
+      */
+      Error pull_window(WriteBufferInterface& buffer, uint32_t& remaining) const
+      {
+        Error return_value = Error::NO_ERRORS;
+        const uint32_t offered = min(min(window_.size, remaining), buffer.get_available_size());
+        if(0U == offered)
+        {
+          return_value = Error::BUFFER_FULL;
+        }
+        else
+        {
+          uint32_t produced = 0U;
+          static_cast<void>(on_serialize_chunk_.invoke(produced, VIEW{window_.data, offered}));
+          if((0U == produced) || (offered < produced))
+          {
+            return_value = Error::CALLBACK_SIZE_MISMATCH;
+          }
+          else if(!buffer.push(const_bytes_view{window_bytes(), produced}))
+          {
+            return_value = Error::BUFFER_FULL;
+          }
+          else
+          {
+            remaining -= produced;
+          }
+        }
+        return return_value;
+      }
+
+      //! Peek one window out of the buffer, offer it to the deserialize callback and consume what it accepted.
+      /*!
+          The window offered is the smallest of the bound window, the elements
+          still to read and the bytes the buffer holds. An empty buffer is
+          END_OF_BUFFER before anything is consumed. Without a window nothing can
+          be offered: CALLBACK_NOT_SET. Without a callback no window is needed to
+          drain and discard. The window is peeked, not popped, so only
+          the accepted elements leave the buffer and a stopped field can resume.
+
+          \param[in] buffer The buffer to read from.
+          \param[in,out] remaining The number of elements still to read, decremented by what was accepted.
+      */
+      Error offer_window(ReadBufferInterface& buffer, uint32_t& remaining)
+      {
+        Error return_value = Error::NO_ERRORS;
+        const uint32_t offered = min(remaining, buffer.get_size());
+        if(0U == offered)
+        {
+          return_value = Error::END_OF_BUFFER;
+        }
+        else if(on_deserialize_chunk_.is_set())
+        {
+          if(!is_window_set())
+          {
+            return_value = Error::CALLBACK_NOT_SET;
+          }
+          else
+          {
+            return_value = offer_to_callback(buffer, remaining, min(window_.size, offered));
+          }
+        }
+        else if(strict_)
+        {
+          return_value = Error::CALLBACK_NOT_SET;
+        }
+        else
+        {
+          // No callback bound and not strict: drain and discard.
+          static_cast<void>(buffer.advance(offered));
+          remaining -= offered;
+        }
+        return return_value;
+      }
+
+      //! Peek the offered elements into the window, hand it to the callback and consume what it accepted.
+      Error offer_to_callback(ReadBufferInterface& buffer, uint32_t& remaining, const uint32_t offered)
+      {
+        Error return_value = Error::NO_ERRORS;
+        // The bytes stay in the buffer until the callback says how many it accepted.
+        static_cast<void>(buffer.peek(bytes_view{window_bytes(), offered}));
+
+        uint32_t accepted = 0U;
+        static_cast<void>(on_deserialize_chunk_.invoke(accepted, VIEW{window_.data, offered}));
+        if(offered < accepted)
+        {
+          return_value = Error::CALLBACK_SIZE_MISMATCH;
+        }
+        else
+        {
+          static_cast<void>(buffer.advance(accepted));
+          remaining -= accepted;
+          if(accepted < offered)
+          {
+            return_value = Error::CALLBACK_STOPPED;
+          }
+        }
+        return return_value;
+      }
+
+      //! The window as writable bytes, the unit the read buffer fills.
+      uint8_t* window_bytes()
+      {
+        void* void_pointer = static_cast<void*>(window_.data);
+        return static_cast<uint8_t*>(void_pointer);
+      }
+
+      //! The window as bytes, the unit the write buffer takes.
+      const uint8_t* window_bytes() const
+      {
+        const void* void_pointer = static_cast<const void*>(window_.data);
+        return static_cast<const uint8_t*>(void_pointer);
+      }
+
+      //! When true, deserializing without a bound callback is an error rather than a silent drain.
+      bool strict_ = false;
+
+      //! The declared payload length written as the LEN prefix.
+      uint32_t length_ = 0U;
+
+      //! The user supplied memory the windows are staged in; its size bounds every window offered.
+      VIEW window_{nullptr, 0U};
+
+      //! Callback invoked to fill a window while serializing.
+      ChunkCallback on_serialize_chunk_{};
+
+      //! Callback invoked with a parsed window while deserializing.
+      ChunkCallback on_deserialize_chunk_{};
+  };
+
+} // End of namespace EmbeddedProto
+
+#endif // End of _BYTES_STRING_CALLBACK_H_

EmbeddedProto/src/EmbeddedProto/Defines.h

@@ -0,0 +1,118 @@
+/*
+ *  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 _EMBEDDED_PROTO_DEFINES_H_
+#define _EMBEDDED_PROTO_DEFINES_H_
+
+#include <type_traits>
+#include <cstdint>
+
+#if __cplusplus >= 201703L // C++17 and up
+#include <memory>
+#endif
+
+namespace EmbeddedProto
+{
+
+//! Define PARTIAL_SERIALIZATION_ENABLED to enable partial (chunked) serialization
+//! and deserialization. When defined the generated messages and the library gain
+//! the serialize_partial()/deserialize_partial() methods, which allow (de)serialization
+//! to be paused when a buffer is exhausted and resumed with a fresh buffer.
+//! When the macro is not defined only the regular, single-call serialize()/deserialize()
+//! are available.
+
+//! Define VIRTUAL_DESTRUCTORS_ENABLED to give the Field, ReadBufferInterface and
+//! WriteBufferInterface base classes a public virtual destructor.
+/*!
+    By default those destructors are protected and non-virtual: objects are destroyed as
+    their concrete type and deleting one through a pointer to the interface is a compile
+    error. A virtual destructor puts a deleting destructor in every vtable, which references
+    operator delete and links malloc and free into firmware that never frees anything
+    (about 700 bytes of flash and 400 bytes of RAM on a Cortex-M4). Define the macro when
+    messages or buffers are owned and deleted through an interface pointer, for example a
+    std::unique_ptr<MessageInterface> backed by an RTOS heap.
+*/
+
+#if __cplusplus >= 201703L // C++17 and up
+  
+  template<class T>
+  inline constexpr void destroy_at(T* p) 
+  {
+    std::destroy_at(p);
+  }
+
+#elif __cplusplus >= 201402L // C++14
+
+  template<class T>
+  constexpr void destroy_at(T* p) 
+  {
+    p->~T(); 
+  }
+
+#elif __cplusplus >= 201103L // C++11
+
+  template<class T>
+  constexpr void destroy_at(T* p) 
+  {
+    p->~T(); 
+  }
+
+#else // Other
+
+  #error "Unsupported version of C++. Embedded Proto supports C++11 and up."
+
+#endif
+
+
+  //! A simple struct holding both a pointer to an array and the size of that array.
+  /*!
+      The view keeps the pointer and its bound together, which is what the array
+      interfaces of the library take instead of a separate pointer and length. Use a
+      const element type, for example array_view<const uint8_t>, to view an array which
+      is only read.
+  */
+  template<class T>
+  struct array_view {
+    T* data; //!< A pointer to the start of an array.
+    uint32_t size; //!< The number of elements in the array.
+  };
+
+  using string_view = array_view<char>;
+  using bytes_view = array_view<uint8_t>;
+  using const_string_view = array_view<const char>; //!< A view on characters which are only read.
+  using const_bytes_view = array_view<const uint8_t>; //!< A view on bytes which are only read.
+
+  //! Simple max function as constexpr
+  constexpr uint32_t max(const uint32_t a, const uint32_t b)
+  {
+    return (a > b) ? a : b;    
+  }
+
+  //! Simple min function as constexpr
+  constexpr uint32_t min(const uint32_t a, const uint32_t b)
+  {
+    return (a < b) ? a : b;
+  }
+}
+
+#endif //_EMBEDDED_PROTO_DEFINES_H_

EmbeddedProto/src/EmbeddedProto/EmptyArray.h

@@ -0,0 +1,81 @@
+/*
+ *  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 _EMPTY_ARRAY_H_
+#define _EMPTY_ARRAY_H_
+
+#include <cstdint>
+
+namespace EmbeddedProto
+{
+  namespace internal
+  {
+
+    //! Stand-in for std::array<T, 0> that is one byte on every standard library.
+    /*!
+        libc++ gives std::array<T, 0> the size of one T so that data() stays aligned, libstdc++
+        makes it one byte. A field with a maximum length of zero holds no element, so the fixed size
+        containers use this class instead of the array there. Every element access lands on one
+        scratch element shared by all instances for the same T. That keeps an out of range access
+        memory safe, but a value written to the scratch element is lost by design.
+    */
+    template<class T>
+    class EmptyArray
+    {
+      public:
+        static constexpr uint32_t size() { return 0U; }
+
+        T* data() { return &storage(); }
+        const T* data() const { return &storage(); }
+
+        //! Begin and end are equal, a range based loop does not run.
+        T* begin() { return data(); }
+        T* end() { return data(); }
+        const T* begin() const { return data(); }
+        const T* end() const { return data(); }
+
+        //! Any index lands on the scratch element, reset to its default value first.
+        T& operator[](uint32_t) { return reset(); }
+        const T& operator[](uint32_t) const { return reset(); }
+
+        void fill(const T&) {}
+
+      private:
+        static T& storage()
+        {
+          static T element = T();
+          return element;
+        }
+
+        static T& reset()
+        {
+          T& element = storage();
+          element = T();
+          return element;
+        }
+    };
+
+  } // End of namespace internal
+} // End of namespace EmbeddedProto
+
+#endif // End of _EMPTY_ARRAY_H_