EmbeddedProto 4.0.0b1__py3-none-any.whl

EmbeddedProto/src/EmbeddedProto/ReadBufferSection.h

@@ -0,0 +1,232 @@
+/*
+ *  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_SECTION_H_
+#define _READ_BUFFER_SECTION_H_
+
+#include "ReadBufferInterface.h"
+
+#include <cstdint>
+#include <algorithm>
+
+
+namespace EmbeddedProto 
+{
+  //! This is a wrapper around a ReadBufferInterface only exposing a given number of bytes.
+  /*!
+      This class is used when decoding a length delimited fields. It is constructed given a message
+      buffer and a size. This class will return bytes from the buffer for the given number of bytes
+      stated in the size parameter.
+
+      \see ReadBufferInterface
+  */
+  class ReadBufferSection : public ReadBufferInterface
+  {
+    public:
+
+      //! Explicitly delete the default constructor in favor of the one with parameters.
+      ReadBufferSection() = delete;
+
+      //! The constructor of the class with the required parameters
+      /*!
+        \param buffer The actual data buffer from which the bytes are obtained.
+        \param size The maximum number of bytes to return from buffer.
+      */
+      ReadBufferSection(ReadBufferInterface& buffer, const uint32_t size);
+
+      ~ReadBufferSection() = default;
+
+
+      //! Return the number of bytes remaining.
+      uint32_t get_size() const override;
+
+      //! Obtain the total number of bytes which can at most be stored in the buffer.
+      /*!
+        In the case of this buffer section this will return the size of the section.
+      */
+      uint32_t get_max_size() const override;
+
+      //! Expose the function of the parent buffer.
+      /*!
+        This will not do anything if size zero is reached.
+        \return True when the buffer was not empty.
+      */
+      bool peek(uint8_t& byte) const override;
+
+      //! Expose the function of the parent buffer.
+      /*!
+        This will not do anything if size zero is reached.
+        \return True when the buffer was not empty.
+      */
+      bool peek(const uint32_t n_bytes, uint8_t& byte) const override;
+      
+      //! Decrement the size and call advance on the parent buffer.
+      /*!
+        This will not do anything if size zero is reached.
+        \return True when the buffer was not empty.
+      */
+      bool advance() override;
+
+      //! Decrement the size by N bytes and call advance on the parent buffer.
+      /*!
+        This will not do anything if size zero is reached.
+        \return True when the buffer held the n_bytes or more.
+      */
+      bool advance(const uint32_t n_bytes) override;
+
+      //! Decrement the size and pop the next byte from the parent buffer.
+      /*!
+        This will not do anything if size zero is reached.
+        \return True while the end of the buffer is not reached.
+      */
+      bool pop(uint8_t& byte) override;
+
+      //! Keep the pointer and length form of pop() reachable next to the override below.
+      using ReadBufferInterface::pop;
+
+      //! Copy a block of bytes from the parent buffer, respecting the section size.
+      /*!
+        All-or-nothing: nothing is copied and the section size is left unchanged
+        when dest.size exceeds the number of bytes remaining in this section. This
+        keeps a fixed-width element that straddles the section boundary from being
+        half-consumed.
+        \return True when dest.size bytes were available within the section and copied.
+      */
+      bool pop(const bytes_view& dest) override;
+
+      //! Keep the single byte forms of peek() reachable next to the override below.
+      using ReadBufferInterface::peek;
+
+      //! Copy a block of bytes from the parent buffer without consuming them, respecting the section size.
+      bool peek(const bytes_view& dest) const override;
+
+    private:
+
+      //! A reference to the buffer containing the actual data.
+      ReadBufferInterface& buffer_;
+
+      //! The number of bytes left in this section.
+      uint32_t size_;
+
+      //! The total number of bytes masked of by this section.
+      const uint32_t max_size_;
+  };
+
+
+  // Definitions of the member functions declared above. The library is header only, so they are
+  // inline.
+
+  inline ReadBufferSection::ReadBufferSection(ReadBufferInterface& buffer, const uint32_t size)
+    : buffer_(buffer),
+      size_(std::min(size, buffer.get_size())),
+      max_size_(std::min(size, buffer.get_size()))
+  {
+    
+  }
+
+  inline uint32_t ReadBufferSection::get_size() const
+  {
+    return size_;
+  }
+
+  inline uint32_t ReadBufferSection::get_max_size() const
+  {
+    return max_size_;
+  }
+
+  inline bool ReadBufferSection::peek(uint8_t& byte) const
+  {
+    bool result = 0 < size_;
+    if(result)
+    {
+      result = buffer_.peek(byte);
+    }
+    return result;
+  }
+
+  inline bool ReadBufferSection::peek(const uint32_t n_bytes, uint8_t& byte) const
+  {
+    bool result = n_bytes < size_;
+    if(result)
+    {
+      result = buffer_.peek(n_bytes, byte);
+    }
+    return result;
+  }
+
+  inline bool ReadBufferSection::advance()
+  {
+    bool result = 0 < size_;
+    if(result) 
+    {
+      result = buffer_.advance();
+      --size_;
+    }
+    return result;
+  }
+
+  inline bool ReadBufferSection::advance(const uint32_t n_bytes)
+  {
+    bool result = 0 < size_;
+    if(result) 
+    {
+      uint32_t n = (n_bytes <= size_) ? n_bytes : size_;
+      result = buffer_.advance(n);
+      size_ -= n;
+    }
+    return result;
+  }
+
+  inline bool ReadBufferSection::pop(uint8_t& byte)
+  {
+    bool result = 0 < size_;
+    if(result)
+    {
+      result = buffer_.pop(byte);
+      --size_;
+    }
+    return result;
+  }
+
+  inline bool ReadBufferSection::pop(const bytes_view& dest)
+  {
+    bool result = dest.size <= size_;
+    if(result)
+    {
+      result = buffer_.pop(dest);
+      if(result)
+      {
+        size_ -= dest.size;
+      }
+    }
+    return result;
+  }
+
+  inline bool ReadBufferSection::peek(const bytes_view& dest) const
+  {
+    return (dest.size <= size_) && buffer_.peek(dest);
+  }
+
+} // End of namespace EmbeddedProto
+
+#endif // _READ_BUFFER_SECTION_H_