Update ETL

Author: rolandreichweinbmw

libs/3rdparty/etl/include/etl/algorithm.h

@@ -43,6 +43,7 @@ SOFTWARE.
 #include "iterator.h"
 #include "functional.h"
 #include "utility.h"
+#include "largest.h"
 #include "gcd.h"
 #include "error_handler.h"
 #include "exception.h"
@@ -952,12 +953,12 @@ namespace etl
 
       while ((value_index > top_index) && compare(first[parent], value))
       {
-        first[value_index] = etl::move(first[parent]);
+        first[value_index] = ETL_MOVE(first[parent]);
         value_index = parent;
         parent = (value_index - 1) / 2;
       }
 
-      first[value_index] = etl::move(value);
+      first[value_index] = ETL_MOVE(value);
     }
 
     // Adjust Heap Helper
@@ -974,18 +975,18 @@ namespace etl
           --child2nd;
         }
 
-        first[value_index] = etl::move(first[child2nd]);
+        first[value_index] = ETL_MOVE(first[child2nd]);
         value_index = child2nd;
         child2nd = 2 * (child2nd + 1);
       }
 
       if (child2nd == length)
       {
-        first[value_index] = etl::move(first[child2nd - 1]);
+        first[value_index] = ETL_MOVE(first[child2nd - 1]);
         value_index = child2nd - 1;
       }
 
-      push_heap(first, value_index, top_index, etl::move(value), compare);
+      push_heap(first, value_index, top_index, ETL_MOVE(value), compare);
     }
 
     // Is Heap Helper
@@ -1018,10 +1019,10 @@ namespace etl
     typedef typename etl::iterator_traits<TIterator>::value_type value_t;
     typedef typename etl::iterator_traits<TIterator>::difference_type distance_t;
 
-    value_t value = etl::move(last[-1]);
-    last[-1] = etl::move(first[0]);
+    value_t value = ETL_MOVE(last[-1]);
+    last[-1] = ETL_MOVE(first[0]);
 
-    private_heap::adjust_heap(first, distance_t(0), distance_t(last - first - 1), etl::move(value), compare);
+    private_heap::adjust_heap(first, distance_t(0), distance_t(last - first - 1), ETL_MOVE(value), compare);
   }
 
   // Pop Heap
@@ -1040,7 +1041,7 @@ namespace etl
     typedef typename etl::iterator_traits<TIterator>::difference_type difference_t;
     typedef typename etl::iterator_traits<TIterator>::value_type      value_t;
 
-    private_heap::push_heap(first, difference_t(last - first - 1), difference_t(0), value_t(etl::move(*(last - 1))), compare);
+    private_heap::push_heap(first, difference_t(last - first - 1), difference_t(0), value_t(ETL_MOVE(*(last - 1))), compare);
   }
 
   // Push Heap
@@ -1068,7 +1069,7 @@ namespace etl
 
     while (true)
     {
-      private_heap::adjust_heap(first, parent, length, etl::move(*(first + parent)), compare);
+      private_heap::adjust_heap(first, parent, length, ETL_MOVE(*(first + parent)), compare);
 
       if (parent == 0)
       {
@@ -1205,7 +1206,7 @@ namespace etl
 
       for (int i = 0; i < gcd_nm; i++) 
       {
-        value_type temp = etl::move(*(first + i));
+        value_type temp = ETL_MOVE(*(first + i));
         int j = i;
 
         while (true) 
@@ -1222,11 +1223,11 @@ namespace etl
             break;
           }
 
-          *(first + j) = etl::move(*(first + k));
+          *(first + j) = ETL_MOVE(*(first + k));
           j = k;
         }
 
-        *(first + j) = etl::move(temp);
+        *(first + j) = ETL_MOVE(temp);
       }
 
       return result;
@@ -1347,13 +1348,13 @@ namespace etl
       typedef typename etl::iterator_traits<TIterator>::value_type value_type;
 
       // Save the first item.
-      value_type temp(etl::move(*first));
+      value_type temp(ETL_MOVE(*first));
 
       // Move the rest.
       TIterator result = etl::move(etl::next(first), last, first);
 
       // Restore the first item in its rotated position.
-      *result = etl::move(temp);
+      *result = ETL_MOVE(temp);
 
       // The new position of the first item.
       return result;
@@ -1369,13 +1370,13 @@ namespace etl
 
       // Save the last item.
       TIterator previous = etl::prev(last);
-      value_type temp(etl::move(*previous));
+      value_type temp(ETL_MOVE(*previous));
 
       // Move the rest.
       TIterator result = etl::move_backward(first, previous, last);
 
       // Restore the last item in its rotated position.
-      *first = etl::move(temp);
+      *first = ETL_MOVE(temp);
 
       // The new position of the first item.
       return result;
@@ -2150,7 +2151,7 @@ namespace etl
   {
     while (first != last)
     {
-      sum = etl::move(sum) + *first;
+      sum = ETL_MOVE(sum) + *first;
       ++first;
     }
 
@@ -2167,7 +2168,7 @@ namespace etl
   {
     while (first != last)
     {
-      sum = operation(etl::move(sum), *first);
+      sum = operation(ETL_MOVE(sum), *first);
       ++first;
     }
 
@@ -2224,7 +2225,7 @@ namespace etl
       {
         if (!(*itr == value))
         {
-          *first++ = etl::move(*itr);
+          *first++ = ETL_MOVE(*itr);
         }
       }
     }
@@ -2250,7 +2251,7 @@ namespace etl
       {
         if (!predicate(*itr))
         {
-          *first++ = etl::move(*itr);
+          *first++ = ETL_MOVE(*itr);
         }
       }
     }
@@ -2280,14 +2281,19 @@ namespace etl
   ETL_CONSTEXPR14
   typename etl::enable_if<etl::is_random_iterator<TInputIterator>::value &&
                           etl::is_random_iterator<TOutputIterator>::value, TOutputIterator>::type
-   copy_s(TInputIterator  i_begin,
-          TInputIterator  i_end,
-          TOutputIterator o_begin,
-          TOutputIterator o_end)
+    copy_s(TInputIterator  i_begin,
+           TInputIterator  i_end,
+           TOutputIterator o_begin,
+           TOutputIterator o_end)
   {
-    using s_size_type = typename iterator_traits<TInputIterator>::difference_type;
-    using d_size_type = typename iterator_traits<TOutputIterator>::difference_type;
-    using min_size_type = typename etl::common_type<s_size_type, d_size_type>::type;
+    typedef typename iterator_traits<TInputIterator>::difference_type  s_size_type;
+    typedef typename iterator_traits<TOutputIterator>::difference_type d_size_type;
+
+#if ETL_USING_CPP11
+    typedef typename etl::common_type<s_size_type, d_size_type>::type  min_size_type;
+#else
+    typedef typename etl::largest_type<s_size_type, d_size_type>::type  min_size_type;
+#endif
 
     s_size_type s_size = etl::distance(i_begin, i_end);
     ETL_ASSERT(s_size >= 0, ETL_ERROR(algorithm_error));

libs/3rdparty/etl/include/etl/alignment.h

@@ -347,9 +347,10 @@ namespace etl
 #if ETL_USING_CPP11
   template <size_t Length, typename T>
   using aligned_storage_as_t = typename aligned_storage_as<Length, T>::type;
+#endif
 
   //***************************************************************************
-  /// Wrapper class that provides a memory area and lets the user emplace and
+  /// Wrapper class that provides a memory area and lets the user create an
   /// instance of T in this memory at runtime. This class also erases the
   /// destructor call of T, i.e. if typed_storage goes out of scope, the
   /// destructor if the wrapped type will not be called. This can be done
@@ -361,11 +362,11 @@ namespace etl
   {
   public:
 
-    using value_type      = T;
-    using reference       = T&;
-    using const_reference = T const&;
-    using pointer         = T*;
-    using const_pointer   = T const*;
+    typedef T        value_type;
+    typedef T&       reference;
+    typedef const T& const_reference;
+    typedef T*       pointer;
+    typedef const T* const_pointer;
 
     // Constructor
     typed_storage()
@@ -375,7 +376,7 @@ namespace etl
 
     //***************************************************************************
     /// Default destructor which will NOT call the destructor of the object which
-    /// was created by calling emplace().
+    /// was created by calling create().
     //***************************************************************************
     ~typed_storage() = default;
 
@@ -390,17 +391,18 @@ namespace etl
     }
 
     //***************************************************************************
-    /// \returns true if object has been constructed using emplace().
-    /// \returns false otherwise.
+    /// \returns <b>true</b> if object has been constructed using create().
+    /// \returns <b>false</b> otherwise.
     //***************************************************************************
     bool has_value() const
     {
       return valid;
     }
 
+#if ETL_USING_CPP11
     //***************************************************************************
     /// Constructs the instance of T forwarding the given \p args to its constructor and
-    /// asserts if has_value() is true before calling emplace().
+    /// asserts if has_value() is false.
     ///
     /// \returns the instance of T which has been constructed in the internal byte array.
     //***************************************************************************
@@ -411,6 +413,63 @@ namespace etl
       valid = true;
       return *::new (data.template get_address<char>()) value_type(etl::forward<Args>(args)...);
     }
+#else
+    //***************************************************************************
+    /// Constructs the instance of T with type T1
+    /// asserts if has_value() is false.
+    ///
+    /// \returns the instance of T which has been constructed in the internal byte array.
+    //***************************************************************************
+    template<typename T1>
+    reference create(const T1& t1)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (data.template get_address<char>()) value_type(t1);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2
+    /// asserts if has_value() is false.
+    ///
+    /// \returns the instance of T which has been constructed in the internal byte array.
+    //***************************************************************************
+    template<typename T1, typename T2>
+    reference create(const T1& t1, const T2& t2)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (data.template get_address<char>()) value_type(t1, t2);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3
+    /// asserts if has_value() is false.
+    ///
+    /// \returns the instance of T which has been constructed in the internal byte array.
+    //***************************************************************************
+    template<typename T1, typename T2, typename T3>
+    reference create(const T1& t1, const T2& t2, const T3& t3)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (data.template get_address<char>()) value_type(t1, t2, t3);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3, T4
+    /// asserts if has_value() is false.
+    ///
+    /// \returns the instance of T which has been constructed in the internal byte array.
+    //***************************************************************************
+    template<typename T1, typename T2, typename T3, typename T4>
+    reference create(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (data.template get_address<char>()) value_type(t1, t2, t3, t4);
+    }
+#endif
 
     //***************************************************************************
     /// \returns a pointer of type T and asserts if has_value() is false.
@@ -450,7 +509,6 @@ namespace etl
     typename aligned_storage_as<sizeof(value_type), value_type>::type data;
     bool valid;
   };
-#endif
 }
 
 #endif