Sync to 20.38.2

Author: John Wellbelove

Diff for: library.json

@@ -1,6 +1,6 @@
 {
   "name": "Embedded Template Library - Arduino",
-  "version": "20.36.0",
+  "version": "20.38.2",
   "authors": {
     "name": "John Wellbelove",
     "email": "[email protected]"

Diff for: library.properties

@@ -1,5 +1,5 @@
 name=Embedded Template Library - Arduino
-version=20.36.0
+version=20.38.2
 author= John Wellbelove <[email protected]>
 maintainer=John Wellbelove <[email protected]>
 license=MIT

Diff for: src/Embedded_Template_Library.h

@@ -77,4 +77,4 @@
     #endif
 #endif
 
-#endif
+#endif

Diff for: src/etl/algorithm.h

@@ -229,8 +229,8 @@ namespace etl
   {
     return std::move(sb, se, db);
   }
-#else
-  // non-pointer or not trivially copyable
+#elif ETL_USING_CPP11
+  // For C++11
   template <typename TIterator1, typename TIterator2>
   ETL_CONSTEXPR14 TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db)
   {
@@ -243,19 +243,25 @@ namespace etl
 
     return db;
   }
+#else
+  // For C++03
+  template <typename TIterator1, typename TIterator2>
+  ETL_CONSTEXPR14 TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db)
+  {
+    return copy(sb, se, db);
+  }
 #endif
 
   //***************************************************************************
   // move_backward
 #if ETL_USING_STL && ETL_USING_CPP20
   template <typename TIterator1, typename TIterator2>
-  ETL_CONSTEXPR20
-    TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
+  ETL_CONSTEXPR20 TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
   {
     return std::move_backward(sb, se, de);
   }
-#else
-  // non-pointer or not trivially copyable
+#elif ETL_USING_CPP11
+  // For C++11
   template <typename TIterator1, typename TIterator2>
   ETL_CONSTEXPR14 TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
   {
@@ -266,6 +272,13 @@ namespace etl
 
     return de;
   }
+#else
+  // For C++03
+  template <typename TIterator1, typename TIterator2>
+  ETL_CONSTEXPR14 TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
+  {
+    return etl::copy_backward(sb, se, de);
+  }
 #endif
 
   //***************************************************************************
@@ -560,6 +573,7 @@ namespace etl
   //***************************************************************************
   // equal
 #if ETL_USING_STL && ETL_USING_CPP20
+  // Three parameter
   template <typename TIterator1, typename TIterator2>
   [[nodiscard]]
   constexpr
@@ -568,15 +582,35 @@ namespace etl
     return std::equal(first1, last1, first2);
   }
 
+  // Three parameter + predicate
   template <typename TIterator1, typename TIterator2, typename TPredicate>
   [[nodiscard]]
   constexpr
   bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TPredicate predicate)
   {
     return std::equal(first1, last1, first2, predicate);
   }
+
+  // Four parameter
+  template <typename TIterator1, typename TIterator2>
+  [[nodiscard]]
+  constexpr
+  bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
+  {
+    return std::equal(first1, last1, first2, last2);
+  }
+
+  // Four parameter + Predicate
+  template <typename TIterator1, typename TIterator2, typename TPredicate>
+  [[nodiscard]]
+  constexpr
+  bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TPredicate predicate)
+  {
+    return std::equal(first1, last1, first2, last2, predicate);
+  }
+
 #else
-  // Not pointer types or not trivially copyable.
+
   template <typename TIterator1, typename TIterator2>
   ETL_NODISCARD
   ETL_CONSTEXPR14
@@ -639,8 +673,8 @@ namespace etl
   // Four parameter, Predicate
   template <typename TIterator1, typename TIterator2, typename TPredicate>
   ETL_NODISCARD
-    ETL_CONSTEXPR14
-    bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TPredicate predicate)
+  ETL_CONSTEXPR14
+  bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TPredicate predicate)
   {
     while ((first1 != last1) && (first2 != last2))
     {

Diff for: src/etl/alignment.h

@@ -102,34 +102,79 @@ namespace etl
 
   namespace private_alignment
   {
+#if ETL_USING_CPP11
     //***************************************************************************
     // Matcher.
     //***************************************************************************
-    template <bool IS_MATCH, const size_t ALIGNMENT, typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void, 
+    template <bool Is_Match, size_t Alignment, typename... TRest>
+    class type_with_alignment_matcher;
+
+    // Matching alignment.
+    template <size_t Alignment, typename T1, typename... TRest>
+    class type_with_alignment_matcher<true, Alignment, T1, TRest...> 
+    {
+    public:
+    
+      typedef T1 type;
+    };
+
+    // Non-matching alignment
+    template <size_t Alignment, typename T1, typename T2, typename... TRest>
+    class type_with_alignment_matcher <false, Alignment, T1, T2, TRest...> 
+    {
+    public:
+    
+      typedef typename type_with_alignment_matcher < Alignment <= etl::alignment_of<T2>::value , Alignment, T2, TRest... > ::type type;
+    };
+
+    // Non-matching alignment, none left.
+    template <size_t Alignment, typename T1>
+    class type_with_alignment_matcher <false, Alignment, T1> 
+    {
+    public:
+    
+      typedef char type;
+    };
+
+    //***************************************************************************
+    // Helper.
+    //***************************************************************************
+    template <size_t Alignment, typename T1, typename... T>
+    class type_with_alignment_helper 
+    {
+    public:
+    
+      typedef typename type_with_alignment_matcher<Alignment <= etl::alignment_of<T1>::value, Alignment, T1, T...>::type type;
+    };
+#else
+    //***************************************************************************
+    // Matcher.
+    //***************************************************************************
+    template <bool Is_Match, const size_t Alignment, typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void, 
                                                      typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void>
     class type_with_alignment_matcher;
 
     // Matching alignment.
-    template <size_t ALIGNMENT, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    class type_with_alignment_matcher <true, ALIGNMENT, T1, T2, T3, T4, T5, T6, T7, T8>
+    template <size_t Alignment, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+    class type_with_alignment_matcher <true, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>
     {
     public:
 
       typedef T1 type;
     };
 
     // Non-matching alignment.
-    template <size_t ALIGNMENT, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    class type_with_alignment_matcher <false, ALIGNMENT, T1, T2, T3, T4, T5, T6, T7, T8>
+    template <size_t Alignment, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+    class type_with_alignment_matcher <false, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>
     {
     public:
 
-      typedef typename type_with_alignment_matcher<ALIGNMENT <= etl::alignment_of<T2>::value, ALIGNMENT, T2, T3, T4, T5, T6, T7, T8, void>::type type;
+      typedef typename type_with_alignment_matcher<Alignment <= etl::alignment_of<T2>::value, Alignment, T2, T3, T4, T5, T6, T7, T8, void>::type type;
     };
 
     // Non-matching alignment, none left.
-    template <size_t ALIGNMENT>
-    class type_with_alignment_matcher <false, ALIGNMENT, void, void, void, void, void, void, void, void>
+    template <size_t Alignment>
+    class type_with_alignment_matcher <false, Alignment, void, void, void, void, void, void, void, void>
     {
     public:
 
@@ -139,38 +184,39 @@ namespace etl
     //***************************************************************************
     // Helper.
     //***************************************************************************
-    template <size_t ALIGNMENT, typename T1,        typename T2 = void, typename T3 = void, typename T4 = void,
-                                      typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void>
+    template <size_t Alignment, typename T1,        typename T2 = void, typename T3 = void, typename T4 = void,
+                                typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void>
     class type_with_alignment_helper
     {
     public:
 
-      typedef typename type_with_alignment_matcher<ALIGNMENT <= etl::alignment_of<T1>::value, ALIGNMENT, T1, T2, T3, T4, T5, T6, T7, T8>::type type;
+      typedef typename type_with_alignment_matcher<Alignment <= etl::alignment_of<T1>::value, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>::type type;
     };
+#endif
   }
 
   //***************************************************************************
   /// Gets a type that has the same as the specified alignment.
   ///\ingroup alignment
   //***************************************************************************
-  template <size_t ALIGNMENT>
+  template <size_t Alignment>
   class type_with_alignment
   {
   public:
 
 #if ETL_NOT_USING_64BIT_TYPES
-    typedef typename private_alignment::type_with_alignment_helper<ALIGNMENT, int_least8_t, int_least16_t, int32_t, float, double, void*>::type type;
+    typedef typename private_alignment::type_with_alignment_helper<Alignment, int_least8_t, int_least16_t, int32_t, float, double, void*>::type type;
 #else
-    typedef typename private_alignment::type_with_alignment_helper<ALIGNMENT, int_least8_t, int_least16_t, int32_t, int64_t, float, double, void*>::type type;
+    typedef typename private_alignment::type_with_alignment_helper<Alignment, int_least8_t, int_least16_t, int32_t, int64_t, float, double, void*>::type type;
 #endif
   };
 
   //***************************************************************************
   /// Aligned storage
-  /// LENGTH should be determined in terms of sizeof()
+  /// Length should be determined in terms of sizeof()
   ///\ingroup alignment
   //***************************************************************************
-  template <size_t LENGTH, const size_t ALIGNMENT>
+  template <size_t Length, const size_t Alignment>
   struct aligned_storage
   {
     struct type
@@ -184,7 +230,7 @@ namespace etl
       template <typename T>
       operator T& ()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         T* t = *this;
         return *t;
       }
@@ -193,7 +239,7 @@ namespace etl
       template <typename T>
       operator const T& () const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         const T* t = *this;
         return *t;
       }
@@ -202,23 +248,23 @@ namespace etl
       template <typename T>
       operator T* ()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<T*>(data);
       }
 
       /// Convert to const T pointer.
       template <typename T>
       operator const T* () const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<const T*>(data);
       }
 
       /// Get address as T reference.
       template <typename T>
       T& get_reference()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         T* t = *this;
         return *t;
       }
@@ -227,7 +273,7 @@ namespace etl
       template <typename T>
       const T& get_reference() const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         const T* t = *this;
         return *t;
       }
@@ -236,47 +282,47 @@ namespace etl
       template <typename T>
       T* get_address()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<T*>(data);
       }
 
       /// Get address as const T pointer.
       template <typename T>
       const T* get_address() const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<const T*>(data);
       }
 
 #if ETL_USING_CPP11 && !defined(ETL_COMPILER_ARM5)
-      alignas(ALIGNMENT) char data[LENGTH];
+      alignas(Alignment) char data[Length];
 #else
       union
       {
-        char data[LENGTH];
-        typename etl::type_with_alignment<ALIGNMENT>::type etl_alignment_type; // A POD type that has the same alignment as ALIGNMENT.
+        char data[Length];
+        typename etl::type_with_alignment<Alignment>::type etl_alignment_type; // A POD type that has the same alignment as Alignment.
       };
 #endif
     };
   };
 
 #if ETL_USING_CPP11
-  template <size_t LENGTH, const size_t ALIGNMENT>
-  using aligned_storage_t = typename aligned_storage<LENGTH, ALIGNMENT>::type;
+  template <size_t Length, const size_t Alignment>
+  using aligned_storage_t = typename aligned_storage<Length, Alignment>::type;
 #endif
 
   //***************************************************************************
   /// Aligned storage as
   ///\ingroup alignment
   //***************************************************************************
-  template <size_t LENGTH, typename T>
-  struct aligned_storage_as : public etl::aligned_storage<LENGTH, etl::alignment_of<T>::value>
+  template <size_t Length, typename T>
+  struct aligned_storage_as : public etl::aligned_storage<Length, etl::alignment_of<T>::value>
   {
   };
 
 #if ETL_USING_CPP11
-  template <size_t LENGTH, typename T>
-  using aligned_storage_as_t = typename aligned_storage_as<LENGTH, T>::type;
+  template <size_t Length, typename T>
+  using aligned_storage_as_t = typename aligned_storage_as<Length, T>::type;
 #endif
 }