Sync with 20.39.5

Author: John Wellbelove

library.json

@@ -1,6 +1,6 @@
 {
   "name": "Embedded Template Library ETL",
-  "version": "20.39.4",
+  "version": "20.39.5",
   "authors": {
     "name": "John Wellbelove",
     "email": "[email protected]"

library.properties

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

src/etl/algorithm.h

@@ -1449,16 +1449,20 @@ namespace etl
                         TCompare  compare)
   {
     TIterator minimum = begin;
-    ++begin;
 
-    while (begin != end)
+    if (begin != end)
     {
-      if (compare(*begin, *minimum))
+      ++begin;
+
+      while (begin != end)
       {
-        minimum = begin;
-      }
+        if (compare(*begin, *minimum))
+        {
+          minimum = begin;
+        }
 
-      ++begin;
+        ++begin;
+      }
     }
 
     return minimum;
@@ -1493,16 +1497,20 @@ namespace etl
                         TCompare  compare)
   {
     TIterator maximum = begin;
-    ++begin;
 
-    while (begin != end)
+    if (begin != end)
     {
-      if (!compare(*begin, *maximum))
+      ++begin;
+
+      while (begin != end)
       {
-        maximum = begin;
-      }
+        if (!compare(*begin, *maximum))
+        {
+          maximum = begin;
+        }
 
-      ++begin;
+        ++begin;
+      }
     }
 
     return maximum;
@@ -1538,21 +1546,25 @@ namespace etl
   {
     TIterator minimum = begin;
     TIterator maximum = begin;
-    ++begin;
 
-    while (begin != end)
+    if (begin != end)
     {
-      if (compare(*begin, *minimum))
-      {
-        minimum = begin;
-      }
+      ++begin;
 
-      if (compare(*maximum, *begin))
+      while (begin != end)
       {
-        maximum = begin;
-      }
+        if (compare(*begin, *minimum))
+        {
+          minimum = begin;
+        }
 
-      ++begin;
+        if (compare(*maximum, *begin))
+        {
+          maximum = begin;
+        }
+
+        ++begin;
+      }
     }
 
     return ETL_OR_STD::pair<TIterator, TIterator>(minimum, maximum);

src/etl/array_view.h

@@ -239,19 +239,19 @@ namespace etl
     //*************************************************************************
     template <typename TIterator>
     ETL_CONSTEXPR array_view(const TIterator begin_, const TIterator end_)
-      : mbegin(etl::addressof(*begin_)),
-        mend(etl::addressof(*begin_) + etl::distance(begin_, end_))
+      : mbegin(etl::to_address(begin_)),
+        mend(etl::to_address(begin_) + etl::distance(begin_, end_))
     {
     }
 
     //*************************************************************************
-    /// Construct from C array
+    /// Construct from iterator and size
     //*************************************************************************
     template <typename TIterator,
               typename TSize>
     ETL_CONSTEXPR array_view(const TIterator begin_, const TSize size_)
-      : mbegin(etl::addressof(*begin_)),
-        mend(etl::addressof(*begin_) + size_)
+      : mbegin(etl::to_address(begin_)),
+        mend(etl::to_address(begin_) + size_)
     {
     }
 
@@ -458,8 +458,8 @@ namespace etl
     template <typename TIterator>
     void assign(const TIterator begin_, const TIterator end_)
     {
-      mbegin = etl::addressof(*begin_);
-      mend   = etl::addressof(*begin_) + etl::distance(begin_, end_);
+      mbegin = etl::to_address(begin_);
+      mend   = etl::to_address(begin_) + etl::distance(begin_, end_);
     }
 
     //*************************************************************************
@@ -469,8 +469,8 @@ namespace etl
               typename TSize>
     void assign(const TIterator begin_, const TSize size_)
     {
-      mbegin = etl::addressof(*begin_);
-      mend   = etl::addressof(*begin_) + size_;
+      mbegin = etl::to_address(begin_);
+      mend   = etl::to_address(begin_) + size_;
     }
 
 #if defined(ETL_ARRAY_VIEW_IS_MUTABLE)

src/etl/atomic/atomic_gcc_sync.h

@@ -83,21 +83,30 @@ namespace etl
   // Only integral and pointer types are supported.
   //***************************************************************************
 
-  enum memory_order
+  typedef enum memory_order
   {
     memory_order_relaxed = __ATOMIC_RELAXED,
     memory_order_consume = __ATOMIC_CONSUME,
     memory_order_acquire = __ATOMIC_ACQUIRE,
     memory_order_release = __ATOMIC_RELEASE,
     memory_order_acq_rel = __ATOMIC_ACQ_REL,
     memory_order_seq_cst = __ATOMIC_SEQ_CST
+  } memory_order;
+
+  template <bool Is_Always_Lock_Free>
+  struct atomic_traits
+  {
+    static ETL_CONSTANT bool is_always_lock_free = Is_Always_Lock_Free;
   };
 
+  template <bool Is_Always_Lock_Free>
+  ETL_CONSTANT bool atomic_traits<Is_Always_Lock_Free>::is_always_lock_free;
+
   //***************************************************************************
   /// For all types except bool, pointers and types that are always lock free.
   //***************************************************************************
   template <typename T, bool integral_type = etl::is_integral<T>::value>
-  class atomic
+  class atomic : public atomic_traits<integral_type>
   {
   public:
 
@@ -389,7 +398,7 @@ namespace etl
   /// Specialisation for pointers
   //***************************************************************************
   template <typename T>
-  class atomic<T*, false>
+  class atomic<T*, false> : public atomic_traits<true>
   {
   public:
 
@@ -631,7 +640,7 @@ namespace etl
   /// Specialisation for bool
   //***************************************************************************
   template <>
-  class atomic<bool, true>
+  class atomic<bool, true> : public atomic_traits<true>
   {
   public:
 
@@ -794,7 +803,7 @@ namespace etl
   /// Uses a mutex to control access.
   //***************************************************************************
   template <typename T>
-  class atomic<T, false>
+  class atomic<T, false> : public atomic_traits<false>
   {
   public:
 
@@ -1030,11 +1039,20 @@ namespace etl
     memory_order_seq_cst
   } memory_order;
 
+  template <bool Is_Always_Lock_Free>
+  struct atomic_traits
+  {
+    static ETL_CONSTANT bool is_always_lock_free = Is_Always_Lock_Free;
+  };
+
+  template <bool Is_Always_Lock_Free>
+  ETL_CONSTANT bool atomic_traits<Is_Always_Lock_Free>::is_always_lock_free;
+
   //***************************************************************************
   /// For all types except bool and pointers
   //***************************************************************************
   template <typename T, bool integral_type = etl::is_integral<T>::value>
-  class atomic
+  class atomic : public atomic_traits<integral_type>
   {
   public:
 
@@ -1440,7 +1458,7 @@ namespace etl
   /// Specialisation for pointers
   //***************************************************************************
   template <typename T>
-  class atomic<T*, false>
+  class atomic<T*, false> : public atomic_traits<true>
   {
   public:
 
@@ -1750,7 +1768,7 @@ namespace etl
   /// Specialisation for bool
   //***************************************************************************
   template <>
-  class atomic<bool, true>
+  class atomic<bool, true> : public atomic_traits<true>
   {
   public:
 
@@ -1973,7 +1991,7 @@ namespace etl
   /// Uses a mutex to control access.
   //***************************************************************************
   template <typename T>
-  class atomic<T, false>
+  class atomic<T, false> : public atomic_traits<false>
   {
   public:
 
@@ -2234,3 +2252,4 @@ namespace etl
 }
 
 #endif
+