etl::span: Add advance(), copy(), reinterpret_as() (#1024)

* etl::span: Add advance(), copy(), reinterpret_as()

* Added further tests for span::reinterpret_as

* Fix size of unaligned_type on Windows

Multiple inheritance leads to additional 1 byte for the second base class.
Fixing it by not inheriting but aggregating via typedef.

Author: rolandreichweinbmw

include/etl/file_error_numbers.h

@@ -105,4 +105,6 @@ SOFTWARE.
 #define ETL_BASE64_FILE_ID "72"
 #define ETL_SINGLETON_BASE_FILE_ID "73"
 #define ETL_UNALIGNED_TYPE_FILE_ID "74"
+#define ETL_SPAN_FILE_ID "75"
+
 #endif

include/etl/span.h

@@ -32,6 +32,10 @@ SOFTWARE.
 #define ETL_SPAN_INCLUDED
 
 #include "platform.h"
+
+#include "error_handler.h"
+#include "exception.h"
+#include "alignment.h"
 #include "iterator.h"
 #include "algorithm.h"
 #include "circular_iterator.h"
@@ -55,6 +59,34 @@ SOFTWARE.
 
 namespace etl
 {
+  //***************************************************************************
+  ///\ingroup span
+  /// Exception base for span
+  //***************************************************************************
+  class span_exception : public exception
+  {
+  public:
+
+    span_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
+      : exception(reason_, file_name_, line_number_)
+    {
+    }
+  };
+
+  //***************************************************************************
+  ///\ingroup span
+  /// Bad alignment exception.
+  //***************************************************************************
+  class span_alignment_exception : public span_exception
+  {
+  public:
+
+    span_alignment_exception(string_type file_name_, numeric_type line_number_)
+      : span_exception(ETL_ERROR_TEXT("span:alignment", ETL_SPAN_FILE_ID"A"), file_name_, line_number_)
+    {
+    }
+  };
+
   //***************************************************************************
   /// Span - Fixed Extent
   //***************************************************************************
@@ -426,6 +458,18 @@ namespace etl
                                             : etl::span<element_type, etl::dynamic_extent>(pbegin + offset, pbegin + offset + count);
     }
 
+    //*************************************************************************
+    /// Reinterpret the span as a span with different element type.
+    //*************************************************************************
+    template<typename TNew>
+    ETL_NODISCARD ETL_CONSTEXPR14 etl::span<TNew, etl::dynamic_extent> reinterpret_as() const
+    {
+      ETL_ASSERT(etl::is_aligned<etl::alignment_of<TNew>::value>(pbegin), ETL_ERROR(span_alignment_exception));
+
+      return etl::span<TNew, etl::dynamic_extent>(reinterpret_cast<TNew*>(pbegin),
+        Extent * sizeof(element_type) / sizeof(TNew));
+    }
+
   private:
 
     pointer pbegin;
@@ -812,6 +856,28 @@ namespace etl
                                             : etl::span<element_type, etl::dynamic_extent>(pbegin + offset, pbegin + offset + count);
     }
 
+    //*************************************************************************
+    /// Moves the pointer to the first element of the span further by a specified number of elements.
+    ///\tparam elements Number of elements to move forward
+    //*************************************************************************
+    void advance(size_t elements) ETL_NOEXCEPT
+    {
+      elements = etl::min(elements, size());
+      pbegin += elements;
+    }
+
+    //*************************************************************************
+    /// Reinterpret the span as a span with different element type.
+    //*************************************************************************
+    template<typename TNew>
+    ETL_NODISCARD ETL_CONSTEXPR14 etl::span<TNew, etl::dynamic_extent> reinterpret_as() const
+    {
+      ETL_ASSERT(etl::is_aligned<etl::alignment_of<TNew>::value>(pbegin), ETL_ERROR(span_alignment_exception));
+
+      return etl::span<TNew, etl::dynamic_extent>(reinterpret_cast<TNew*>(pbegin),
+        (pend - pbegin) * sizeof(element_type) / sizeof(TNew));
+    }
+
   private:
 
     pointer pbegin;
@@ -884,6 +950,33 @@ namespace etl
            etl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
   }
 
+  //*************************************************************************
+  /// Copy complete element data from one span to another. If the destination
+  /// span is bigger than the source span, only the initial part of
+  /// destination span is overwritten.
+  ///\param src Source
+  ///\param dst Destination
+  ///\return true, if copy was successful (including empty source span, or
+  ///        spans pointing to the same address)
+  ///\return false, if the destination span is shorter than the source span.
+  //*************************************************************************
+  template <typename T1, size_t N1, typename T2, size_t N2>
+  typename etl::enable_if<etl::is_same<typename etl::remove_cv<T1>::type, typename etl::remove_cv<T2>::type>::value &&
+                          !etl::is_const<T2>::value, bool>::type
+    copy(const etl::span<T1, N1>& src, const etl::span<T2, N2>& dst)
+  {
+    if (src.empty() || (src.begin() == dst.begin()))
+    {
+      return true;
+    }
+    if (src.size() > dst.size())
+    {
+      return false;
+    }
+    (void) etl::copy(src.begin(), src.end(), dst.begin());
+    return true;
+  }
+
   //*************************************************************************
   /// Template deduction guides.
   //*************************************************************************

include/etl/unaligned_type.h

@@ -449,14 +449,15 @@ namespace etl
   //*************************************************************************
   template <typename T, int Endian_>
   ETL_PACKED_CLASS(unaligned_type) : public private_unaligned_type::unaligned_type_storage<sizeof(T)>
-                                   , public private_unaligned_type::unaligned_copy<sizeof(T), Endian_, etl::is_floating_point<T>::value ? false : true>
   {
   public:
 
     ETL_STATIC_ASSERT(etl::is_integral<T>::value || etl::is_floating_point<T>::value, "Unaligned type must be integral or floating point");
 
     typedef T value_type;
 
+    typedef private_unaligned_type::unaligned_copy<sizeof(T), Endian_, etl::is_floating_point<T>::value ? false : true> unaligned_copy;
+
     typedef typename private_unaligned_type::unaligned_type_storage<sizeof(T)>::storage_type           storage_type;
     typedef typename private_unaligned_type::unaligned_type_storage<sizeof(T)>::pointer                pointer;
     typedef typename private_unaligned_type::unaligned_type_storage<sizeof(T)>::const_pointer          const_pointer;
@@ -480,7 +481,7 @@ namespace etl
     //*************************************************************************
     unaligned_type(T value)
     {
-      this->copy_value_to_store(value, this->storage);
+      unaligned_copy::copy_value_to_store(value, this->storage);
     }
 
     //*************************************************************************
@@ -506,7 +507,7 @@ namespace etl
     //*************************************************************************
     unaligned_type(const unaligned_type<T, Endian>& other)
     {
-      this->copy_store_to_store(other.data(), Endian, this->storage);
+      unaligned_copy::copy_store_to_store(other.data(), Endian, this->storage);
     }
 
     //*************************************************************************
@@ -515,15 +516,15 @@ namespace etl
     template <int Endian_Other>
     unaligned_type(const unaligned_type<T, Endian_Other>& other)
     {
-      this->copy_store_to_store(other.data(), Endian_Other, this->storage);
+      unaligned_copy::copy_store_to_store(other.data(), Endian_Other, this->storage);
     }
 
     //*************************************************************************
     /// Assignment operator
     //*************************************************************************
     unaligned_type& operator =(T value)
     {
-      this->copy_value_to_store(value, this->storage);
+      unaligned_copy::copy_value_to_store(value, this->storage);
 
       return *this;
     }
@@ -533,7 +534,7 @@ namespace etl
     //*************************************************************************
     unaligned_type& operator =(const unaligned_type<T, Endian_>& other)
     {
-      this->copy_store_to_store(other.data(), Endian_, this->storage);
+      unaligned_copy::copy_store_to_store(other.data(), Endian_, this->storage);
 
       return *this;
     }
@@ -544,7 +545,7 @@ namespace etl
     template <int Endian_Other>
     unaligned_type& operator =(const unaligned_type<T, Endian_Other>& other)
     {
-      this->copy_store_to_store(other.data(), Endian_Other, this->storage);
+      unaligned_copy::copy_store_to_store(other.data(), Endian_Other, this->storage);
 
       return *this;
     }
@@ -556,7 +557,7 @@ namespace etl
     {
       T value = T();
 
-      this->copy_store_to_value(this->storage, value);
+      unaligned_copy::copy_store_to_value(this->storage, value);
 
       return value;
     }
@@ -568,7 +569,7 @@ namespace etl
     {
       T value = T();
 
-      this->copy_store_to_value(this->storage, value);
+      unaligned_copy::copy_store_to_value(this->storage, value);
 
       return value;
     }
@@ -589,7 +590,6 @@ namespace etl
   //*************************************************************************
   template <typename T, int Endian_>
   ETL_PACKED_CLASS(unaligned_type_ext) : public private_unaligned_type::unaligned_type_storage_ext<sizeof(T)>
-                                       , public private_unaligned_type::unaligned_copy<sizeof(T), Endian_, etl::is_floating_point<T>::value ? false : true>
   {
   public:
 
@@ -600,6 +600,8 @@ namespace etl
 
     typedef T value_type;
 
+    typedef private_unaligned_type::unaligned_copy<sizeof(T), Endian_, etl::is_floating_point<T>::value ? false : true> unaligned_copy;
+
     typedef typename private_unaligned_type::unaligned_type_storage_ext<sizeof(T)>::storage_type           storage_type;
     typedef typename private_unaligned_type::unaligned_type_storage_ext<sizeof(T)>::pointer                pointer;
     typedef typename private_unaligned_type::unaligned_type_storage_ext<sizeof(T)>::const_pointer          const_pointer;
@@ -625,7 +627,7 @@ namespace etl
     unaligned_type_ext(T value, pointer storage_)
       : private_unaligned_type::unaligned_type_storage_ext<Size>(storage_)
     {
-      this->copy_value_to_store(value, this->storage);
+      unaligned_copy::copy_value_to_store(value, this->storage);
     }
 
     //*************************************************************************
@@ -635,7 +637,7 @@ namespace etl
     unaligned_type_ext(const unaligned_type_ext<T, Endian_Other>& other, pointer storage_)
       : private_unaligned_type::unaligned_type_storage_ext<Size>(storage_)
     {      
-      this->copy_store_to_store(other.data(), Endian_Other, this->storage);
+      unaligned_copy::copy_store_to_store(other.data(), Endian_Other, this->storage);
     }
 
 #if ETL_USING_CPP11
@@ -670,7 +672,7 @@ namespace etl
     //*************************************************************************
     unaligned_type_ext& operator =(T value)
     {
-      this->copy_value_to_store(value, this->storage);
+      unaligned_copy::copy_value_to_store(value, this->storage);
 
       return *this;
     }
@@ -680,7 +682,7 @@ namespace etl
     //*************************************************************************
     unaligned_type_ext& operator =(const unaligned_type_ext<T, Endian>& other)
     {
-      this->copy_store_to_store(other.data(), Endian, this->storage);
+      unaligned_copy::copy_store_to_store(other.data(), Endian, this->storage);
 
       return *this;
     }
@@ -691,7 +693,7 @@ namespace etl
     template <int Endian_Other>
     unaligned_type_ext& operator =(const unaligned_type_ext<T, Endian_Other>& other)
     {
-      this->copy_store_to_store(other.data(), Endian_Other, this->storage);
+      unaligned_copy::copy_store_to_store(other.data(), Endian_Other, this->storage);
 
       return *this;
     }
@@ -735,7 +737,7 @@ namespace etl
     {
       T value = T();
 
-      this->copy_store_to_value(this->storage, value);
+      unaligned_copy::copy_store_to_value(this->storage, value);
 
       return value;
     }
@@ -747,7 +749,7 @@ namespace etl
     {
       T value = T();
 
-      this->copy_store_to_value(this->storage, value);
+      unaligned_copy::copy_store_to_value(this->storage, value);
 
       return value;
     }