Adding missing const_shared_buffer span, revamped unit test

Author: cliffg-softwarelibre

include/buffer/shared_buffer.hpp

@@ -81,12 +81,12 @@
 #include <span>
 
 #include <utility> // std::move, std::swap
-#include <cstring> // std::memcpy
+#include <algorithm> // std::copy
 
 // TODO - add conecepts and / or requires
 //
 // modify the templated constructor that takes a buffer of any valid 
-// byte type, add constraints; this makes the "reinterpret_cast" safe
+// byte type, add constraints which makes the casting safer
 
 namespace chops {
 
@@ -147,6 +147,16 @@ class mutable_shared_buffer {
   mutable_shared_buffer() noexcept : 
       m_data{std::make_shared<byte_vec>(size_type(0))} { }
 
+/**
+ * @brief Construct by copying from a @c std::span of @c std::byte.
+ *
+ * @param sp @c std::byte span pointing to buffer of data. The data is
+ * copied into the internal buffer of the @c mutable_shared_buffer. 
+ *
+ */
+  explicit mutable_shared_buffer(std::span<const std::byte> sp) : 
+      m_data{std::make_shared<byte_vec>(sp.data(), sp.data()+sp.size())} { }
+
 /**
  * @brief Move construct from a @c std::vector of @c std::bytes.
  *
@@ -161,6 +171,7 @@ class mutable_shared_buffer {
       m_data{std::make_shared<byte_vec>(size_type(0))} {
     *m_data = std::move(bv);
   }
+
 /**
  * @brief Construct a @c mutable_shared_buffer with an initial size, contents
  * set to zero.
@@ -171,18 +182,9 @@ class mutable_shared_buffer {
  *
  * @param sz Size for internal @c std::byte buffer.
  */
-  explicit mutable_shared_buffer(size_type sz) noexcept : 
+  explicit mutable_shared_buffer(size_type sz) : 
       m_data{std::make_shared<byte_vec>(sz)} { }
 
-/**
- * @brief Construct by copying from a @c std::span of @c std::byte.
- *
- * @param sp @c std::byte span pointing to buffer of data. The data is
- * copied into the internal buffer of the @c mutable_shared_buffer. 
- *
- */
-  mutable_shared_buffer(std::span<const std::byte> sp) noexcept : 
-      m_data{std::make_shared<byte_vec>(sp.data(), sp.data()+sp.size())} { }
 
 /**
  * @brief Construct by copying from a @c std::byte array.
@@ -192,15 +194,29 @@ class mutable_shared_buffer {
  *
  * @pre Size cannot be greater than the source buffer.
  *
- * @param buf @c std::byte array containing buffer of data. The data is
- * copied into the internal buffer of the @c mutable_shared_buffer.
+ * @param buf Non-null pointer to a @c std::byte buffer of data. The 
+ * data is copied into the internal buffer of the @c mutable_shared_buffer.
  *
  * @param sz Size of buffer.
  *
  */
-  mutable_shared_buffer(const std::byte* buf, size_type sz) noexcept : 
+  mutable_shared_buffer(const std::byte* buf, size_type sz) : 
       mutable_shared_buffer(std::span<const std::byte>(buf, sz)) { }
 
+/**
+ * @brief Construct by copying bytes from a @c std::span.
+ *
+ * The type of the span must be convertible to or layout compatible with
+ * @c std::byte.
+ *
+ * @param sp @c std::span pointing to buffer of data. The @c std::span 
+ * pointer is cast into a @c std::byte pointer and bytes are then copied. 
+ *
+ */
+  template <typename T>
+  mutable_shared_buffer(std::span<const T> sp) : 
+      mutable_shared_buffer(std::bit_cast<const std::byte *>(sp.data()), sp.size()) { }
+
 /**
  * @brief Construct by copying bytes from an arbitrary pointer.
  *
@@ -210,14 +226,13 @@ class mutable_shared_buffer {
  *
  * @pre Size cannot be greater than the source buffer.
  *
- * @param buf Pointer to a buffer of data. The pointer must be convertible 
- * to a @c void pointer and then to a @c std::byte pointer.
+ * @param buf Non-null pointer to a buffer of data. 
  *
  * @param sz Size of buffer, in bytes.
  */
   template <typename T>
   mutable_shared_buffer(const T* buf, size_type sz) : 
-      mutable_shared_buffer(reinterpret_cast<const std::byte *>(buf), sz) { }
+      mutable_shared_buffer(std::bit_cast<const std::byte *>(buf), sz) { }
 
 /**
  * @brief Construct from input iterators.
@@ -258,10 +273,10 @@ class mutable_shared_buffer {
 /**
  * @brief Return access to underlying @c std::vector.
  *
- * This can be used to instantiate a dynamic_buffer as defined in the Networking TS.
- * Changing the @c std::vector from outside this class works because no state
- * data is stored within this object that needs to be consistent with the @c std::vector
- * contents.
+ * This can be used to instantiate a @c dynamic_buffer as defined in the Networking TS
+ * or Asio API. Changing the @c std::vector from outside this class works because no 
+ * state data is stored within this object that needs to be consistent with the 
+ * @c std::vector contents.
  *
  * @return Reference to @c std::vector<std::byte>.
  */
@@ -315,7 +330,7 @@ class mutable_shared_buffer {
 /**
  * @brief Append a @c std::byte buffer to the end of the internal buffer.
  *
- * @param buf @c std::byte array containing buffer of data.
+ * @param buf Non-null pointer to @c std::byte buffer of data.
  *
  * @param sz Size of buffer.
  *
@@ -324,25 +339,53 @@ class mutable_shared_buffer {
   mutable_shared_buffer& append(const std::byte* buf, size_type sz) {
     size_type old_sz = size();
     resize(old_sz + sz); // set up buffer space
-    std::memcpy(data() + old_sz, buf, sz);
+    std::copy(buf, buf+sz, data()+old_sz);
     return *this;
   }
 
+/**
+ * @brief Append a @c std::span to the end of the internal buffer.
+ *
+ * @param sp @c std::span of @c std::byte data.
+ *
+ * @return Reference to @c this (to allow method chaining).
+ */
+  mutable_shared_buffer& append(std::span<const std::byte> sp) {
+    return append(sp.data(), sp.size());
+  }
+
 /**
  * @brief Append by copying bytes from an arbitrary pointer.
  *
  * The pointer passed into this method is cast into a @c std::byte pointer and bytes 
  * are then copied. In particular, this method can be used for @c char pointers, 
  * @c void pointers, @ unsigned @c char pointers, etc.
  *
- * @param buf Pointer to a buffer of data. The pointer must be convertible 
- * to a @c void pointer and then to a @c std::byte pointer.
+ * @param buf Non-null pointer to a buffer of data.
  *
  * @param sz Size of buffer, in bytes.
  */
   template <typename T>
   mutable_shared_buffer& append(const T* buf, size_type sz) {
-    return append(reinterpret_cast<const std::byte *>(buf), sz);
+    return append(std::bit_cast<const std::byte *>(buf), sz);
+  }
+
+/**
+ * @brief Append a @c std::span that is a non @c std::byte buffer.
+ *
+ * The @c std::span passed into this method is performs a cast on the
+ * data. In particular, this method can be used for @c char pointers, 
+ * @c void pointers, @ unsigned @c char pointers, etc.
+ *
+ * The type of the span must be convertible to or layout compatible with
+ * @c std::byte.
+ *
+ * @param sp @c std::span of arbitrary bytes.
+ *
+ */
+  template <typename T>
+  mutable_shared_buffer& append(std::span<const T> sp) {
+    return append(std::bit_cast<const std::byte *>(sp.data()), sp.size());
   }
 
 /**
@@ -463,18 +506,27 @@ class const_shared_buffer {
   const_shared_buffer& operator=(const const_shared_buffer&) = delete;
   const_shared_buffer& operator=(const_shared_buffer&&) = delete;
 
+/**
+ * @brief Construct by copying from a @c std::span of @c std::byte.
+ *
+ * @param sp @c std::byte span pointing to buffer of data. The data is
+ * copied into the internal buffer of the @c const_shared_buffer. 
+ *
+ */
+  explicit const_shared_buffer(std::span<const std::byte> sp) : 
+      m_data(std::make_shared<byte_vec>(sp.data(), sp.data()+sp.size())) { }
 /**
  * @brief Construct by copying from a @c std::byte array.
  *
  * @pre Size cannot be greater than the source buffer.
  *
- * @param buf @c std::byte array containing buffer of data. The data is
+ * @param buf Non-null pointer to @c std::byte buffer of data. The data is
  * copied into the internal buffer of the @c const_shared_buffer.
  *
  * @param sz Size of buffer.
  */
   const_shared_buffer(const std::byte* buf, size_type sz) : 
-      m_data(std::make_shared<byte_vec>(buf, buf+sz)) { }
+      const_shared_buffer(std::span<const std::byte>(buf, sz)) { }
 
 /**
  * @brief Construct by copying bytes from an arbitrary pointer.
@@ -483,16 +535,18 @@ class const_shared_buffer {
  * are then copied. In particular, this method can be used for @c char pointers, 
  * @c void pointers, @c unsigned @c char pointers, etc.
  *
+ * The type of the span must be convertible to or layout compatible with
+ * @c std::byte.
+ *
  * @pre Size cannot be greater than the source buffer.
  *
- * @param buf Pointer to a buffer of data. The pointer must be convertible 
- * to a @c void pointer and then to a @c std::byte pointer.
+ * @param buf Non-null pointer to a buffer of data. 
  *
  * @param sz Size of buffer, in bytes.
  */
   template <typename T>
   const_shared_buffer(const T* buf, size_type sz) : 
-      const_shared_buffer(reinterpret_cast<const std::byte *>(buf), sz) { }
+      const_shared_buffer(std::bit_cast<const std::byte *>(buf), sz) { }
 
 /**
  * @brief Construct by copying from a @c mutable_shared_buffer object.