diff --git a/library.json b/library.json
index 69f6941..cb598ae 100644
--- a/library.json
+++ b/library.json
@@ -1,6 +1,6 @@
 {
   "name": "Embedded Template Library ETL",
-  "version": "20.38.11",
+  "version": "20.38.17",
   "authors": {
     "name": "John Wellbelove",
     "email": "john.wellbelove@etlcpp.com"
diff --git a/library.properties b/library.properties
index d13b639..5feed38 100644
--- a/library.properties
+++ b/library.properties
@@ -1,5 +1,5 @@
 name=Embedded Template Library ETL
-version=20.38.11
+version=20.38.17
 author= John Wellbelove <john.wellbelove@etlcpp.com>
 maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
 license=MIT
diff --git a/src/etl/absolute.h b/src/etl/absolute.h
index 5812f86..7bc5ea6 100644
--- a/src/etl/absolute.h
+++ b/src/etl/absolute.h
@@ -40,8 +40,10 @@ namespace etl
   // For signed types.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_signed<T>::value, T>::type
-    absolute(T value)
+  ETL_NODISCARD
+  ETL_CONSTEXPR 
+  typename etl::enable_if<etl::is_signed<T>::value, T>::type
+    absolute(T value) ETL_NOEXCEPT
   {
     return (value < T(0)) ? -value : value;
   }
@@ -50,8 +52,10 @@ namespace etl
   // For unsigned types.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
-    absolute(T value)
+  ETL_NODISCARD
+  ETL_CONSTEXPR
+  typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
+    absolute(T value) ETL_NOEXCEPT
   {
     return value;
   }
@@ -65,8 +69,10 @@ namespace etl
 #else
   template <typename T, typename TReturn>
   #endif
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_signed<T>::value, TReturn>::type
-    absolute_unsigned(T value)
+  ETL_NODISCARD
+  ETL_CONSTEXPR 
+  typename etl::enable_if<etl::is_signed<T>::value, TReturn>::type
+    absolute_unsigned(T value) ETL_NOEXCEPT
   {
     return (value == etl::integral_limits<T>::min) ? (etl::integral_limits<TReturn>::max / 2U) + 1U
                                                    : (value < T(0)) ? TReturn(-value) : TReturn(value);
@@ -77,8 +83,10 @@ namespace etl
   // Returns the result as the unsigned type.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
-    absolute_unsigned(T value)
+  ETL_NODISCARD
+  ETL_CONSTEXPR
+  typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
+    absolute_unsigned(T value) ETL_NOEXCEPT
   {
     return etl::absolute(value);
   }
diff --git a/src/etl/algorithm.h b/src/etl/algorithm.h
index cc989d1..59f8b9b 100644
--- a/src/etl/algorithm.h
+++ b/src/etl/algorithm.h
@@ -43,6 +43,7 @@ SOFTWARE.
 #include "iterator.h"
 #include "functional.h"
 #include "utility.h"
+#include "gcd.h"
 
 #include <stdint.h>
 #include <string.h>
@@ -169,6 +170,18 @@ namespace etl
     return first2;
   }
 
+  //***************************************************************************
+  // generate
+  template <typename TIterator, typename TFunction>
+  ETL_CONSTEXPR14
+  void generate(TIterator db, TIterator de, TFunction funct)
+  {
+    while (db != de)
+    {
+      *db++ = funct();
+    }
+  }
+
   //***************************************************************************
   // copy
 #if ETL_USING_STL && ETL_USING_CPP20 
@@ -1144,21 +1157,148 @@ namespace etl
   //***************************************************************************
   namespace private_algorithm
   {
+#if ETL_USING_CPP11
     //*********************************
+    // For random access iterators
     template <typename TIterator>
     ETL_CONSTEXPR14
-    TIterator rotate_general(TIterator first, TIterator middle, TIterator last)
+    typename etl::enable_if<etl::is_random_access_iterator<TIterator>::value, TIterator>::type
+      rotate_general(TIterator first, TIterator middle, TIterator last) 
     {
-      TIterator next = middle;
+      if (first == middle || middle == last)
+      {
+        return first;
+      }
 
-      while (first != next)
+      typedef typename etl::iterator_traits<TIterator>::value_type value_type;
+
+      int n = last - first;
+      int m = middle - first;
+      int gcd_nm = (n == 0 || m == 0) ? n + m : etl::gcd(n, m);
+
+      TIterator result = first + (last - middle);
+
+      for (int i = 0; i < gcd_nm; i++) 
       {
-        using ETL_OR_STD::swap; // Allow ADL
+        value_type temp = etl::move(*(first + i));
+        int j = i;
+        
+        while (true) 
+        {
+          int k = j + m;
+          
+          if (k >= n)
+          {
+            k = k - n;
+          }
+          
+          if (k == i)
+          {
+            break;
+          }
 
-        swap(*first, *next);
+          *(first + j) = etl::move(*(first + k));
+          j = k;
+        }
 
-        ++first;
-        ++next;
+        *(first + j) = etl::move(temp);
+      }
+
+      return result;
+    }
+#else
+    //*********************************
+    // For random access iterators
+    template <typename TIterator>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_random_access_iterator<TIterator>::value, TIterator>::type
+      rotate_general(TIterator first, TIterator middle, TIterator last)
+    {
+      if (first == middle || middle == last)
+      {
+        return first;
+      }
+
+      typedef typename etl::iterator_traits<TIterator>::value_type value_type;
+
+      int n = last - first;
+      int m = middle - first;
+      int gcd_nm = (n == 0 || m == 0) ? n + m : etl::gcd(n, m);
+
+      TIterator result = first + (last - middle);
+
+      for (int i = 0; i < gcd_nm; i++)
+      {
+        value_type temp = *(first + i);
+        int j = i;
+
+        while (true)
+        {
+          int k = j + m;
+
+          if (k >= n)
+          {
+            k = k - n;
+          }
+
+          if (k == i)
+          {
+            break;
+          }
+
+          *(first + j) = *(first + k);
+          j = k;
+        }
+
+        *(first + j) = temp;
+      }
+
+      return result;
+    }
+#endif
+
+    //*********************************
+    // For bidirectional iterators
+    template <typename TIterator>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_bidirectional_iterator<TIterator>::value, TIterator>::type
+      rotate_general(TIterator first, TIterator middle, TIterator last)
+    {
+      if (first == middle || middle == last)
+      {
+        return first;
+      }
+
+      TIterator result = first;
+      etl::advance(result, etl::distance(middle, last));
+
+      reverse(first, middle);
+      reverse(middle, last);
+      reverse(first, last);
+
+      return result;
+    }
+
+    //*********************************
+    // For forward iterators
+    template <typename TIterator>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_forward_iterator<TIterator>::value, TIterator>::type
+      rotate_general(TIterator first, TIterator middle, TIterator last)
+    {
+      if (first == middle || middle == last)
+      {
+        return first;
+      }
+
+      TIterator next = middle;
+      TIterator result = first;
+      etl::advance(result, etl::distance(middle, last));
+
+      while (first != next)
+      {
+        using ETL_OR_STD::swap;
+        swap(*first++, *next++);
 
         if (next == last)
         {
@@ -1170,10 +1310,11 @@ namespace etl
         }
       }
 
-      return first;
+      return result;
     }
 
     //*********************************
+    // Simplified algorithm for rotate left by one
     template <typename TIterator>
     ETL_CONSTEXPR14
     TIterator rotate_left_by_one(TIterator first, TIterator last)
@@ -1194,6 +1335,7 @@ namespace etl
     }
 
     //*********************************
+    // Simplified for algorithm rotate right by one
     template <typename TIterator>
     ETL_CONSTEXPR14
     TIterator rotate_right_by_one(TIterator first, TIterator last)
@@ -1227,7 +1369,18 @@ namespace etl
 
     if (etl::next(middle) == last)
     {
-      return private_algorithm::rotate_right_by_one(first, last);
+#if ETL_USING_CPP20
+      if ETL_IF_CONSTEXPR(etl::is_forward_iterator<TIterator>::value)
+      {
+        return private_algorithm::rotate_general(first, middle, last);
+      }
+      else
+      {
+        return private_algorithm::rotate_right_by_one(first, last);
+      }
+#else
+      return private_algorithm::rotate_general(first, middle, last);
+#endif
     }
 
     return private_algorithm::rotate_general(first, middle, last);
@@ -1989,19 +2142,33 @@ namespace etl
   ///\ingroup algorithm
   //***************************************************************************
   template<typename T, typename TCompare>
-  ETL_CONSTEXPR 
-  const T& clamp(const T& value, const T& low, const T& high, TCompare compare)
+  ETL_CONSTEXPR
+  T clamp(const T& value, const T& low, const T& high, TCompare compare)
   {
     return compare(value, low) ? low : compare(high, value) ? high : value;
   }
   
   template <typename T>
-  ETL_CONSTEXPR 
-  const T& clamp(const T& value, const T& low, const T& high )
+  ETL_CONSTEXPR
+  T clamp(const T& value, const T& low, const T& high)
   {
     return clamp(value, low, high, etl::less<T>());
   }
 
+  template<typename T, T Low, T High, typename TCompare>
+  ETL_CONSTEXPR
+  T clamp(const T& value, TCompare compare)
+  {
+    return compare(value, Low) ? Low : compare(High, value) ? High : value;
+  }
+
+  template <typename T, T Low, T High>
+  ETL_CONSTEXPR
+  T clamp(const T& value)
+  {
+    return clamp<T, Low, High>(value, etl::less<T>());
+  }
+
   //***************************************************************************
   /// Remove
   ///\ingroup algorithm
@@ -2009,22 +2176,19 @@ namespace etl
   template <typename TIterator, typename T>
   ETL_CONSTEXPR14
   TIterator remove(TIterator first, TIterator last, const T& value)
-  {
+  {    
     first = etl::find(first, last, value);
-      
+
     if (first != last)
     {
       TIterator itr = first;
 
-      while (itr != last)
+      while (++itr != last)
       {
         if (!(*itr == value))
         {
-          *first = etl::move(*itr);
-          ++first;
+          *first++ = etl::move(*itr);
         }
-
-        ++itr;
       }
     }
       
@@ -2045,19 +2209,16 @@ namespace etl
     {
       TIterator itr = first;
 
-      while (itr != last)
+      while (++itr != last)
       {
         if (!predicate(*itr))
         {
-          *first = etl::move(*itr);
-          ++first;
+          *first++ = etl::move(*itr);
         }
-
-        ++itr;
       }
     }
 
-    return first;
+    return first; 
   }
 }
 
@@ -2177,7 +2338,7 @@ namespace etl
   //***************************************************************************
   /// copy_if
   /// A safer form of copy_if where it terminates when the first end iterator is reached.
-  /// There is currently no STL equivelent.
+  /// There is currently no STL equivalent.
   ///\ingroup algorithm
   //***************************************************************************
   template <typename TInputIterator,
@@ -3065,6 +3226,196 @@ namespace etl
     return multimin_iter_compare(compare, t, multimin_iter_compare(compare, tx...));
   }
 #endif
+
+  //***************************************************************************
+  /// partition
+  /// For forward iterators only
+  /// Does at most etl::distance(first, last) swaps.
+  //***************************************************************************
+  template <typename TIterator, typename TPredicate>
+  ETL_CONSTEXPR14 
+  typename etl::enable_if<etl::is_forward_iterator<TIterator>::value, TIterator>::type
+    partition(TIterator first, TIterator last, TPredicate predicate)
+  {
+    first = etl::find_if_not(first, last, predicate);
+
+    if (first == last)
+    {
+      return first;
+    }
+
+    for (TIterator i = etl::next(first); i != last; ++i)
+    {
+      if (predicate(*i))
+      {
+        using ETL_OR_STD::swap;
+        swap(*i, *first);
+        ++first;
+      }
+    }
+
+    return first;
+  }
+
+  //***************************************************************************
+  /// partition
+  /// For iterators that support bidirectional iteration.
+  /// Does at most (etl::distance(first, last) / 2) swaps.
+  //***************************************************************************
+  template <typename TIterator, typename TPredicate>
+  ETL_CONSTEXPR14
+  typename etl::enable_if<etl::is_bidirectional_iterator_concept<TIterator>::value, TIterator>::type
+    partition(TIterator first, TIterator last, TPredicate predicate) 
+  {
+    while (first != last)
+    {
+      first = etl::find_if_not(first, last, predicate);
+
+      if (first == last)
+      {
+        break;
+      }
+
+      last = etl::find_if(etl::reverse_iterator<TIterator>(last),
+                          etl::reverse_iterator<TIterator>(first),
+                          predicate).base();
+
+      if (first == last)
+      {
+        break;
+      }
+
+      --last;
+      using ETL_OR_STD::swap;
+      swap(*first, *last);
+      ++first;
+    }
+
+    return first;
+  }
+
+  //*********************************************************
+  namespace private_algorithm
+  {
+    using ETL_OR_STD::swap;
+
+    template <typename TIterator, typename TCompare>
+#if (ETL_USING_CPP20 && ETL_USING_STL) || (ETL_USING_CPP14 && ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST))
+    constexpr
+#endif
+    TIterator nth_partition(TIterator first, TIterator last, TCompare compare)
+    {
+      typedef typename etl::iterator_traits<TIterator>::value_type value_type;
+
+      TIterator  pivot = last; // Maybe find a better pivot choice?
+      value_type pivot_value = *pivot;
+
+      // Swap the pivot with the last, if necessary.
+      if (pivot != last)
+      {
+        swap(*pivot, *last);
+      }
+
+      TIterator i = first;
+
+      for (TIterator j = first; j < last; ++j)
+      {
+        if (!compare(pivot_value, *j)) // Hack to get '*j <= pivot_value' in terms of 'pivot_value < *j'
+        {
+          swap(*i, *j);
+          ++i;
+        }
+      }
+
+      swap(*i, *last);
+
+      return i;
+    }
+  }
+
+  //*********************************************************
+  /// nth_element
+  /// see https://en.cppreference.com/w/cpp/algorithm/nth_element
+  //*********************************************************
+#if ETL_USING_CPP11
+  template <typename TIterator, typename TCompare = etl::less<typename etl::iterator_traits<TIterator>::value_type>>
+#if (ETL_USING_CPP20 && ETL_USING_STL) || (ETL_USING_CPP14 && ETL_NOT_USING_STL && !defined(ETL_IN_UNIT_TEST))
+  constexpr
+#endif
+  typename etl::enable_if<etl::is_random_access_iterator_concept<TIterator>::value, void>::type
+    nth_element(TIterator first, TIterator nth, TIterator last, TCompare compare = TCompare())
+  {
+    if (first == last)
+    {
+      return;
+    }
+
+    // 'last' must point to the actual last value.
+    --last;
+
+    while (first <= last)
+    {
+      TIterator p = private_algorithm::nth_partition(first, last, compare);
+
+      if (p == nth)
+      {
+        return;
+      }
+      else if (p > nth)
+      {
+        last = p - 1;
+      }
+      else
+      {
+        first = p + 1;
+      }
+    }
+  }
+
+#else
+
+  //*********************************************************
+  template <typename TIterator, typename TCompare>
+  typename etl::enable_if<etl::is_random_access_iterator_concept<TIterator>::value, void>::type
+    nth_element(TIterator first, TIterator nth, TIterator last, TCompare compare)
+  {
+    if (first == last)
+    {
+      return;
+    }
+
+    // 'last' must point to the actual last value.
+    --last;
+
+    while (first <= last)
+    {
+      TIterator p = private_algorithm::nth_partition(first, last, compare);
+
+      if (p == nth)
+      {
+        return;
+      }
+      else if (p > nth)
+      {
+        last = p - 1;
+      }
+      else
+      {
+        first = p + 1;
+      }
+    }
+  }
+
+  //*********************************************************
+  template <typename TIterator>
+  typename etl::enable_if<etl::is_random_access_iterator_concept<TIterator>::value, void>::type
+    nth_element(TIterator first, TIterator nth, TIterator last)
+  {
+    typedef etl::less<typename etl::iterator_traits<TIterator>::value_type> compare_t;
+
+    nth_element(first, last, compare_t());
+  }
+#endif
 }
 
 #include "private/minmax_pop.h"
diff --git a/src/etl/array.h b/src/etl/array.h
index 52f0f65..0a41fae 100644
--- a/src/etl/array.h
+++ b/src/etl/array.h
@@ -94,15 +94,15 @@ namespace etl
 
     static ETL_CONSTANT size_t SIZE = SIZE_;
 
-    typedef T                                     value_type;
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef T&                                    reference;
-    typedef const T&                              const_reference;
-    typedef T*                                    pointer;
-    typedef const T*                              const_pointer;
-    typedef T*                                    iterator;
-    typedef const T*                              const_iterator;
+    typedef T         value_type;
+    typedef size_t    size_type;
+    typedef ptrdiff_t difference_type;
+    typedef T&        reference;
+    typedef const T&  const_reference;
+    typedef T*        pointer;
+    typedef const T*  const_pointer;
+    typedef T*        iterator;
+    typedef const T*  const_iterator;
     typedef ETL_OR_STD::reverse_iterator<iterator>       reverse_iterator;
     typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
 
@@ -115,6 +115,7 @@ namespace etl
     ///\param i The index of the element to access.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     reference at(size_t i)
     {
       ETL_ASSERT(i < SIZE, ETL_ERROR(array_out_of_range));
@@ -141,6 +142,7 @@ namespace etl
     ///\param i The index of the element to access.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     reference operator[](size_t i)
     {
       return _buffer[i];
@@ -161,6 +163,7 @@ namespace etl
     /// Returns a reference to the first element.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     reference front()
     {
       return _buffer[0];
@@ -179,6 +182,7 @@ namespace etl
     /// Returns a reference to the last element.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     reference back()
     {
       return _buffer[SIZE - 1];
@@ -197,6 +201,7 @@ namespace etl
     /// Returns a pointer to the first element of the internal buffer.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     pointer data() ETL_NOEXCEPT
     {
       return &_buffer[0];
@@ -219,6 +224,7 @@ namespace etl
     /// Returns an iterator to the beginning of the array.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     iterator begin() ETL_NOEXCEPT
     {
       return &_buffer[0];
@@ -246,6 +252,7 @@ namespace etl
     /// Returns an iterator to the end of the array.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     iterator end() ETL_NOEXCEPT
     {
       return _buffer + SIZE;
@@ -273,6 +280,7 @@ namespace etl
     // Returns an reverse iterator to the reverse beginning of the array.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     reverse_iterator rbegin() ETL_NOEXCEPT
     {
       return reverse_iterator(end());
@@ -300,6 +308,7 @@ namespace etl
     /// Returns a reverse iterator to the end of the array.
     //*************************************************************************
     ETL_NODISCARD
+    ETL_CONSTEXPR14
     reverse_iterator rend() ETL_NOEXCEPT
     {
       return reverse_iterator(begin());
@@ -386,11 +395,12 @@ namespace etl
     /// If the range is smaller than the array then the unused array elements are left unmodified.
     ///\param first The iterator to the first item in the range.
     ///\param last  The iterator to one past the final item in the range.
+    ///\return An iterator to the first unassigned array element, or end().
     //*************************************************************************
     template <typename TIterator>
-    void assign(TIterator first, const TIterator last)
+    iterator assign(TIterator first, const TIterator last)
     {
-      etl::copy_s(first, last, begin(), end());
+      return etl::copy_s(first, last, begin(), end());
     }
 
     //*************************************************************************
@@ -398,15 +408,18 @@ namespace etl
     /// If the range is smaller than the array then the unused array elements are initialised with the supplied value.
     ///\param first The iterator to the first item in the range.
     ///\param last  The iterator to one past the final item in the range.
+    ///\return An iterator to the first array element set to 'value', or end().
     //*************************************************************************
     template <typename TIterator>
-    void assign(TIterator first, const TIterator last, parameter_t value)
+    iterator assign(TIterator first, const TIterator last, parameter_t value)
     {
       // Copy from the range.
-      iterator p = etl::copy(first, last, begin());
+      iterator p = etl::copy_s(first, last, begin(), end());
 
       // Initialise any that are left.
       etl::fill(p, end(), value);
+
+      return p;
     }
 
     //*************************************************************************
diff --git a/src/etl/atomic/atomic_gcc_sync.h b/src/etl/atomic/atomic_gcc_sync.h
index 152279d..9e7399a 100644
--- a/src/etl/atomic/atomic_gcc_sync.h
+++ b/src/etl/atomic/atomic_gcc_sync.h
@@ -167,7 +167,7 @@ namespace etl
 
     T operator --(int) volatile
     {
-      return __atomic_fetch_sub(&value, 1), etl::memory_order_seq_cst;
+      return __atomic_fetch_sub(&value, 1, etl::memory_order_seq_cst);
     }
 
     // Add
diff --git a/src/etl/basic_format_spec.h b/src/etl/basic_format_spec.h
index 90a48c1..36c2d74 100644
--- a/src/etl/basic_format_spec.h
+++ b/src/etl/basic_format_spec.h
@@ -172,10 +172,10 @@ namespace etl
   static ETL_CONSTANT private_basic_format_spec::base_spec hex(16U);
 
   //*********************************
-  static ETL_CONSTANT private_basic_format_spec::left_spec left;
+  static ETL_CONSTANT private_basic_format_spec::left_spec left = private_basic_format_spec::left_spec();
 
   //*********************************
-  static ETL_CONSTANT private_basic_format_spec::right_spec right;
+  static ETL_CONSTANT private_basic_format_spec::right_spec right = private_basic_format_spec::right_spec();
 
   //*********************************
   static ETL_CONSTANT private_basic_format_spec::boolalpha_spec boolalpha(true);
diff --git a/src/etl/basic_string.h b/src/etl/basic_string.h
index 8afdf18..6b01c61 100644
--- a/src/etl/basic_string.h
+++ b/src/etl/basic_string.h
@@ -1262,7 +1262,7 @@ namespace etl
     /// Erases a sequence.
     ///\param position Position to start from.
     ///\param length   Number of characters.
-    ///\return A refernce to this string.
+    ///\return A reference to this string.
     //*********************************************************************
     etl::ibasic_string<T>& erase(size_type position, size_type length_ = npos)
     {
diff --git a/src/etl/basic_string_stream.h b/src/etl/basic_string_stream.h
index e91ee1f..2b46605 100644
--- a/src/etl/basic_string_stream.h
+++ b/src/etl/basic_string_stream.h
@@ -58,28 +58,28 @@ namespace etl
     }
 
     //*************************************************************************
-    /// Construct from text and format spec.
+    /// Construct from text and format fmt.
     //*************************************************************************
     basic_string_stream(TIString& text_, const TFormat& spec_)
       : text(text_)
-      , spec(spec_)
+      , format(spec_)
     {
     }
 
     //*************************************************************************
-    /// Set the format spec.
+    /// Set the format fmt.
     //*************************************************************************
     void set_format(const TFormat& spec_)
     {
-      spec = spec_;
+      format = spec_;
     }
 
     //*************************************************************************
-    /// Get a const reference to the format spec.
+    /// Get a const reference to the format fmt.
     //*************************************************************************
     const TFormat& get_format() const
     {
-      return spec;
+      return format;
     }
 
     //*************************************************************************
@@ -121,27 +121,27 @@ namespace etl
     //*********************************
     /// TFormat
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, const TFormat& spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, const TFormat& fmt)
     {
-      ss.spec = spec;
+      ss.format = fmt;
       return ss;
     }
 
     //*********************************
     /// etl::base_spec from etl::setbase, etl::bin, etl::oct, etl::dec & etl::hex stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::base_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::base_spec fmt)
     {
-      ss.spec.base(spec.base);
+      ss.format.base(fmt.base);
       return ss;
     }
 
     //*********************************
     /// etl::width_spec from etl::setw stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::width_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::width_spec fmt)
     {
-      ss.spec.width(spec.width);
+      ss.format.width(fmt.width);
       return ss;
     }
 
@@ -149,63 +149,63 @@ namespace etl
     /// etl::fill_spec from etl::setfill stream manipulator
     //*********************************
     template <typename TChar>
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::fill_spec<TChar> spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::fill_spec<TChar> fmt)
     {
-      ss.spec.fill(spec.fill);
+      ss.format.fill(fmt.fill);
       return ss;
     }
 
     //*********************************
     /// etl::precision_spec from etl::setprecision stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::precision_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::precision_spec fmt)
     {
-      ss.spec.precision(spec.precision);
+      ss.format.precision(fmt.precision);
       return ss;
     }
 
     //*********************************
     /// etl::boolalpha_spec from etl::boolalpha & etl::noboolalpha stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::boolalpha_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::boolalpha_spec fmt)
     {
-      ss.spec.boolalpha(spec.boolalpha);
+      ss.format.boolalpha(fmt.boolalpha);
       return ss;
     }
 
     //*********************************
     /// etl::uppercase_spec from etl::uppercase & etl::nouppercase stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::uppercase_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::uppercase_spec fmt)
     {
-      ss.spec.upper_case(spec.upper_case);
+      ss.format.upper_case(fmt.upper_case);
       return ss;
     }
 
     //*********************************
     /// etl::showbase_spec from etl::showbase & etl::noshowbase stream manipulators
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::showbase_spec spec)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::showbase_spec fmt)
     {
-      ss.spec.show_base(spec.show_base);
+      ss.format.show_base(fmt.show_base);
       return ss;
     }
 
     //*********************************
     /// etl::left_spec from etl::left stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::left_spec /*spec*/)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::left_spec /*fmt*/)
     {
-      ss.spec.left();
+      ss.format.left();
       return ss;
     }
 
     //*********************************
     /// etl::right_spec from etl::left stream manipulator
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::right_spec /*spec*/)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, etl::private_basic_format_spec::right_spec /*fmt*/)
     {
-      ss.spec.right();
+      ss.format.right();
       return ss;
     }
 
@@ -214,7 +214,7 @@ namespace etl
     //*********************************
     friend basic_string_stream& operator <<(basic_string_stream& ss, TStringView view)
     {
-      etl::to_string(view, ss.text, ss.spec, true);
+      etl::to_string(view, ss.text, ss.format, true);
       return ss;
     }
 
@@ -241,9 +241,9 @@ namespace etl
     //*********************************
     /// From a string interface
     //*********************************
-    friend basic_string_stream& operator <<(basic_string_stream& ss, const TIString& text)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, const TIString& t)
     {
-      etl::to_string(text, ss.text, ss.spec, true);
+      etl::to_string(t, ss.text, ss.format, true);
       return ss;
     }
 
@@ -251,9 +251,9 @@ namespace etl
     /// From a string
     //*********************************
     template <template <size_t> class TString, size_t SIZE>
-    friend basic_string_stream& operator <<(basic_string_stream& ss, const TString<SIZE>& text)
+    friend basic_string_stream& operator <<(basic_string_stream& ss, const TString<SIZE>& t)
     {
-      const TIString& itext = text;
+      const TIString& itext = t;
       etl::to_string(itext, ss.str(), ss.get_format(), true);
       return ss;
     }
@@ -264,14 +264,14 @@ namespace etl
     template <typename T>
     friend basic_string_stream& operator <<(basic_string_stream& ss, const T& value)
     {
-      etl::to_string(value, ss.text, ss.spec, true);
+      etl::to_string(value, ss.text, ss.format, true);
       return ss;
     }
 
   private:
 
-    TIString&    text;
-    TFormat spec;
+    TIString& text;
+    TFormat   format;
 
     basic_string_stream(const basic_string_stream&) ETL_DELETE;
     basic_string_stream& operator =(const basic_string_stream&) ETL_DELETE;
diff --git a/src/etl/binary.h b/src/etl/binary.h
index f638856..4ddf627 100644
--- a/src/etl/binary.h
+++ b/src/etl/binary.h
@@ -343,45 +343,6 @@ namespace etl
     return TReturn((value ^ mask) - mask);
   }
 
-  //***************************************************************************
-  /// Find the position of the first set bit.
-  /// Starts from LSB.
-  ///\ingroup binary
-  //***************************************************************************
-  template <typename T>
-  ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
-  {
-    return count_trailing_zeros(value);
-  }
-
-  //***************************************************************************
-  /// Find the position of the first clear bit.
-  /// Starts from LSB.
-  ///\ingroup binary
-  //***************************************************************************
-  template <typename T>
-  ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
-  {
-    value = ~value;
-    return count_trailing_zeros(value);
-  }
-
-  //***************************************************************************
-  /// Find the position of the first bit that is clear or set.
-  /// Starts from LSB.
-  ///\ingroup binary
-  //***************************************************************************
-  template <typename T>
-  ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
-  {
-    if (!state)
-    {
-      value = ~value;
-    }
-
-    return count_trailing_zeros(value);
-  }
-
   //***************************************************************************
   /// Gets the value of the bit at POSITION
   /// Starts from LSB.
@@ -2097,6 +2058,45 @@ namespace etl
     return static_cast<T>(count_leading_ones(static_cast<unsigned_t>(value)));
   }
 
+  //***************************************************************************
+  /// Find the position of the first set bit.
+  /// Starts from LSB.
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  ETL_CONSTEXPR14 uint_least8_t first_set_bit_position(T value)
+  {
+    return count_trailing_zeros(value);
+  }
+
+  //***************************************************************************
+  /// Find the position of the first clear bit.
+  /// Starts from LSB.
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position(T value)
+  {
+    value = ~value;
+    return count_trailing_zeros(value);
+  }
+
+  //***************************************************************************
+  /// Find the position of the first bit that is clear or set.
+  /// Starts from LSB.
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  ETL_CONSTEXPR14 uint_least8_t first_bit_position(bool state, T value)
+  {
+    if (!state)
+    {
+      value = ~value;
+    }
+
+    return count_trailing_zeros(value);
+  }
+
 #if ETL_USING_8BIT_TYPES
   //*****************************************************************************
   /// Binary interleave
@@ -2276,6 +2276,111 @@ namespace etl
     return msb_mask<T, NBits>::value;
   }
 
+  //***************************************************************************
+  /// Bit 'not' a value
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_not : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return ~value;
+    }
+  };
+
+  //***************************************************************************
+  /// Bit 'and' a value with another
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_and : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_CONSTEXPR 
+    explicit binary_and(T parameter_) ETL_NOEXCEPT
+      : parameter(parameter_)
+    {
+    }
+
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR 
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return value & parameter;
+    }
+
+  private:
+
+    T parameter;
+  };
+
+  //***************************************************************************
+  /// Bit 'or' a value with another
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_or : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_CONSTEXPR
+    explicit binary_or(T parameter_) ETL_NOEXCEPT
+      : parameter(parameter_)
+    {
+    }
+
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return value | parameter;
+    }
+
+  private:
+
+    T parameter;
+  };
+
+  //***************************************************************************
+  /// Bit 'exclusive-or' a value with another
+  ///\ingroup binary
+  //***************************************************************************
+  template <typename T>
+  struct binary_xor : public etl::unary_function<T, T>
+  {
+    //***********************************
+    ETL_CONSTEXPR
+    explicit binary_xor(T parameter_) ETL_NOEXCEPT
+      : parameter(parameter_)
+    {
+    }
+
+    //***********************************
+    ETL_NODISCARD
+    ETL_CONSTEXPR
+    T operator ()(T value) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
+
+      return value ^ parameter;
+    }
+
+  private:
+
+    T parameter;
+  };
+
   //***************************************************************************
   /// 8 bit binary byte constants.
   ///\ingroup binary
diff --git a/src/etl/bit_stream.h b/src/etl/bit_stream.h
index 6dcc50f..7c5b557 100644
--- a/src/etl/bit_stream.h
+++ b/src/etl/bit_stream.h
@@ -861,7 +861,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Sets the function to call afer every write.
+    /// Sets the function to call after every write.
     //***************************************************************************
     void set_callback(callback_type callback_)
     {
@@ -869,7 +869,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Gets the function to call afer every write.
+    /// Gets the function to call after every write.
     //***************************************************************************
     callback_type get_callback() const
     {
diff --git a/src/etl/bloom_filter.h b/src/etl/bloom_filter.h
index 711a151..5d35128 100644
--- a/src/etl/bloom_filter.h
+++ b/src/etl/bloom_filter.h
@@ -62,17 +62,17 @@ namespace etl
   /// An implementation of a bloom filter.
   /// Allows up to three hashes to be defined.
   /// Hashes must support the () operator and define 'argument_type'.
-  ///\tparam DESIRED_WIDTH The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset.
+  ///\tparam Desired_Width The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset.
   ///\tparam THash1        The first hash generator class.
   ///\tparam THash2        The second hash generator class. If omitted, uses the null hash.
   ///\tparam THash3        The third hash generator class.  If omitted, uses the null hash.
   /// The hash classes must define <b>argument_type</b>.
   ///\ingroup bloom_filter
   //***************************************************************************
-  template <size_t DESIRED_WIDTH,
-            typename     THash1,
-            typename     THash2 = private_bloom_filter::null_hash,
-            typename     THash3 = private_bloom_filter::null_hash>
+  template <size_t   Desired_Width,
+            typename THash1,
+            typename THash2 = private_bloom_filter::null_hash,
+            typename THash3 = private_bloom_filter::null_hash>
   class bloom_filter
   {
   private:
@@ -85,7 +85,7 @@ namespace etl
     enum
     {
       // Make the most efficient use of the bitset.
-      WIDTH = etl::bitset<DESIRED_WIDTH>::ALLOCATED_BITS
+      WIDTH = etl::bitset<Desired_Width>::Allocated_Bits
     };
 
     //***************************************************************************
diff --git a/src/etl/byte.h b/src/etl/byte.h
index bfd39e5..264788f 100644
--- a/src/etl/byte.h
+++ b/src/etl/byte.h
@@ -176,8 +176,6 @@ namespace etl
     {
     }
 
-  private:
-
     // Cast to a T
     template <typename T>
     operator T() const
@@ -185,6 +183,8 @@ namespace etl
       return static_cast<T>(value);
     }
 
+  private:
+
     // The byte value
     unsigned char value;
   };
diff --git a/src/etl/byte_stream.h b/src/etl/byte_stream.h
index aaa9d8a..17d58f4 100644
--- a/src/etl/byte_stream.h
+++ b/src/etl/byte_stream.h
@@ -69,7 +69,7 @@ namespace etl
     byte_stream_writer(etl::span<char> span_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(span_.begin())
       , pcurrent(span_.begin())
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -81,7 +81,7 @@ namespace etl
     byte_stream_writer(etl::span<unsigned char> span_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(reinterpret_cast<char*>(span_.begin()))
       , pcurrent(reinterpret_cast<char*>(span_.begin()))
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -93,7 +93,7 @@ namespace etl
     byte_stream_writer(void* begin_, void* end_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(reinterpret_cast<char*>(begin_))
       , pcurrent(reinterpret_cast<char*>(begin_))
-      , length(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_)))
+      , stream_length(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_)))
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -105,7 +105,7 @@ namespace etl
     byte_stream_writer(void* begin_, size_t length_, etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(reinterpret_cast<char*>(begin_))
       , pcurrent(reinterpret_cast<char*>(begin_))
-      , length(length_)
+      , stream_length(length_)
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -118,7 +118,7 @@ namespace etl
     byte_stream_writer(T(&begin_)[Size], etl::endian stream_endianness_, callback_type callback_ = callback_type())
       : pdata(begin_)
       , pcurrent(begin_)
-      , length(begin_ + (Size * sizeof(T)))
+      , stream_length(begin_ + (Size * sizeof(T)))
       , stream_endianness(stream_endianness_)
       , callback(callback_)
     {
@@ -333,7 +333,7 @@ namespace etl
     //***************************************************************************
     etl::span<char> free_data()
     {
-      return etl::span<char>(pcurrent, pdata + length);
+      return etl::span<char>(pcurrent, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -341,7 +341,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> free_data() const
     {
-      return etl::span<const char>(pcurrent, pdata + length);
+      return etl::span<const char>(pcurrent, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -349,7 +349,7 @@ namespace etl
     //***************************************************************************
     etl::span<char> data()
     {
-      return etl::span<char>(pdata, pdata + length);
+      return etl::span<char>(pdata, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -357,7 +357,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> data() const
     {
-      return etl::span<const char>(pdata, pdata + length);
+      return etl::span<const char>(pdata, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -389,7 +389,7 @@ namespace etl
     //***************************************************************************
     size_t capacity() const
     {
-      return length;
+      return stream_length;
     }
 
     //***************************************************************************
@@ -410,7 +410,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Sets the function to call afer every write.
+    /// Sets the function to call after every write.
     //***************************************************************************
     void set_callback(callback_type callback_)
     {
@@ -418,7 +418,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Gets the function to call afer every write.
+    /// Gets the function to call after every write.
     //***************************************************************************
     callback_type get_callback() const
     {
@@ -481,7 +481,7 @@ namespace etl
 
     char* const       pdata;             ///< The start of the byte stream buffer.
     char*             pcurrent;          ///< The current position in the byte stream buffer.
-    const size_t      length;            ///< The length of the byte stream buffer.
+    const size_t      stream_length;     ///< The length of the byte stream buffer.
     const etl::endian stream_endianness; ///< The endianness of the stream data.
     callback_type     callback;          ///< An optional callback on every step on the write buffer.
   };
@@ -503,7 +503,7 @@ namespace etl
     byte_stream_reader(etl::span<char> span_, etl::endian stream_endianness_)
       : pdata(span_.begin())
       , pcurrent(span_.begin())
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
     {
     }
@@ -514,7 +514,7 @@ namespace etl
     byte_stream_reader(etl::span<const char> span_, etl::endian stream_endianness_)
       : pdata(span_.begin())
       , pcurrent(span_.begin())
-      , length(span_.size_bytes())
+      , stream_length(span_.size_bytes())
       , stream_endianness(stream_endianness_)
     {
     }
@@ -525,7 +525,7 @@ namespace etl
     byte_stream_reader(const void* begin_, const void* end_, etl::endian stream_endianness_)
       : pdata(reinterpret_cast<const char*>(begin_))
       , pcurrent(reinterpret_cast<const char*>(begin_))
-      , length(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_)))
+      , stream_length(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_)))
       , stream_endianness(stream_endianness_)
     {
     }
@@ -536,7 +536,7 @@ namespace etl
     byte_stream_reader(const void* begin_, size_t length_, etl::endian stream_endianness_)
       : pdata(reinterpret_cast<const char*>(begin_))
       , pcurrent(reinterpret_cast<const char*>(begin_))
-      , length(length_)
+      , stream_length(length_)
       , stream_endianness(stream_endianness_)
     {
     }
@@ -548,7 +548,7 @@ namespace etl
     byte_stream_reader(T(&begin_)[Size], etl::endian stream_endianness_)
       : pdata(begin_)
       , pcurrent(begin_)
-      , length(begin_ + (Size * sizeof(T)))
+      , stream_length(begin_ + (Size * sizeof(T)))
       , stream_endianness(stream_endianness_)
     {
     }
@@ -560,7 +560,7 @@ namespace etl
     byte_stream_reader(const T(&begin_)[Size], etl::endian stream_endianness_)
       : pdata(begin_)
       , pcurrent(begin_)
-      , length(begin_ + (Size * sizeof(T)))
+      , stream_length(begin_ + (Size * sizeof(T)))
       , stream_endianness(stream_endianness_)
     {
     }
@@ -766,7 +766,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> free_data() const
     {
-      return etl::span<const char>(pcurrent, pdata + length);
+      return etl::span<const char>(pcurrent, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -774,7 +774,7 @@ namespace etl
     //***************************************************************************
     etl::span<const char> data() const
     {
-      return etl::span<const char>(pdata, pdata + length);
+      return etl::span<const char>(pdata, pdata + stream_length);
     }
 
     //***************************************************************************
@@ -790,7 +790,7 @@ namespace etl
     //***************************************************************************
     size_t size_bytes() const
     {
-      return length;
+      return stream_length;
     }
 
     //***************************************************************************
@@ -801,7 +801,7 @@ namespace etl
     {
       size_t used = etl::distance(pdata, pcurrent);
 
-      return (length - used) / sizeof(T);
+      return (stream_length - used) / sizeof(T);
     }
 
     //***************************************************************************
@@ -855,7 +855,7 @@ namespace etl
 
     const char* const pdata;             ///< The start of the byte stream buffer.
     const char*       pcurrent;          ///< The current position in the byte stream buffer.
-    const size_t      length;            ///< The length of the byte stream buffer.
+    const size_t      stream_length;     ///< The length of the byte stream buffer.
     const etl::endian stream_endianness; ///< The endianness of the stream data.
   };
 
diff --git a/src/etl/callback_timer.h b/src/etl/callback_timer.h
index e4b5596..9c833db 100644
--- a/src/etl/callback_timer.h
+++ b/src/etl/callback_timer.h
@@ -708,12 +708,26 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      return !active_list.empty();
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
-      uint32_t delta = active_list.front().delta;
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
+      if (has_active_timer())
+      {
+        delta = active_list.front().delta;
+      }
 
       return delta;
     }
diff --git a/src/etl/callback_timer_atomic.h b/src/etl/callback_timer_atomic.h
index 0d12fc2..2a886de 100644
--- a/src/etl/callback_timer_atomic.h
+++ b/src/etl/callback_timer_atomic.h
@@ -297,13 +297,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      ++process_semaphore;
+      bool result = !active_list.empty();
+      --process_semaphore;
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       ++process_semaphore;
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
       --process_semaphore;
 
       return delta;
diff --git a/src/etl/callback_timer_interrupt.h b/src/etl/callback_timer_interrupt.h
index bc3fda5..831565a 100644
--- a/src/etl/callback_timer_interrupt.h
+++ b/src/etl/callback_timer_interrupt.h
@@ -300,15 +300,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      TInterruptGuard guard;
+      (void)guard; // Silence 'unused variable warnings.
+      return !active_list.empty();
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       TInterruptGuard guard;
       (void)guard; // Silence 'unused variable warnings.
 
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
 
       return delta;
     }
diff --git a/src/etl/callback_timer_locked.h b/src/etl/callback_timer_locked.h
index bfd6952..c7480ba 100644
--- a/src/etl/callback_timer_locked.h
+++ b/src/etl/callback_timer_locked.h
@@ -309,13 +309,31 @@ namespace etl
       unlock   = unlock_;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      lock();
+      bool result = !active_list.empty();
+      unlock();
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       lock();
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
       unlock();
 
       return delta;
diff --git a/src/etl/char_traits.h b/src/etl/char_traits.h
index 8ffeb7f..a85bf67 100644
--- a/src/etl/char_traits.h
+++ b/src/etl/char_traits.h
@@ -153,7 +153,7 @@ namespace etl
     }
 
     //*************************************************************************
-    ETL_CONSTEXPR14 static size_t length(const char_type* str, size_t max_length)
+    static ETL_CONSTEXPR14 size_t length(const char_type* str, size_t max_length)
     {
       size_t count = 0UL;
 
diff --git a/src/etl/circular_buffer.h b/src/etl/circular_buffer.h
index a099ca4..0902f0d 100644
--- a/src/etl/circular_buffer.h
+++ b/src/etl/circular_buffer.h
@@ -246,6 +246,22 @@ namespace etl
         return &picb->pbuffer[current];
       }
 
+      //*************************************************************************
+      /// [] operator
+      //*************************************************************************
+      reference operator [](size_t index)
+      {
+        return pbuffer[(current + index) % picb->buffer_size];
+      }
+
+      //*************************************************************************
+      /// [] operator
+      //*************************************************************************
+      const_reference operator [](size_t index) const
+      {
+        return pbuffer[(current + index) % picb->buffer_size];
+      }
+
       //*************************************************************************
       /// Pre-increment.
       //*************************************************************************
@@ -335,6 +351,18 @@ namespace etl
         return temp;
       }
 
+      //*************************************************************************
+      /// Add offset.
+      //*************************************************************************
+      friend iterator operator +(int n, const iterator& rhs)
+      {
+        iterator temp = rhs;
+
+        temp += n;
+
+        return temp;
+      }
+
       //*************************************************************************
       /// Subtract offset.
       //*************************************************************************
@@ -517,6 +545,14 @@ namespace etl
         return &(picb->pbuffer[current]);
       }
 
+      //*************************************************************************
+      /// [] operator
+      //*************************************************************************
+      const_reference operator [](size_t index) const
+      {
+        return pbuffer[(current + index) % picb->buffer_size];
+      }
+
       //*************************************************************************
       /// Pre-increment.
       //*************************************************************************
@@ -998,22 +1034,6 @@ namespace etl
       return distance(rhs, lhs);
     }
 
-    //*************************************************************************
-    /// - operator for reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
-    //*************************************************************************
-    /// - operator for const_reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const const_reverse_iterator& lhs, const const_reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
   protected:
 
     //*************************************************************************
@@ -1208,11 +1228,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
+      virtual void repair() ETL_OVERRIDE
+#else
       void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::circular_buffer_incompatible_type));
@@ -1395,11 +1413,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-    virtual
-#endif
-      void repair()
-#ifdef ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/src/etl/compare.h b/src/etl/compare.h
index 479758d..6320824 100644
--- a/src/etl/compare.h
+++ b/src/etl/compare.h
@@ -40,40 +40,73 @@ SOFTWARE.
 /// Comparisons only using less than operator
 ///\ingroup utilities
 //*****************************************************************************
-
 namespace etl
 {
   //***************************************************************************
-  /// Defines <=, >, >= in terms of <
-  /// Default
+  /// Defines <=, >, >=, ==, !=, <=> in terms of <
+  /// Default implementation of TLess is etl::less
   //***************************************************************************
   template <typename T, typename TLess = etl::less<T> >
   struct compare
   {
+    enum cmp_result
+    {
+      Less    = -1,
+      Equal   = 0,
+      Greater = 1
+    };
+
     typedef typename etl::parameter_type<T>::type first_argument_type;
     typedef typename etl::parameter_type<T>::type second_argument_type;
-    typedef bool result_type;
 
-    static result_type lt(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool lt(first_argument_type lhs, second_argument_type rhs)
     {
       return TLess()(lhs, rhs);
     }
 
-    static result_type gt(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool gt(first_argument_type lhs, second_argument_type rhs)
     {
       return TLess()(rhs, lhs);
     }
 
-    static result_type lte(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool lte(first_argument_type lhs, second_argument_type rhs)
     {
       return !gt(lhs, rhs);
     }
 
-    static result_type gte(first_argument_type lhs, second_argument_type rhs)
+    static ETL_CONSTEXPR bool gte(first_argument_type lhs, second_argument_type rhs)
     {
       return !lt(lhs, rhs);
     }
+
+    static ETL_CONSTEXPR bool eq(first_argument_type lhs, second_argument_type rhs)
+    {
+      return gte(lhs, rhs) && lte(lhs, rhs);
+    }
+
+    static ETL_CONSTEXPR bool ne(first_argument_type lhs, second_argument_type rhs)
+    {
+      return !eq(lhs, rhs);
+    }
+
+    static ETL_CONSTEXPR cmp_result cmp(first_argument_type lhs, second_argument_type rhs)
+    {
+      return lt(lhs, rhs) ? Less : gt(lhs, rhs) ? Greater : Equal;
+    }
   };
+
+  //***************************************************************************
+  /// Default implementation of TLess is etl::less
+  //***************************************************************************
+#if ETL_USING_CPP11
+  template <typename T, typename TLess = etl::less<T> >
+#else
+  template <typename T, typename TLess>
+#endif
+  ETL_CONSTEXPR14 int three_way_compare(const T& lhs, const T& rhs)
+  {
+    return etl::compare<T>::cmp(lhs, rhs);
+  }
 }
 
 #endif
diff --git a/src/etl/crc.h b/src/etl/crc.h
index eab6d7b..78ceb55 100644
--- a/src/etl/crc.h
+++ b/src/etl/crc.h
@@ -40,6 +40,8 @@ SOFTWARE.
 #include "crc8_ebu.h"
 #include "crc8_icode.h"
 #include "crc8_itu.h"
+#include "crc8_j1850_zero.h"
+#include "crc8_j1850.h"
 #include "crc8_maxim.h"
 #include "crc8_rohc.h"
 #include "crc8_wcdma.h"
diff --git a/src/etl/crc8_j1850.h b/src/etl/crc8_j1850.h
new file mode 100644
index 0000000..723a295
--- /dev/null
+++ b/src/etl/crc8_j1850.h
@@ -0,0 +1,79 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2021 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#ifndef ETL_CRC8_J1850_INCLUDED
+#define ETL_CRC8_J1850_INCLUDED
+
+#include "platform.h"
+#include "private/crc_implementation.h"
+
+///\defgroup SAE J1850 8 bit CRC calculation
+///\ingroup crc
+
+namespace etl
+{
+#if ETL_USING_CPP11 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
+  template <size_t Table_Size>
+  using crc8_j1850_t = etl::crc_type<etl::private_crc::crc8_j1850_parameters, Table_Size>;
+#else
+  template <size_t Table_Size>
+  class crc8_j1850_t : public etl::crc_type<etl::private_crc::crc8_j1850_parameters, Table_Size>
+  {
+  public:
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    crc8_j1850_t()
+    {
+      this->reset();
+    }
+
+    //*************************************************************************
+    /// Constructor from range.
+    /// \param begin Start of the range.
+    /// \param end   End of the range.
+    //*************************************************************************
+    template<typename TIterator>
+    crc8_j1850_t(TIterator begin, const TIterator end)
+    {
+      this->reset();
+      this->add(begin, end);
+    }
+  };
+#endif
+    
+  typedef etl::crc8_j1850_t<256U> crc8_j1850_t256;
+  typedef etl::crc8_j1850_t<16U>  crc8_j1850_t16;
+  typedef etl::crc8_j1850_t<4U>   crc8_j1850_t4;
+  typedef crc8_j1850_t256         crc8_j1850;
+}
+
+#endif
diff --git a/src/etl/crc8_j1850_zero.h b/src/etl/crc8_j1850_zero.h
new file mode 100644
index 0000000..04bd7b5
--- /dev/null
+++ b/src/etl/crc8_j1850_zero.h
@@ -0,0 +1,79 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2021 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#ifndef ETL_CRC8_J1850_ZERO_INCLUDED
+#define ETL_CRC8_J1850_ZERO_INCLUDED
+
+#include "platform.h"
+#include "private/crc_implementation.h"
+
+///\defgroup SAE J1850 Zero 8 bit CRC calculation
+///\ingroup crc
+
+namespace etl
+{
+#if ETL_USING_CPP11 && !defined(ETL_CRC_FORCE_CPP03_IMPLEMENTATION)
+  template <size_t Table_Size>
+  using crc8_j1850_zero_t = etl::crc_type<etl::private_crc::crc8_j1850_zero_parameters, Table_Size>;
+#else
+  template <size_t Table_Size>
+  class crc8_j1850_zero_t : public etl::crc_type<etl::private_crc::crc8_j1850_zero_parameters, Table_Size>
+  {
+  public:
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    crc8_j1850_zero_t()
+    {
+      this->reset();
+    }
+
+    //*************************************************************************
+    /// Constructor from range.
+    /// \param begin Start of the range.
+    /// \param end   End of the range.
+    //*************************************************************************
+    template<typename TIterator>
+    crc8_j1850_zero_t(TIterator begin, const TIterator end)
+    {
+      this->reset();
+      this->add(begin, end);
+    }
+  };
+#endif
+    
+  typedef etl::crc8_j1850_zero_t<256U> crc8_j1850_zero_t256;
+  typedef etl::crc8_j1850_zero_t<16U>  crc8_j1850_zero_t16;
+  typedef etl::crc8_j1850_zero_t<4U>   crc8_j1850_zero_t4;
+  typedef crc8_j1850_zero_t256         crc8_j1850_zero;
+}
+
+#endif
diff --git a/src/etl/cyclic_value.h b/src/etl/cyclic_value.h
index 03f1932..392c7a1 100644
--- a/src/etl/cyclic_value.h
+++ b/src/etl/cyclic_value.h
@@ -49,19 +49,19 @@ namespace etl
   //***************************************************************************
   /// Provides a value that cycles between two limits.
   //***************************************************************************
-  template <typename T, T FIRST = 0, T LAST = 0, bool EtlRuntimeSpecialisation = ((FIRST == 0) && (LAST == 0))>
+  template <typename T, T First = 0, T Last = 0, bool EtlRuntimeSpecialisation = ((First == 0) && (Last == 0))>
   class cyclic_value;
 
   //***************************************************************************
-  /// Provides a value that cycles between two limits.
+  /// Provides a value that cycles between two compile time limits.
   /// Supports incrementing and decrementing.
   ///\tparam T     The type of the variable.
-  ///\tparam FIRST The first value of the range.
-  ///\tparam LAST  The last value of the range.
+  ///\tparam First The first value of the range.
+  ///\tparam Last  The last value of the range.
   ///\ingroup cyclic_value
   //***************************************************************************
-  template <typename T, T FIRST, T LAST>
-  class cyclic_value<T, FIRST, LAST, false>
+  template <typename T, T First, T Last>
+  class cyclic_value<T, First, Last, false>
   {
   public:
 
@@ -70,7 +70,7 @@ namespace etl
     /// The initial value is set to the first value.
     //*************************************************************************
     cyclic_value()
-      : value(FIRST)
+      : value(First)
     {
     }
 
@@ -87,7 +87,7 @@ namespace etl
     //*************************************************************************
     /// Copy constructor.
     //*************************************************************************
-    cyclic_value(const cyclic_value<T, FIRST, LAST>& other)
+    cyclic_value(const cyclic_value<T, First, Last>& other)
       : value(other.value)
     {
     }
@@ -95,7 +95,7 @@ namespace etl
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
-    cyclic_value& operator =(const cyclic_value<T, FIRST, LAST>& other)
+    cyclic_value& operator =(const cyclic_value<T, First, Last>& other)
     {
       value = other.value;
 
@@ -104,17 +104,18 @@ namespace etl
 
     //*************************************************************************
     /// Sets the value.
+    /// Truncates to the First/Last range.
     ///\param value The value.
     //*************************************************************************
     void set(T value_)
     {
-      if (value_ > LAST)
+      if (value_ > Last)
       {
-        value_ = LAST;
+        value_ = Last;
       }
-      else if (value_ < FIRST)
+      else if (value_ < First)
       {
-        value_ = FIRST;
+        value_ = First;
       }
 
       value = value_;
@@ -125,7 +126,7 @@ namespace etl
     //*************************************************************************
     void to_first()
     {
-      value = FIRST;
+      value = First;
     }
 
     //*************************************************************************
@@ -133,7 +134,7 @@ namespace etl
     //*************************************************************************
     void to_last()
     {
-      value = LAST;
+      value = Last;
     }
 
     //*************************************************************************
@@ -181,9 +182,9 @@ namespace etl
     //*************************************************************************
     cyclic_value& operator ++()
     {
-      if (value >= LAST) ETL_UNLIKELY
+      if (value >= Last) ETL_UNLIKELY
       {
-        value = FIRST;
+        value = First;
       }
       else
       {
@@ -210,9 +211,9 @@ namespace etl
     //*************************************************************************
     cyclic_value& operator --()
     {
-      if (value <= FIRST) ETL_UNLIKELY
+      if (value <= First) ETL_UNLIKELY
       {
-        value = LAST;
+        value = Last;
       }
       else
       {
@@ -264,23 +265,23 @@ namespace etl
     //*************************************************************************
     /// Gets the first value.
     //*************************************************************************
-    const T first() const
+    static ETL_CONSTEXPR T first()
     {
-      return FIRST;
+      return First;
     }
 
     //*************************************************************************
     /// Gets the last value.
     //*************************************************************************
-    const T last() const
+    static ETL_CONSTEXPR T last()
     {
-      return LAST;
+      return Last;
     }
 
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    void swap(cyclic_value<T, FIRST, LAST>& other)
+    void swap(cyclic_value<T, First, Last>& other)
     {
       using ETL_OR_STD::swap; // Allow ADL
 
@@ -290,7 +291,7 @@ namespace etl
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    friend void swap(cyclic_value<T, FIRST, LAST>& lhs, cyclic_value<T, FIRST, LAST>& rhs)
+    friend void swap(cyclic_value<T, First, Last>& lhs, cyclic_value<T, First, Last>& rhs)
     {
       lhs.swap(rhs);
     }
@@ -298,7 +299,7 @@ namespace etl
     //*************************************************************************
     /// Operator ==.
     //*************************************************************************
-    friend bool operator == (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator == (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return lhs.value == rhs.value;
     }
@@ -306,7 +307,7 @@ namespace etl
     //*************************************************************************
     /// Operator !=.
     //*************************************************************************
-    friend bool operator != (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator != (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return !(lhs == rhs);
     }
@@ -317,15 +318,15 @@ namespace etl
   };
 
   //***************************************************************************
-  /// Provides a value that cycles between two limits.
+  /// Provides a value that cycles between two run time limits.
   /// Supports incrementing and decrementing.
   ///\tparam T     The type of the variable.
-  ///\tparam FIRST The first value of the range.
-  ///\tparam LAST  The last value of the range.
+  ///\tparam First The first value of the range.
+  ///\tparam Last  The last value of the range.
   ///\ingroup cyclic_value
   //***************************************************************************
-  template <typename T, T FIRST, T LAST>
-  class cyclic_value<T, FIRST, LAST, true>
+  template <typename T, T First, T Last>
+  class cyclic_value<T, First, Last, true>
   {
   public:
 
@@ -335,9 +336,9 @@ namespace etl
     /// The initial value is set to the first value.
     //*************************************************************************
     cyclic_value()
-      : value(FIRST),
-        first_value(FIRST),
-        last_value(LAST)
+      : value(First)
+      , first_value(First)
+      , last_value(Last)
     {
     }
 
@@ -348,9 +349,9 @@ namespace etl
     ///\param last  The last value in the range.
     //*************************************************************************
     cyclic_value(T first_, T last_)
-      : value(first_),
-        first_value(first_),
-        last_value(last_) 
+      : value(first_)
+      , first_value(first_)
+      , last_value(last_) 
     {
     }
 
@@ -372,9 +373,9 @@ namespace etl
     /// Copy constructor.
     //*************************************************************************
     cyclic_value(const cyclic_value& other)
-      : value(other.value),
-        first_value(other.first_value),
-        last_value(other.last_value)
+      : value(other.value)
+      , first_value(other.first_value)
+      , last_value(other.last_value)
     {
     }
 
@@ -570,7 +571,7 @@ namespace etl
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    void swap(cyclic_value<T, FIRST, LAST>& other)
+    void swap(cyclic_value<T, First, Last>& other)
     {
       using ETL_OR_STD::swap; // Allow ADL
 
@@ -582,7 +583,7 @@ namespace etl
     //*************************************************************************
     /// Swaps the values.
     //*************************************************************************
-    friend void swap(cyclic_value<T, FIRST, LAST>& lhs, cyclic_value<T, FIRST, LAST>& rhs)
+    friend void swap(cyclic_value<T, First, Last>& lhs, cyclic_value<T, First, Last>& rhs)
     {
       lhs.swap(rhs);
     }
@@ -590,7 +591,7 @@ namespace etl
     //*************************************************************************
     /// Operator ==.
     //*************************************************************************
-    friend bool operator == (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator == (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return (lhs.value       == rhs.value) &&
              (lhs.first_value == rhs.first_value) &&
@@ -600,7 +601,7 @@ namespace etl
     //*************************************************************************
     /// Operator !=.
     //*************************************************************************
-    friend bool operator != (const cyclic_value<T, FIRST, LAST>& lhs, const cyclic_value<T, FIRST, LAST>& rhs)
+    friend bool operator != (const cyclic_value<T, First, Last>& lhs, const cyclic_value<T, First, Last>& rhs)
     {
       return !(lhs == rhs);
     }
diff --git a/src/etl/deque.h b/src/etl/deque.h
index 8a11063..8e7c357 100644
--- a/src/etl/deque.h
+++ b/src/etl/deque.h
@@ -41,7 +41,6 @@ SOFTWARE.
 #include "debug_count.h"
 #include "algorithm.h"
 #include "type_traits.h"
-#include "iterator.h"
 #include "placement_new.h"
 #include "initializer_list.h"
 
@@ -258,17 +257,17 @@ namespace etl
 
       //***************************************************
       iterator(const iterator& other)
-        : index(other.index),
-        p_deque(other.p_deque),
-        p_buffer(other.p_buffer)
+        : index(other.index)
+        , p_deque(other.p_deque)
+        , p_buffer(other.p_buffer)
       {
       }
 
       //***************************************************
       iterator& operator =(const iterator& other)
       {
-        index = other.index;
-        p_deque = other.p_deque;
+        index    = other.index;
+        p_deque  = other.p_deque;
         p_buffer = other.p_buffer;
 
         return *this;
@@ -352,6 +351,24 @@ namespace etl
         return &p_buffer[index];
       }
 
+      //***************************************************
+      reference operator [](size_t i)
+      {
+        iterator result(*this);
+        result += i;
+
+        return *result;
+      }
+
+      //***************************************************
+      const_reference operator [](size_t i) const
+      {
+        iterator result(*this);
+        result += i;
+
+        return *result;
+      }
+
       //***************************************************
       friend iterator operator +(const iterator& lhs, difference_type offset)
       {
@@ -360,6 +377,14 @@ namespace etl
         return result;
       }
 
+      //***************************************************
+      friend iterator operator +(difference_type offset, const iterator& lhs)
+      {
+        iterator result(lhs);
+        result += offset;
+        return result;
+      }
+
       //***************************************************
       friend iterator operator -(const iterator& lhs, difference_type offset)
       {
@@ -596,6 +621,15 @@ namespace etl
         return &p_buffer[index];
       }
 
+      //***************************************************
+      reference operator [](size_t i)
+      {
+        iterator result(*this);
+        result += i;
+
+        return *result;
+      }
+
       //***************************************************
       friend const_iterator operator +(const const_iterator& lhs, difference_type offset)
       {
@@ -604,6 +638,14 @@ namespace etl
         return result;
       }
 
+      //***************************************************
+      friend const_iterator operator +(difference_type offset, const const_iterator& lhs)
+      {
+        const_iterator result(lhs);
+        result += offset;
+        return result;
+      }
+
       //***************************************************
       friend const_iterator operator -(const const_iterator& lhs, difference_type offset)
       {
@@ -2054,22 +2096,6 @@ namespace etl
       return distance(rhs, lhs);
     }
 
-    //*************************************************************************
-    /// - operator for reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
-    //*************************************************************************
-    /// - operator for const_reverse_iterator
-    //*************************************************************************
-    friend difference_type operator -(const const_reverse_iterator& lhs, const const_reverse_iterator& rhs)
-    {
-      return distance(lhs.base(), rhs.base());
-    }
-
     //*************************************************************************
     /// Assignment operator.
     //*************************************************************************
@@ -2483,11 +2509,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IDEQUE_REPAIR_ENABLE
-      virtual
-#endif
-      void repair()
-#ifdef ETL_IDEQUE_REPAIR_ENABLE
-      ETL_OVERRIDE
+        virtual void repair() ETL_OVERRIDE
+#else
+        void repair()
 #endif
     {
 #if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
diff --git a/src/etl/exception.h b/src/etl/exception.h
index 90ab6e7..49e6adc 100644
--- a/src/etl/exception.h
+++ b/src/etl/exception.h
@@ -100,7 +100,7 @@ namespace etl
 
     //***************************************************************************
     /// Gets the line for the exception.
-    /// \return const char* to the line.
+    /// \return int as line number.
     //***************************************************************************
     ETL_CONSTEXPR
     numeric_type line_number() const
diff --git a/src/etl/expected.h b/src/etl/expected.h
index f7a123f..0c3dd98 100644
--- a/src/etl/expected.h
+++ b/src/etl/expected.h
@@ -38,6 +38,7 @@ SOFTWARE.
 #include "error_handler.h"
 #include "utility.h"
 #include "variant.h"
+#include "initializer_list.h"
 
 namespace etl
 {
@@ -353,6 +354,7 @@ namespace etl
     {
     }
 
+#if ETL_HAS_INITIALIZER_LIST
     //*******************************************
     /// Construct value type from initializser_list and arguments.
     //*******************************************
@@ -361,6 +363,7 @@ namespace etl
       : storage(il, etl::forward<Args>(args)...)
     {
     }
+#endif
 
     //*******************************************
     /// Construct error type from arguments.
@@ -608,17 +611,23 @@ namespace etl
     template <typename... Args>
     ETL_CONSTEXPR14 value_type& emplace(Args&&... args) ETL_NOEXCEPT
     {
-      storage.emplace(etl::forward<Args>(args)...);
+      storage.template emplace<value_type>(etl::forward<Args>(args)...);
+
+      return value();
     }
 
     //*******************************************
     ///
     //*******************************************
+#if ETL_HAS_INITIALIZER_LIST
     template <typename U, typename... Args>
-    ETL_CONSTEXPR14 value_type& emplace(std::initializer_list<U>& il, Args&&... args) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 value_type& emplace(std::initializer_list<U> il, Args&&... args) ETL_NOEXCEPT
     {
-      storage.emplace(il, etl::forward<Args>(args)...);
+      storage.template emplace<value_type>(il, etl::forward<Args>(args)...);
+
+      return value();
     }
+#endif
 #else
     //*******************************************
     ///
diff --git a/src/etl/fsm.h b/src/etl/fsm.h
index 19584a9..0471577 100644
--- a/src/etl/fsm.h
+++ b/src/etl/fsm.h
@@ -158,7 +158,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// Exception for forbidden state chages.
+  /// Exception for forbidden state changes.
   //***************************************************************************
   class fsm_state_composite_state_change_forbidden : public etl::fsm_exception
   {
@@ -169,6 +169,18 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Exception for message received but not started.
+  //***************************************************************************
+  class fsm_not_started : public etl::fsm_exception
+  {
+  public:
+    fsm_not_started(string_type file_name_, numeric_type line_number_)
+      : etl::fsm_exception(ETL_ERROR_TEXT("fsm:not started", ETL_FSM_FILE_ID"F"), file_name_, line_number_)
+    {
+    }
+  };
+
   namespace private_fsm
   {
     template <typename T = void>
@@ -404,31 +416,38 @@ namespace etl
     //*******************************************
     void receive(const etl::imessage& message) ETL_OVERRIDE
     {
-      etl::fsm_state_id_t next_state_id = p_state->process_event(message);
-
-      if (have_changed_state(next_state_id))
+      if (is_started())
       {
-        ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-        etl::ifsm_state* p_next_state = state_list[next_state_id];
+        etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        do
+        if (have_changed_state(next_state_id))
         {
-          p_state->on_exit_state();
-          p_state = p_next_state;
-
-          next_state_id = p_state->on_enter_state();
+          ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          etl::ifsm_state* p_next_state = state_list[next_state_id];
 
-          if (have_changed_state(next_state_id))
+          do
           {
-            ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-            p_next_state = state_list[next_state_id];
-          }
-        } while (p_next_state != p_state); // Have we changed state again?
+            p_state->on_exit_state();
+            p_state = p_next_state;
+
+            next_state_id = p_state->on_enter_state();
+
+            if (have_changed_state(next_state_id))
+            {
+              ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+              p_next_state = state_list[next_state_id];
+            }
+          } while (p_next_state != p_state); // Have we changed state again?
+        }
+        else if (is_self_transition(next_state_id))
+        {
+          p_state->on_exit_state();
+          p_state->on_enter_state();
+        }
       }
-      else if (is_self_transition(next_state_id))
+      else
       {
-        p_state->on_exit_state();
-        p_state->on_enter_state();
+        ETL_ASSERT_FAIL(ETL_ERROR(etl::fsm_not_started));
       }
     }
 
@@ -587,11 +606,11 @@ namespace etl
 
     //********************************************
     template <typename TMessage>
-    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& state_id)
+    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& new_state_id)
     {
       if (TMessage::ID == msg.get_message_id())
       {
-        state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
+        new_state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
         return true;
       }
       else
diff --git a/src/etl/functional.h b/src/etl/functional.h
index e6a72ad..d762506 100644
--- a/src/etl/functional.h
+++ b/src/etl/functional.h
@@ -32,6 +32,7 @@ SOFTWARE.
 #define ETL_FUNCTIONAL_INCLUDED
 
 #include "platform.h"
+#include "utility.h"
 
 ///\defgroup functional functional
 ///\ingroup utilities
@@ -528,6 +529,73 @@ namespace etl
       return ~lhs;
     }
   };
+
+#if ETL_USING_CPP11
+  namespace private_functional
+  {
+    //***************************************************************************
+    template<typename TReturnType, typename TClassType, typename... TArgs>
+    class mem_fn_impl
+    {
+    public:
+
+      typedef TReturnType(TClassType::* MemberFunctionType)(TArgs...);
+
+      ETL_CONSTEXPR mem_fn_impl(MemberFunctionType member_function_)
+        : member_function(member_function_)
+      {
+      }
+
+      ETL_CONSTEXPR TReturnType operator()(TClassType& instance, TArgs... args) const
+      {
+        return (instance.*member_function)(etl::forward<TArgs>(args)...);
+      }
+
+    private:
+
+      MemberFunctionType member_function;
+    };
+
+    //***************************************************************************
+    template<typename TReturnType, typename TClassType, typename... TArgs>
+    class const_mem_fn_impl
+    {
+    public:
+
+      typedef TReturnType(TClassType::* MemberFunctionType)(TArgs...) const;
+
+      ETL_CONSTEXPR const_mem_fn_impl(MemberFunctionType member_function_)
+        : member_function(member_function_)
+      {
+      }
+
+      ETL_CONSTEXPR TReturnType operator()(const TClassType& instance, TArgs... args) const
+      {
+        return (instance.*member_function)(etl::forward<TArgs>(args)...);
+      }
+
+    private:
+
+      MemberFunctionType member_function;
+    };
+  }
+
+  //***************************************************************************
+  template<typename TReturnType, typename TClassType, typename... TArgs>
+  ETL_CONSTEXPR
+  private_functional::mem_fn_impl<TReturnType, TClassType, TArgs...> mem_fn(TReturnType(TClassType::* member_function)(TArgs...))
+  {
+    return private_functional::mem_fn_impl<TReturnType, TClassType, TArgs...>(member_function);
+  }
+
+  //***************************************************************************
+  template<typename TReturnType, typename TClassType, typename... TArgs>
+  ETL_CONSTEXPR
+  private_functional::const_mem_fn_impl<TReturnType, TClassType, TArgs...> mem_fn(TReturnType(TClassType::* member_function)(TArgs...) const)
+  {
+    return private_functional::const_mem_fn_impl<TReturnType, TClassType, TArgs...>(member_function);
+  }
+#endif
 }
 
 #endif
diff --git a/src/etl/gcd.h b/src/etl/gcd.h
new file mode 100644
index 0000000..aea495e
--- /dev/null
+++ b/src/etl/gcd.h
@@ -0,0 +1,144 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2024 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#ifndef ETL_GDC_INCLUDED
+#define ETL_GDC_INCLUDED
+
+#include "type_traits.h"
+#include "absolute.h"
+#include "static_assert.h"
+
+namespace etl
+{
+  //***************************************************************************
+  // Greatest Common Divisor.
+  // For unsigned types.
+  //***************************************************************************
+  template <typename T>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
+    gcd(T a, T b) ETL_NOEXCEPT
+  {
+    ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Integral type required");
+
+    if ((a == 0 || b == 0))
+    {
+      return (a + b);
+    }
+
+    while (b != 0) 
+    {
+      T t = b;
+      b = a % b;
+      a = t;
+    }
+    
+    return a;
+  }
+
+  //***************************************************************************
+  // Greatest Common Divisor.
+  // For signed types.
+  //***************************************************************************
+  template <typename T>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  typename etl::enable_if<etl::is_signed<T>::value, T>::type
+    gcd(T a, T b) ETL_NOEXCEPT
+  {
+    ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Integral type required");
+
+    typedef typename etl::make_unsigned<T>::type utype;
+
+    utype ua = etl::absolute_unsigned(a);
+    utype ub = etl::absolute_unsigned(b);
+
+    return static_cast<T>(gcd(ua, ub));
+  }
+
+#if ETL_USING_CPP11
+  #if ETL_HAS_INITIALIZER_LIST
+  //***************************************************************************
+  // Greatest Common Divisor.
+  // Non-recursive, using an initializer_list.
+  // Top level variadic function.
+  //***************************************************************************
+  template<typename T, typename... TRest>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  T gcd(T first, TRest... rest) ETL_NOEXCEPT
+  {
+    T result = first;
+
+    for (T value : {rest...})
+    {
+      result = gcd(result, value);
+
+      if (result == 1)
+      {
+        // Early termination: if the GCD is one, it will remain one
+        // no matter what other numbers are processed.
+        return 1;
+      }
+    }
+
+    return result;
+  }
+  #else
+  //***************************************************************************
+  // Greatest Common Divisor.
+  // Recursive.
+  // Top level variadic function.
+  //***************************************************************************
+  template<typename T, typename... TRest>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  T gcd(T a, T b, TRest... rest) ETL_NOEXCEPT
+  {
+    T gcd_ab = gcd(a, b);
+
+    if (gcd_ab == 1)
+    {
+      // Early termination: if the GCD is one, it will remain one
+      // no matter what other numbers are processed.
+      return 1;
+    }
+    else
+    {
+      return gcd(gcd_ab, rest...);
+    }
+  }
+  #endif
+#endif
+}
+
+#endif
+
diff --git a/src/etl/generators/fsm_generator.h b/src/etl/generators/fsm_generator.h
index a59d1fa..d0e029f 100644
--- a/src/etl/generators/fsm_generator.h
+++ b/src/etl/generators/fsm_generator.h
@@ -177,7 +177,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// Exception for forbidden state chages.
+  /// Exception for forbidden state changes.
   //***************************************************************************
   class fsm_state_composite_state_change_forbidden : public etl::fsm_exception
   {
@@ -188,6 +188,18 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Exception for message received but not started.
+  //***************************************************************************
+  class fsm_not_started : public etl::fsm_exception
+  {
+  public:
+    fsm_not_started(string_type file_name_, numeric_type line_number_)
+      : etl::fsm_exception(ETL_ERROR_TEXT("fsm:not started", ETL_FSM_FILE_ID"F"), file_name_, line_number_)
+    {
+    }
+  };
+
   namespace private_fsm
   {
     template <typename T = void>
@@ -430,31 +442,38 @@ namespace etl
     //*******************************************
     void receive(const etl::imessage& message) ETL_OVERRIDE
     {
-      etl::fsm_state_id_t next_state_id = p_state->process_event(message);
-
-      if (have_changed_state(next_state_id))
+      if (is_started())
       {
-        ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-        etl::ifsm_state* p_next_state = state_list[next_state_id];
+        etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        do
+        if (have_changed_state(next_state_id))
         {
-          p_state->on_exit_state();
-          p_state = p_next_state;
-
-          next_state_id = p_state->on_enter_state();
+          ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          etl::ifsm_state* p_next_state = state_list[next_state_id];
 
-          if (have_changed_state(next_state_id))
+          do
           {
-            ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-            p_next_state = state_list[next_state_id];
-          }
-        } while (p_next_state != p_state); // Have we changed state again?
+            p_state->on_exit_state();
+            p_state = p_next_state;
+
+            next_state_id = p_state->on_enter_state();
+
+            if (have_changed_state(next_state_id))
+            {
+              ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+              p_next_state = state_list[next_state_id];
+            }
+          } while (p_next_state != p_state); // Have we changed state again?
+        }
+        else if (is_self_transition(next_state_id))
+        {
+          p_state->on_exit_state();
+          p_state->on_enter_state();
+        }
       }
-      else if (is_self_transition(next_state_id))
+      else
       {
-        p_state->on_exit_state();
-        p_state->on_enter_state();
+        ETL_ASSERT_FAIL(ETL_ERROR(etl::fsm_not_started));
       }
     }
 
@@ -613,11 +632,11 @@ namespace etl
 
     //********************************************
     template <typename TMessage>
-    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& state_id)
+    bool process_event_type(const etl::imessage& msg, etl::fsm_state_id_t& new_state_id)
     {
       if (TMessage::ID == msg.get_message_id())
       {
-        state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
+        new_state_id = static_cast<TDerived*>(this)->on_event(static_cast<const TMessage&>(msg));
         return true;
       }
       else
diff --git a/src/etl/generators/message_packet_generator.h b/src/etl/generators/message_packet_generator.h
index cc3cfab..595fa12 100644
--- a/src/etl/generators/message_packet_generator.h
+++ b/src/etl/generators/message_packet_generator.h
@@ -111,7 +111,7 @@ namespace etl
     ///
     //********************************************
 #include "private/diagnostic_uninitialized_push.h"
-    template <typename T>
+    template <typename T, typename = typename etl::enable_if<IsIMessage<T> || IsInMessageList<T>, int>::type>
     explicit message_packet(T&& msg)
       : valid(true)
     {
@@ -133,10 +133,6 @@ namespace etl
       {
         add_new_message_type<T>(etl::forward<T>(msg));
       }
-      else if constexpr (IsMessagePacket<T>)
-      {
-        copy(etl::forward<T>(msg));
-      }
       else
       {
         ETL_STATIC_ASSERT(IsInMessageList<T>, "Message not in packet type list");
@@ -144,6 +140,30 @@ namespace etl
     }
 #include "private/diagnostic_pop.h"
 
+    //**********************************************
+    message_packet(const message_packet& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(other.get());
+      }
+    }
+
+#if ETL_USING_CPP11
+    //**********************************************
+    message_packet(message_packet&& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(etl::move(other.get()));
+      }
+    }
+#endif
+
     //**********************************************
     void copy(const message_packet& other)
     {
diff --git a/src/etl/generators/message_router_generator.h b/src/etl/generators/message_router_generator.h
index 32903ac..35d47d7 100644
--- a/src/etl/generators/message_router_generator.h
+++ b/src/etl/generators/message_router_generator.h
@@ -51,7 +51,7 @@ cog.outl("//********************************************************************
 // Note: You will need Python and COG installed.
 //
 // python -m cogapp -d -e -omessage_router.h -DHandlers=<n> message_router_generator.h
-// Where <n> is the number of messages to support.
+// Where <n> is the maximum number of messages to support.
 //
 // e.g.
 // To generate handlers for up to 16 messages...
@@ -212,8 +212,8 @@ namespace etl
     }
 
     //********************************************
-    null_message_router(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    null_message_router(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
     
@@ -290,8 +290,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    message_producer(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
 
@@ -303,8 +303,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor)
-      : imessage_router(id_, successor)
+    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor_)
+      : imessage_router(id_, successor_)
     {
       ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
     }
@@ -354,11 +354,22 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage_router?
+  //***************************************************************************
+  template <typename T>
+  struct is_message_router : public etl::bool_constant<etl::is_base_of<etl::imessage_router, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
   //***************************************************************************
   /// Send a message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  const etl::imessage&  message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&        destination,
+                 const TMessage& message)
   {
     destination.receive(message);
   }
@@ -366,8 +377,11 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&            destination,
+                 etl::shared_message message)
   {
     destination.receive(message);
   }
@@ -375,9 +389,12 @@ namespace etl
   //***************************************************************************
   /// Send a message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  const etl::imessage& message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 const TMessage&          message)
   {
     destination.receive(id, message);
   }
@@ -385,9 +402,12 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 etl::shared_message      message)
   {
     destination.receive(id, message);
   }
diff --git a/src/etl/generators/type_traits_generator.h b/src/etl/generators/type_traits_generator.h
index d2cf8ce..35db7ea 100644
--- a/src/etl/generators/type_traits_generator.h
+++ b/src/etl/generators/type_traits_generator.h
@@ -74,7 +74,7 @@ cog.outl("//********************************************************************
 
 ///\defgroup type_traits type_traits
 /// A set of type traits definitions.
-/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined.
+/// Derived from either the standard or alternate definitions, dependent on whether or not ETL_NO_STL is defined.
 /// \ingroup utilities
 
 #if ETL_USING_STL && ETL_USING_CPP11
@@ -1406,6 +1406,52 @@ typedef integral_constant<bool, true>  true_type;
   inline constexpr bool is_one_of_v = etl::is_one_of<T, TRest...>::value;
 #endif
 
+#if ETL_USING_CPP11
+  //***************************************************************************
+  /// Template to determine if a type is a base of all types in a specified list.
+  ///\ingroup types
+  template <typename T, typename T1, typename... TRest>
+  struct is_base_of_all
+  {
+    static const bool value = etl::is_base_of<T, T1>::value &&
+                              etl::is_base_of_all<T, TRest...>::value;
+  };
+
+  template <typename T, typename T1>
+  struct is_base_of_all<T, T1>
+  {
+    static const bool value = etl::is_base_of<T, T1>::value;
+  };
+#endif
+
+#if ETL_USING_CPP17
+  template <typename T, typename... TRest>
+  inline constexpr bool is_base_of_all_v = etl::is_base_of_all<T, TRest...>::value;
+#endif
+
+#if ETL_USING_CPP11
+  //***************************************************************************
+  /// Template to determine if a type is a base of any type in a specified list.
+  ///\ingroup types
+  template <typename T, typename T1, typename... TRest>
+  struct is_base_of_any
+  {
+    static const bool value = etl::is_base_of<T, T1>::value ||
+                              etl::is_base_of_any<T, TRest...>::value;
+  };
+
+  template <typename T, typename T1>
+  struct is_base_of_any<T, T1>
+  {
+    static const bool value = etl::is_base_of<T, T1>::value;
+  };
+#endif
+
+#if ETL_USING_CPP17
+  template <typename T, typename... TRest>
+  inline constexpr bool is_base_of_any_v = etl::is_base_of_any<T, TRest...>::value;
+#endif
+
   //***************************************************************************
   /// A set of templates to allow related types to be derived.
   ///\ingroup types
@@ -2077,6 +2123,21 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
+#if ETL_USING_CPP11
+  //*********************************************
+  // is_default_constructible
+  template<typename T, typename = void>
+  struct is_default_constructible : etl::false_type { };
+
+  template<typename T>
+  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type { };
+#else
+  template <typename T>
+  struct is_default_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
+  {
+  };
+#endif
+
 #if ETL_USING_CPP17
 
   template <typename T1, typename T2>
@@ -2088,6 +2149,9 @@ typedef integral_constant<bool, true>  true_type;
   template<typename T, typename... TArgs>
   inline constexpr bool is_constructible_v = etl::is_constructible<T, TArgs...>::value;
 
+  template<typename T, typename... TArgs>
+  inline constexpr bool is_default_constructible_v = etl::is_default_constructible<T, TArgs...>::value;
+
   template<typename T>
   inline constexpr bool is_copy_constructible_v = etl::is_copy_constructible<T>::value;
 
diff --git a/src/etl/generators/variant_pool_generator.h b/src/etl/generators/variant_pool_generator.h
index 1ff7675..a212a1e 100644
--- a/src/etl/generators/variant_pool_generator.h
+++ b/src/etl/generators/variant_pool_generator.h
@@ -73,6 +73,120 @@ cog.outl("//********************************************************************
 
 namespace etl
 {
+#if ETL_USING_CPP11 && !defined(ETL_VARIANT_POOL_FORCE_CPP03_IMPLEMENTATION)
+  //***************************************************************************
+  template <size_t MAX_SIZE_, typename ... Ts>
+  class variant_pool
+    : public etl::generic_pool<etl::largest<Ts...>::size,
+                               etl::largest<Ts...>::alignment,
+                               MAX_SIZE_>
+  {
+  public:
+
+    typedef etl::generic_pool<etl::largest<Ts...>::size,
+                              etl::largest<Ts...>::alignment,
+                              MAX_SIZE_> base_t;
+
+    static const size_t MAX_SIZE = MAX_SIZE_;
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    variant_pool()
+    {
+    }
+
+    //*************************************************************************
+    /// Creates the object from a type. Variadic parameter constructor.
+    //*************************************************************************
+    template <typename T, typename... Args>
+    T* create(Args&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value), "Unsupported type");
+
+      return base_t::template create<T>(etl::forward<Args>(args)...);
+    }
+
+    //*************************************************************************
+    /// Destroys the object.
+    //*************************************************************************
+    template <typename T>
+    void destroy(const T* const p)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value || etl::is_base_of_any<T, Ts...>::value), "Invalid type");
+
+      base_t::destroy(p);
+    }
+
+    //*************************************************************************
+    /// Returns the maximum number of items in the variant_pool.
+    //*************************************************************************
+    size_t max_size() const
+    {
+      return MAX_SIZE;
+    }
+
+  private:
+
+    variant_pool(const variant_pool&) ETL_DELETE;
+    variant_pool& operator =(const variant_pool&) ETL_DELETE;
+  };
+
+  //***************************************************************************
+  template <typename ... Ts>
+  class variant_pool_ext
+    : public etl::generic_pool_ext<etl::largest<Ts...>::size,
+                                   etl::largest<Ts...>::alignment>
+  {
+  public:
+
+    typedef etl::generic_pool_ext<etl::largest<Ts...>::size,
+                                  etl::largest<Ts...>::alignment> base_t;
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    variant_pool_ext(typename base_t::element* buffer, size_t size)
+      : base_t(buffer, size)
+    {
+    }
+
+    //*************************************************************************
+    /// Creates the object from a type. Variadic parameter constructor.
+    //*************************************************************************
+    template <typename T, typename... Args>
+    T* create(Args&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value), "Unsupported type");
+
+      return base_t::template create<T>(etl::forward<Args>(args)...);
+    }
+
+    //*************************************************************************
+    /// Destroys the object.
+    //*************************************************************************
+    template <typename T>
+    void destroy(const T* const p)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value || etl::is_base_of_any<T, Ts...>::value), "Invalid type");
+
+      base_t::destroy(p);
+    }
+
+    //*************************************************************************
+    /// Returns the maximum number of items in the variant_pool.
+    //*************************************************************************
+    size_t max_size() const
+    {
+      return base_t::max_size();
+    }
+
+  private:
+
+    variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
+    variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
+  };
+#else
   //***************************************************************************
   /*[[[cog
   import cog
@@ -500,6 +614,7 @@ namespace etl
     variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
     variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
   };
+#endif
 }
 
 #endif
diff --git a/src/etl/hfsm.h b/src/etl/hfsm.h
index d61ac70..8afe94f 100644
--- a/src/etl/hfsm.h
+++ b/src/etl/hfsm.h
@@ -55,7 +55,7 @@ namespace etl
     /// Can only be called once.
     /// Subsequent calls will do nothing.
     ///\param call_on_enter_state If true will call on_enter_state() for the first state. Default = true.
-    /// If the first state has child states then they will be recersively entered.
+    /// If the first state has child states then they will be recursively entered.
     //*******************************************
     void start(bool call_on_enter_state = true) ETL_OVERRIDE
     {
@@ -98,30 +98,37 @@ namespace etl
     //*******************************************
     void receive(const etl::imessage& message) ETL_OVERRIDE
     {
-      etl::fsm_state_id_t next_state_id = p_state->process_event(message);
-
-      if (next_state_id != ifsm_state::No_State_Change)
+      if (is_started())
       {
-        ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-        etl::ifsm_state* p_next_state = state_list[next_state_id];
+        etl::fsm_state_id_t next_state_id = p_state->process_event(message);
 
-        // Have we changed state?
-        if (p_next_state != p_state)
+        if (next_state_id != ifsm_state::No_State_Change)
         {
-          etl::ifsm_state* p_root = common_ancestor(p_state, p_next_state);
-          do_exits(p_root, p_state);
+          ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+          etl::ifsm_state* p_next_state = state_list[next_state_id];
+
+          // Have we changed state?
+          if (p_next_state != p_state)
+          {
+            etl::ifsm_state* p_root = common_ancestor(p_state, p_next_state);
+            do_exits(p_root, p_state);
 
-          p_state = p_next_state;
+            p_state = p_next_state;
 
-          next_state_id = do_enters(p_root, p_next_state, true);
+            next_state_id = do_enters(p_root, p_next_state, true);
 
-          if (next_state_id != ifsm_state::No_State_Change)
-          {
-            ETL_ASSERT(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
-            p_state = state_list[next_state_id];
+            if (next_state_id != ifsm_state::No_State_Change)
+            {
+              ETL_ASSERT_OR_RETURN(next_state_id < number_of_states, ETL_ERROR(etl::fsm_state_id_exception));
+              p_state = state_list[next_state_id];
+            }
           }
         }
       }
+      else
+      {
+        ETL_ASSERT_FAIL(ETL_ERROR(etl::fsm_not_started));
+      }
     }
 
   private:
diff --git a/src/etl/intrusive_forward_list.h b/src/etl/intrusive_forward_list.h
index 665d42e..a38cf43 100644
--- a/src/etl/intrusive_forward_list.h
+++ b/src/etl/intrusive_forward_list.h
@@ -209,7 +209,7 @@ namespace etl
 #if defined(ETL_CHECK_PUSH_POP)
       ETL_ASSERT_OR_RETURN(!empty(), ETL_ERROR(intrusive_forward_list_empty));
 #endif
-      remove_link_after(start);
+      disconnect_link_after(start);
     }
 
     //*************************************************************************
@@ -297,7 +297,7 @@ namespace etl
     //*************************************************************************
     /// Remove a link.
     //*************************************************************************
-    void remove_link_after(link_type& link)
+    void disconnect_link_after(link_type& link)
     {
       link_type* p_next = link.etl_next;
 
@@ -333,6 +333,89 @@ namespace etl
       start.etl_next = &terminator;
       current_size = 0;
     }
+
+    //*************************************************************************
+    /// Tests if the link is in this list.
+    /// Returns the previous link to it, if found, otherwise ETL_NULLPTR.
+    //*************************************************************************
+    link_type* is_link_in_list(link_type& search_link)
+    {
+      link_type* p_link     = start.etl_next;
+      link_type* p_previous = &start;
+
+      while (p_link != ETL_NULLPTR)
+      {
+        if (&search_link == p_link)
+        {
+          return p_previous;
+        }
+
+        p_previous = p_link;
+
+        if (p_link != ETL_NULLPTR)
+        {
+          p_link = p_link->link_type::etl_next;
+        }
+      }
+
+      return ETL_NULLPTR;
+    }
+
+    //*************************************************************************
+    /// Remove the specified node from the list.
+    /// Returns ETL_NULLPTR if the link was not in this list.
+    /// Returns the next 
+    //*************************************************************************
+    link_type* remove_link(link_type& link)
+    {
+      link_type* result = ETL_NULLPTR;
+
+      link_type* p_previous = is_link_in_list(link);
+
+      if (p_previous != ETL_NULLPTR)
+      {
+        link_type* p_next = link.etl_next;
+
+        disconnect_link_after(*p_previous);
+
+        if (p_next != &this->terminator)
+        {
+          result = p_next;
+        }
+      }
+
+      return result;
+    }
+
+    //*************************************************************************
+    /// Remove a range of elements.
+    //*************************************************************************
+    link_type* remove_link_range_after(link_type* p_first, link_type* p_last)
+    {
+      link_type* p_after = p_first->etl_next;
+
+      // Join the ends.
+      etl::link<link_type>(p_first, p_last);
+
+      // Unlink the erased range.
+      link_type* p_unlink = p_after;
+
+      while (p_unlink != p_last)
+      {
+        link_type* p_next = p_unlink->etl_next;
+        p_unlink->clear();
+        p_unlink = p_next;
+      }
+
+      if (p_after == &this->terminator)
+      {
+        return ETL_NULLPTR;
+      }
+      else
+      {
+        return p_last;
+      }
+    }
   };
 
   template <typename TLink>
@@ -361,6 +444,8 @@ namespace etl
 
     typedef intrusive_forward_list<TValue, TLink> list_type;
 
+    typedef TValue node_type;
+
     //*************************************************************************
     /// iterator.
     //*************************************************************************
@@ -404,7 +489,9 @@ namespace etl
 
       reference operator *() const
       {
+#include "etl/private/diagnostic_null_dereference_push.h"
         return *static_cast<pointer>(p_value);
+#include "etl/private/diagnostic_pop.h"
       }
 
       pointer operator &() const
@@ -662,7 +749,7 @@ namespace etl
         if (next != end())
         {
           ++next;
-          this->remove_link_after(*position.p_value);
+          this->disconnect_link_after(*position.p_value);
         }
       }
 
@@ -680,22 +767,9 @@ namespace etl
 
         link_type* p_first = first.p_value;
         link_type* p_last  = last.p_value;
-        link_type* p_after = p_first->etl_next;
-        
-        // Join the ends.
-        etl::link<link_type>(p_first, p_last);
-
-        // Unlink the erased range.
-        link_type* p_unlink = p_after;
-
-        while (p_unlink != p_last)
-        {
-          link_type* p_next = p_unlink->etl_next;
-          p_unlink->clear();
-          p_unlink = p_next;
-        }
+        link_type* p_after = this->remove_link_range_after(p_first, p_last);
 
-        if (p_after == &this->terminator)
+        if (p_after == ETL_NULLPTR)
         {
           return end();
         }
@@ -710,6 +784,14 @@ namespace etl
       }
     }
 
+    //*************************************************************************
+    /// Erases the specified node.
+    //*************************************************************************
+    node_type* erase(node_type& node)
+    {
+      return static_cast<node_type*>(this->remove_link(node));
+    }
+
     //*************************************************************************
     /// Removes all but the one element from every consecutive group of equal
     /// elements in the container.
@@ -730,7 +812,7 @@ namespace etl
         // Is this value the same as the last?
         if (isEqual(*static_cast<pointer>(current), *static_cast<pointer>(last)))
         {
-          this->remove_link_after(*last);
+          this->disconnect_link_after(*last);
         }
         else
         {
diff --git a/src/etl/intrusive_list.h b/src/etl/intrusive_list.h
index 4a48f83..58c976e 100644
--- a/src/etl/intrusive_list.h
+++ b/src/etl/intrusive_list.h
@@ -175,7 +175,7 @@ namespace etl
 #if defined(ETL_CHECK_PUSH_POP)
       ETL_ASSERT(!empty(), ETL_ERROR(intrusive_list_empty));
 #endif
-      remove_link(get_head());
+      disconnect_link(get_head());
     }
 
     //*************************************************************************
@@ -196,7 +196,7 @@ namespace etl
 #if defined(ETL_CHECK_PUSH_POP)
       ETL_ASSERT(!empty(), ETL_ERROR(intrusive_list_empty));
 #endif
-      remove_link(get_tail());
+      disconnect_link(get_tail());
     }
 
     //*************************************************************************
@@ -320,7 +320,7 @@ namespace etl
     //*************************************************************************
     /// Remove a link.
     //*************************************************************************
-    void remove_link(link_type& link)
+    void disconnect_link(link_type& link)
     {
       etl::unlink<link_type>(link);
       --current_size;
@@ -329,7 +329,7 @@ namespace etl
     //*************************************************************************
     /// Remove a link.
     //*************************************************************************
-    void remove_link(link_type* link)
+    void disconnect_link(link_type* link)
     {
       etl::unlink<link_type>(*link);
       --current_size;
@@ -375,6 +375,74 @@ namespace etl
       etl::link(terminal_link, terminal_link);
       current_size = 0;
     }
+
+    //*************************************************************************
+    /// Tests if the link is in this list.
+    //*************************************************************************
+    bool is_link_in_list(link_type& search_link) const
+    {
+      link_type* p_link = terminal_link.link_type::etl_next;
+
+      while (p_link != &terminal_link)
+      {
+        if (&search_link == p_link)
+        {
+          return true;
+        }
+
+        p_link = p_link->link_type::etl_next;
+      }
+
+      return false;
+    }
+
+    //*************************************************************************
+    /// Remove the specified node from the list.
+    /// Returns ETL_NULLPTR if the link was not in this list or was the last in the list.
+    //*************************************************************************
+    link_type* remove_link(link_type& link)
+    {
+      link_type* result = ETL_NULLPTR;
+
+      if (is_link_in_list(link))
+      {
+        link_type* p_next = link.etl_next;
+
+        disconnect_link(link);
+
+        if (p_next != &terminal_link)
+        {
+          result = p_next;
+        }
+      }
+
+      return result;
+    }
+
+    //*************************************************************************
+    /// Removes a range of links.
+    //*************************************************************************
+    link_type* remove_link_range(link_type* p_first, link_type* p_last)
+    {
+      // Join the ends.
+      etl::link<link_type>(p_first->etl_previous, p_last);
+
+      while (p_first != p_last)
+      {
+        link_type* p_next = p_first->etl_next;
+        p_first->clear();
+        p_first = p_next;
+      }
+
+      if (p_last == &terminal_link)
+      {
+        return ETL_NULLPTR;
+      }
+      else
+      {
+        return p_last;
+      }
+    }
   };
 
   //***************************************************************************
@@ -392,6 +460,8 @@ namespace etl
 
     typedef intrusive_list<TValue, TLink> list_type;
 
+    typedef TValue node_type;
+
     // STL style typedefs.
     typedef TValue            value_type;
     typedef value_type*       pointer;
@@ -458,7 +528,9 @@ namespace etl
 
       reference operator *() const
       {
+#include "etl/private/diagnostic_null_dereference_push.h"
         return *static_cast<pointer>(p_value);
+#include "etl/private/diagnostic_pop.h"
       }
 
       pointer operator &() const
@@ -724,7 +796,7 @@ namespace etl
       iterator next(position);
       ++next;
 
-      this->remove_link(*position.p_value);
+      this->disconnect_link(*position.p_value);
 
       return next;
     }
@@ -737,7 +809,7 @@ namespace etl
       iterator next(position);
       ++next;
 
-      this->remove_link(*position.p_value);
+      this->disconnect_link(*position.p_value);
 
       return next;
     }
@@ -756,17 +828,9 @@ namespace etl
 
       this->current_size -= etl::distance(first, last);
 
-      // Join the ends.
-      etl::link<link_type>(p_first->etl_previous, p_last);
+      p_last = this->remove_link_range(p_first, p_last);
 
-      while (p_first != p_last)
-      {
-        link_type* p_next = p_first->etl_next;
-        p_first->clear();
-        p_first = p_next;
-      }
-
-      if (p_last == &this->terminal_link)
+      if (p_last == ETL_NULLPTR)
       {
         return end();
       }
@@ -776,6 +840,14 @@ namespace etl
       }
     }
 
+    //*************************************************************************
+    /// Erases the specified node.
+    //*************************************************************************
+    node_type* erase(node_type& node)
+    {
+      return static_cast<node_type*>(this->remove_link(node));
+    }
+
     //*************************************************************************
     /// Removes all but the one element from every consecutive group of equal
     /// elements in the container.
diff --git a/src/etl/iterator.h b/src/etl/iterator.h
index ab19db3..8053513 100644
--- a/src/etl/iterator.h
+++ b/src/etl/iterator.h
@@ -583,36 +583,25 @@ namespace etl
   //***************************************************************************
 
   //***************************************************************************
-  ///\brief  Turns assignment into insertion.
-  ///
-  /// These are output iterators, constructed from a container-of-T.
-  /// Assigning a T to the iterator appends it to the container using push_back.
-  ///
-  /// @tparam TContainer
+  /// Turns assignment into push_back
   //***************************************************************************
   template <typename TContainer>
   class back_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
   {
   public:
 
-    /// A nested typedef for the type of whatever container you used.
     typedef TContainer container_type;
 
-    /// The only way to create this %iterator is with a container.
+    //***************************************************************************
+    /// Constructor
+    //***************************************************************************
     explicit ETL_CONSTEXPR14 back_insert_iterator(TContainer& c)
       : container(etl::addressof(c))
     {
     }
 
     //***************************************************************************
-    /// This kind of %iterator doesn't really have a @a position in the
-    /// container (you can think of the position as being permanently at
-    /// the end, if you like).  Assigning a value to the %iterator will
-    /// always append the value to the end of the container.
-    ///
-    /// @param value An instance of whatever type container_type::const_reference is;
-    ///              presumably a reference-to-const T for container<T>.
-    /// @return This %iterator, for chained operations.
+    /// Assignment operator
     //***************************************************************************
     ETL_CONSTEXPR14 back_insert_iterator& operator =(const typename TContainer::value_type& value)
     {
@@ -635,7 +624,6 @@ namespace etl
 
     //***************************************************************************
     /// Dereference operator.
-    /// Simply returns *this.
     //***************************************************************************
     ETL_NODISCARD ETL_CONSTEXPR14 back_insert_iterator& operator *()
     {
@@ -644,7 +632,6 @@ namespace etl
 
     //***************************************************************************
     /// Pre-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 back_insert_iterator& operator ++()
     {
@@ -653,7 +640,6 @@ namespace etl
 
     //***************************************************************************
     /// Post-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 back_insert_iterator operator ++(int)
     {
@@ -666,15 +652,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// This wrapper function helps in creating back_insert_iterator instances.
-  /// Typing the name of the %iterator requires knowing the precise full
-  /// type of the container, which can be tedious and impedes generic
-  /// programming.  Using this function lets you take advantage of automatic
-  /// template parameter deduction, making the compiler match the correct types for you.
-  ///
-  /// @tparam TContainer The container type.
-  /// @param container A container of arbitrary type.
-  /// @return An instance of back_insert_iterator working on @p container.
+  /// Creates a back_insert_iterator from a container.
   //***************************************************************************
   template <typename TContainer>
   ETL_NODISCARD 
@@ -689,28 +667,17 @@ namespace etl
   //***************************************************************************
 
   //***************************************************************************
-  ///\brief Turns assignment into insertion.
-  ///
-  /// These are output iterators, constructed from a container-of-T.
-  /// Assigning a T to the iterator prepends it to the container using
-  /// push_front.
-  ///
-  /// Tip:  Using the front_inserter function to create these iterators can
-  /// save typing.
-  ///
-  ///\tparam TContainer The container type.
+  /// Turns assignment into a push_front.
   //***************************************************************************
   template <typename TContainer>
   class front_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
   {
   public:
 
-    /// A nested typedef for the type of whatever container you used.
     typedef TContainer container_type;
 
     //***************************************************************************
     /// Constructor
-    /// The only way to create this %iterator is with a container.
     //***************************************************************************
     explicit ETL_CONSTEXPR14 front_insert_iterator(TContainer& c)
       : container(etl::addressof(c))
@@ -718,15 +685,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// This kind of %iterator doesn't really have a @a position in the
-    /// container (you can think of the position as being permanently at
-    /// the front, if you like).  Assigning a value to the %iterator will
-    /// always prepend the value to the front of the container.
-    ///
-    /// @param  value  An instance of whatever type
-    ///                container_type::const_reference is; presumably a
-    ///                reference-to-const T for container<T>.
-    /// @return  This %iterator, for chained operations.
+    /// Assignment operator
     //***************************************************************************
     ETL_CONSTEXPR14 front_insert_iterator& operator =(const typename TContainer::value_type& value)
     {
@@ -747,7 +706,6 @@ namespace etl
 
     //***************************************************************************
     /// Dereference operator.
-    /// Simply returns *this.
     //***************************************************************************
     ETL_NODISCARD ETL_CONSTEXPR14 front_insert_iterator& operator *()
     {
@@ -756,7 +714,6 @@ namespace etl
 
     //***************************************************************************
     /// Pre-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 front_insert_iterator& operator ++()
     {
@@ -765,7 +722,6 @@ namespace etl
 
     //***************************************************************************
     /// Post-increment operator.
-    /// Simply returns *this.  (This %iterator does not @a move.)
     //***************************************************************************
     ETL_CONSTEXPR14 front_insert_iterator operator ++(int)
     {
@@ -778,16 +734,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// This wrapper function helps in creating front_insert_iterator instances.
-  /// Typing the name of the %iterator requires knowing the precise full
-  /// type of the container, which can be tedious and impedes generic
-  /// programming.  Using this function lets you take advantage of automatic
-  /// template parameter deduction, making the compiler match the correct
-  /// types for you.
-  ///
-  ///\tparam TContainer The container type.
-  ///\param container A container of arbitrary type.
-  ///\return An instance of front_insert_iterator working on @p x.
+  /// Creates a front_insert_iterator from a container.
   //***************************************************************************
   template <typename TContainer>
   ETL_NODISCARD
@@ -797,6 +744,90 @@ namespace etl
     return etl::front_insert_iterator<TContainer>(container);
   }
 
+  //***************************************************************************
+  // push_insert_iterator
+  //***************************************************************************
+
+  //***************************************************************************
+  /// Turns assignment into a push.
+  //***************************************************************************
+  template <typename TContainer>
+  class push_insert_iterator : public etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
+  {
+  public:
+
+    typedef TContainer container_type;
+
+    //***************************************************************************
+    /// Constructor
+    //***************************************************************************
+    explicit ETL_CONSTEXPR14 push_insert_iterator(TContainer& c)
+      : container(etl::addressof(c))
+    {
+    }
+
+    //***************************************************************************
+    /// Assignment operator
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator& operator =(const typename TContainer::value_type& value)
+    {
+      container->push(value);
+
+      return (*this);
+    }
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Move assignment operator.
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator& operator =(typename TContainer::value_type&& value)
+    {
+      container->push(etl::move(value));
+
+      return (*this);
+    }
+#endif  // ETL_USING_CPP11
+
+    //***************************************************************************
+    /// Dereference operator.
+    //***************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 push_insert_iterator& operator *()
+    {
+      return (*this);
+    }
+
+    //***************************************************************************
+    /// Pre-increment operator.
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator& operator ++()
+    {
+      return (*this);
+    }
+
+    //***************************************************************************
+    /// Post-increment operator.
+    //***************************************************************************
+    ETL_CONSTEXPR14 push_insert_iterator operator ++(int)
+    {
+      return (*this);
+    }
+
+  protected:
+
+    TContainer* container;
+  };
+
+  //***************************************************************************
+  /// Creates a push_insert_iterator from a container.
+  //***************************************************************************
+  template <typename TContainer>
+  ETL_NODISCARD
+    ETL_CONSTEXPR14
+    etl::push_insert_iterator<TContainer> push_inserter(TContainer& container)
+  {
+    return etl::push_insert_iterator<TContainer>(container);
+  }
+
   //***************************************************************************
   // Helper templates.
   //***************************************************************************
diff --git a/src/etl/lcm.h b/src/etl/lcm.h
new file mode 100644
index 0000000..43bb002
--- /dev/null
+++ b/src/etl/lcm.h
@@ -0,0 +1,141 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2024 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+#ifndef ETL_LCM_INCLUDED
+#define ETL_LCM_INCLUDED
+
+#include "type_traits.h"
+#include "absolute.h"
+#include "static_assert.h"
+#include "gcd.h"
+
+namespace etl
+{
+  //***************************************************************************
+  // Least Common Multiple.
+  // For unsigned types.
+  //***************************************************************************
+  template <typename T>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
+    lcm(T a, T b) ETL_NOEXCEPT
+  {
+    ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Integral type required");
+
+    // Early termination: if either number is zero, the LCM is zero.
+    if (a == 0 || b == 0)
+    {
+      return 0;
+    }
+    else
+    {
+      return a * (b / gcd(a, b));
+    }
+  }
+
+  //***************************************************************************
+  // Least Common Multiple.
+  // For signed types.
+  //***************************************************************************
+  template <typename T>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  typename etl::enable_if<etl::is_signed<T>::value, T>::type
+    lcm(T a, T b) ETL_NOEXCEPT
+  {
+    ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Integral type required");
+
+    typedef typename etl::make_unsigned<T>::type utype;
+
+    utype ua = etl::absolute_unsigned(a);
+    utype ub = etl::absolute_unsigned(b);
+
+    return static_cast<T>(lcm(ua, ub));
+  }
+
+#if ETL_USING_CPP11
+  #if ETL_HAS_INITIALIZER_LIST
+  //***************************************************************************
+  // Least Common Multiple.
+  // Non-recursive, using an initializer_list.
+  // Top level variadic function.
+  //***************************************************************************
+  template<typename T, typename... TRest>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  T lcm(T first, TRest... rest) ETL_NOEXCEPT
+  {
+    T result = first;
+
+    for (T value : {rest...})
+    {
+      result = lcm(result, value);
+
+      if (result == 0)
+      {
+        // Early termination: if the LCM is zero, it will remain zero
+        // no matter what other numbers are processed.
+        return 0;
+      }
+    }
+
+    return result;
+  }
+  #else
+  //***************************************************************************
+  // Least Common Multiple.
+  // Recursive
+  // Top level variadic function.
+  //***************************************************************************
+  template<typename T, typename... TRest>
+  ETL_NODISCARD
+  ETL_CONSTEXPR14
+  T lcm(T a, T b, TRest... rest) ETL_NOEXCEPT
+  {
+    T lcm_ab = lcm(a, b);
+
+    if (lcm_ab == 0)
+    {
+      // Early termination: if the LCM is zero, it will remain zero
+      // no matter what other numbers are processed.
+      return 0;
+    }
+    else
+    {
+      return lcm(lcm_ab, rest...);
+    }
+  }
+  #endif
+#endif
+}
+
+#endif
+
diff --git a/src/etl/limits.h b/src/etl/limits.h
index d64f6c5..ac31ca6 100644
--- a/src/etl/limits.h
+++ b/src/etl/limits.h
@@ -80,19 +80,19 @@ SOFTWARE.
 
 #if defined(ETL_NO_CPP_NAN_SUPPORT)
   #if defined(NAN)
-  #include "etl/private/diagnostic_useless_cast_push.h"
+  #include "private/diagnostic_useless_cast_push.h"
     #define ETL_NANF    NAN
     #define ETL_NAN     static_cast<double>(NAN)
     #define ETL_NANL    static_cast<long double>(NAN)
     #define ETL_HAS_NAN true
-  #include "etl/private/diagnostic_pop.h"
+  #include "private/diagnostic_pop.h"
   #else
-  #include "etl/private/diagnostic_useless_cast_push.h"
+  #include "private/diagnostic_useless_cast_push.h"
     #define ETL_NANF HUGE_VALF    
     #define ETL_NAN  HUGE_VAL
     #define ETL_NANL HUGE_VALL
     #define ETL_HAS_NAN false
-  #include "etl/private/diagnostic_pop.h"
+  #include "private/diagnostic_pop.h"
   #endif
 #else
   #define ETL_NANF    nanf("")
diff --git a/src/etl/list.h b/src/etl/list.h
index 07e5169..eefedf8 100644
--- a/src/etl/list.h
+++ b/src/etl/list.h
@@ -43,7 +43,6 @@ SOFTWARE.
 #include "type_traits.h"
 #include "algorithm.h"
 #include "memory.h"
-#include "iterator.h"
 #include "static_assert.h"
 #include "parameter_type.h"
 #include "placement_new.h"
diff --git a/src/etl/map.h b/src/etl/map.h
index ce81317..88449df 100644
--- a/src/etl/map.h
+++ b/src/etl/map.h
@@ -1496,10 +1496,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
     //*************************************************************************
@@ -1507,12 +1507,12 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node_with_key(const_key_reference key)
     {
-      Data_Node& node = allocate_data_node();
+      Data_Node* node = allocate_data_node();
 
-      ::new ((void*)etl::addressof(node.value.first))  key_type(key);
-      ::new ((void*)etl::addressof(node.value.second)) mapped_type();
+      ::new ((void*)etl::addressof(node->value.first))  key_type(key);
+      ::new ((void*)etl::addressof(node->value.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1521,10 +1521,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
     //*************************************************************************
@@ -1532,12 +1532,12 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node_with_key(rvalue_key_reference key)
     {
-      Data_Node& node = allocate_data_node();
+      Data_Node* node = allocate_data_node();
 
-      ::new ((void*)etl::addressof(node.value.first))  key_type(etl::move(key));
-      ::new ((void*)etl::addressof(node.value.second)) mapped_type();
+      ::new ((void*)etl::addressof(node->value.first))  key_type(etl::move(key));
+      ::new ((void*)etl::addressof(node->value.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #endif
@@ -1545,10 +1545,10 @@ namespace etl
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/src/etl/memory.h b/src/etl/memory.h
index c4eb8fa..1abcf63 100644
--- a/src/etl/memory.h
+++ b/src/etl/memory.h
@@ -1424,7 +1424,10 @@ namespace etl
     //*********************************
     unique_ptr&	operator =(std::nullptr_t) ETL_NOEXCEPT
     {
-      reset(nullptr);
+      if (p)
+      {
+        reset(nullptr);
+      }
 
       return *this;
     }
@@ -1432,7 +1435,10 @@ namespace etl
     //*********************************
     unique_ptr&	operator =(void*) ETL_NOEXCEPT
     {
-      reset(NULL);
+      if (p)
+      {
+        reset(NULL);
+      }
 
       return *this;
     }
diff --git a/src/etl/message.h b/src/etl/message.h
index 22a802e..9c664ab 100644
--- a/src/etl/message.h
+++ b/src/etl/message.h
@@ -62,6 +62,8 @@ namespace etl
     }
   };
 
+  class message_tag {};
+
 #if ETL_HAS_VIRTUAL_MESSAGES
   //***************************************************************************
   /// Message interface.
@@ -85,10 +87,14 @@ namespace etl
   /// Virtual.
   //***************************************************************************
   template <etl::message_id_t ID_, typename TBase = etl::imessage>
-  class message : public TBase
+  class message : public TBase, public etl::message_tag
   {
   public:
 
+    ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TBase>::value), "TBase is not derived from etl::imessage");
+
+    typedef TBase base_type;
+
     //***********************************
     ETL_NODISCARD virtual etl::message_id_t get_message_id() const ETL_NOEXCEPT ETL_OVERRIDE
     {
@@ -149,12 +155,14 @@ namespace etl
   /// Non-virtual.
   //***************************************************************************
   template <etl::message_id_t ID_, typename TBase = etl::imessage>
-  class message : public TBase
+  class message : public TBase, public etl::message_tag
   {
   public:
 
     ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TBase>::value), "TBase is not derived from etl::imessage");
 
+    typedef TBase base_type;
+
     //***********************************
     message() ETL_NOEXCEPT
       : TBase(ID)
@@ -183,6 +191,78 @@ namespace etl
   //***************************************************************************
   template <etl::message_id_t ID_, typename TBase>
   ETL_CONSTANT etl::message_id_t etl::message<ID_, TBase>::ID;
+
+  //***************************************************************************
+  /// Is T an etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  struct is_imessage : public etl::bool_constant<etl::is_same<etl::imessage, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  struct is_message : public etl::bool_constant<etl::is_base_of<etl::imessage, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T an etl::message<> or derived from etl::message<>
+  //***************************************************************************
+  template <typename T>
+  struct is_message_type : public etl::bool_constant<etl::is_base_of<etl::message_tag, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T a base of etl::message<T>
+  //***************************************************************************
+  template <typename T>
+  struct is_message_base : public etl::bool_constant<etl::is_message<T>::value && !etl::is_message_type<T>::value>
+  {
+  };
+
+  //***************************************************************************
+  /// Is T a user defined base of etl::message<T> and not an etl::imessage
+  //***************************************************************************
+  template <typename T>
+  struct is_user_message_base : public etl::bool_constant<etl::is_message_base<T>::value && !etl::is_imessage<T>::value>
+  {
+  };
+
+#if ETL_USING_CPP17
+  //***************************************************************************
+  /// Is T an etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_imessage_v = is_imessage<T>::value;
+
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage?
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_message_v = is_message<T>::value;
+
+  //***************************************************************************
+  /// Is T derived from etl::message<>
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_message_type_v = is_message_type<T>::value;
+
+  //***************************************************************************
+  /// Is T a base of etl::message<T>
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_message_base_v = is_message_base<T>::value;
+
+  //***************************************************************************
+  /// Is T a user defined base of etl::message<T>
+  //***************************************************************************
+  template <typename T>
+  inline constexpr bool is_user_message_base_v = is_user_message_base<T>::value;
+#endif
 }
 
 #endif
diff --git a/src/etl/message_broker.h b/src/etl/message_broker.h
index ad99cb3..a8ce0ab 100644
--- a/src/etl/message_broker.h
+++ b/src/etl/message_broker.h
@@ -228,9 +228,7 @@ namespace etl
       // Always pass the message on to the successor.
       if (has_successor())
       {
-        etl::imessage_router& successor = get_successor();
-
-        successor.receive(destination_router_id, msg);
+        get_successor().receive(destination_router_id, msg);
       }
     }
 
@@ -276,11 +274,48 @@ namespace etl
     using imessage_router::accepts;
 
     //*******************************************
-    /// Message brokers accept all messages.
+    /// Message brokers accept messages determined
+    /// by the subscribed routers.
     //*******************************************
-    virtual bool accepts(etl::message_id_t) const ETL_OVERRIDE
+    virtual bool accepts(etl::message_id_t id) const ETL_OVERRIDE
     {
-      return true;
+      if (!empty())
+      {
+        // Scan the subscription lists.
+        subscription* sub = static_cast<subscription*>(head.get_next());
+
+        while (sub != ETL_NULLPTR)
+        {
+          message_id_span_t message_ids = sub->message_id_list();
+
+          message_id_span_t::iterator itr = etl::find(message_ids.begin(), message_ids.end(), id);
+
+          if (itr != message_ids.end())
+          {
+            etl::imessage_router* router = sub->get_router();
+
+            if (router->accepts(id))
+            {
+              return true;
+            }
+          }
+
+          sub = sub->next_subscription();
+        }
+      }
+
+      // Check any successor.
+      if (has_successor())
+      {
+        if (get_successor().accepts(id))
+        {
+          return true;
+        }
+      }
+
+      return false;
+
+      //return true;
     }
 
     //*******************************************
diff --git a/src/etl/message_bus.h b/src/etl/message_bus.h
index 3ab24db..1d698e7 100644
--- a/src/etl/message_bus.h
+++ b/src/etl/message_bus.h
@@ -227,11 +227,9 @@ namespace etl
 
       if (has_successor())
       {
-        etl::imessage_router& successor = get_successor();
-
-        if (successor.accepts(message.get_message_id()))
+        if (get_successor().accepts(message.get_message_id()))
         {
-          successor.receive(destination_router_id, message);
+          get_successor().receive(destination_router_id, message);
         }
       }
     }
@@ -306,11 +304,9 @@ namespace etl
 
       if (has_successor())
       {
-        etl::imessage_router& successor = get_successor();
-
-        if (successor.accepts(shared_msg.get_message().get_message_id()))
+        if (get_successor().accepts(shared_msg.get_message().get_message_id()))
         {
-          successor.receive(destination_router_id, shared_msg);
+          get_successor().receive(destination_router_id, shared_msg);
         }
       }
     }
@@ -319,11 +315,35 @@ namespace etl
 
     //*******************************************
     /// Does this message bus accept the message id?
-    /// Yes!, it accepts everything!
+    /// Returns <b>true</b> on the first router that does.
     //*******************************************
-    bool accepts(etl::message_id_t) const ETL_OVERRIDE
+    bool accepts(etl::message_id_t id) const ETL_OVERRIDE
     {
-      return true;
+      // Check the list of subscribed routers.
+      router_list_t::iterator irouter = router_list.begin();
+
+      while (irouter != router_list.end())
+      {
+        etl::imessage_router& router = **irouter;
+
+        if (router.accepts(id))
+        {
+          return true;
+        }
+
+        ++irouter;
+      }
+
+      // Check any successor.
+      if (has_successor())
+      {
+        if (get_successor().accepts(id))
+        {
+          return true;
+        }
+      }
+
+      return false;
     }
 
     //*******************************************
@@ -370,9 +390,9 @@ namespace etl
     //*******************************************
     /// Constructor.
     //*******************************************
-    imessage_bus(router_list_t& list, etl::imessage_router& successor)
-      : imessage_router(etl::imessage_router::MESSAGE_BUS, successor),
-      router_list(list)
+    imessage_bus(router_list_t& router_list_, etl::imessage_router& successor_)
+      : imessage_router(etl::imessage_router::MESSAGE_BUS, successor_),
+      router_list(router_list_)
     {
     }
 
@@ -416,8 +436,8 @@ namespace etl
     //*******************************************
     /// Constructor.
     //*******************************************
-    message_bus(etl::imessage_router& successor)
-      : imessage_bus(router_list, successor)
+    message_bus(etl::imessage_router& successor_)
+      : imessage_bus(router_list, successor_)
     {
     }
 
diff --git a/src/etl/message_packet.h b/src/etl/message_packet.h
index df4d6d2..35650a6 100644
--- a/src/etl/message_packet.h
+++ b/src/etl/message_packet.h
@@ -99,7 +99,7 @@ namespace etl
     ///
     //********************************************
 #include "private/diagnostic_uninitialized_push.h"
-    template <typename T>
+    template <typename T, typename = typename etl::enable_if<IsIMessage<T> || IsInMessageList<T>, int>::type>
     explicit message_packet(T&& msg)
       : valid(true)
     {
@@ -121,10 +121,6 @@ namespace etl
       {
         add_new_message_type<T>(etl::forward<T>(msg));
       }
-      else if constexpr (IsMessagePacket<T>)
-      {
-        copy(etl::forward<T>(msg));
-      }
       else
       {
         ETL_STATIC_ASSERT(IsInMessageList<T>, "Message not in packet type list");
@@ -132,6 +128,30 @@ namespace etl
     }
 #include "private/diagnostic_pop.h"
 
+    //**********************************************
+    message_packet(const message_packet& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(other.get());
+      }
+    }
+
+#if ETL_USING_CPP11
+    //**********************************************
+    message_packet(message_packet&& other)
+    {
+      valid = other.is_valid();
+
+      if (valid)
+      {
+        add_new_message(etl::move(other.get()));
+      }
+    }
+#endif
+
     //**********************************************
     void copy(const message_packet& other)
     {
diff --git a/src/etl/message_router.h b/src/etl/message_router.h
index b7807a7..3f846ef 100644
--- a/src/etl/message_router.h
+++ b/src/etl/message_router.h
@@ -39,7 +39,7 @@ SOFTWARE.
 // Note: You will need Python and COG installed.
 //
 // python -m cogapp -d -e -omessage_router.h -DHandlers=<n> message_router_generator.h
-// Where <n> is the number of messages to support.
+// Where <n> is the maximum number of messages to support.
 //
 // e.g.
 // To generate handlers for up to 16 messages...
@@ -200,8 +200,8 @@ namespace etl
     }
 
     //********************************************
-    null_message_router(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    null_message_router(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
     
@@ -278,8 +278,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::imessage_router& successor)
-      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor)
+    message_producer(etl::imessage_router& successor_)
+      : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
     {
     }
 
@@ -291,8 +291,8 @@ namespace etl
     }
 
     //********************************************
-    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor)
-      : imessage_router(id_, successor)
+    message_producer(etl::message_router_id_t id_, etl::imessage_router& successor_)
+      : imessage_router(id_, successor_)
     {
       ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
     }
@@ -342,11 +342,22 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Is T ultimately derived from etl::imessage_router?
+  //***************************************************************************
+  template <typename T>
+  struct is_message_router : public etl::bool_constant<etl::is_base_of<etl::imessage_router, typename etl::remove_cvref<T>::type>::value>
+  {
+  };
+
   //***************************************************************************
   /// Send a message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  const etl::imessage&  message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&        destination,
+                 const TMessage& message)
   {
     destination.receive(message);
   }
@@ -354,8 +365,11 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&            destination,
+                 etl::shared_message message)
   {
     destination.receive(message);
   }
@@ -363,9 +377,12 @@ namespace etl
   //***************************************************************************
   /// Send a message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  const etl::imessage& message)
+  template <typename TRouter, typename TMessage>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 const TMessage&          message)
   {
     destination.receive(id, message);
   }
@@ -373,9 +390,12 @@ namespace etl
   //***************************************************************************
   /// Send a shared message to a router with a particular id.
   //***************************************************************************
-  static inline void send_message(etl::imessage_router& destination,
-                                  etl::message_router_id_t id,
-                                  etl::shared_message message)
+  template <typename TRouter>
+  static
+  typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
+    send_message(TRouter&                 destination,
+                 etl::message_router_id_t id,
+                 etl::shared_message      message)
   {
     destination.receive(id, message);
   }
diff --git a/src/etl/message_timer.h b/src/etl/message_timer.h
index 075b03a..f272877 100644
--- a/src/etl/message_timer.h
+++ b/src/etl/message_timer.h
@@ -589,13 +589,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      ETL_DISABLE_TIMER_UPDATES;
+      bool result = !active_list.empty();
+      ETL_ENABLE_TIMER_UPDATES;
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       ETL_DISABLE_TIMER_UPDATES;
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {        
+        delta = active_list.front().delta;
+      }
       ETL_ENABLE_TIMER_UPDATES;
 
       return delta;
diff --git a/src/etl/message_timer_atomic.h b/src/etl/message_timer_atomic.h
index 97fb318..2710ea2 100644
--- a/src/etl/message_timer_atomic.h
+++ b/src/etl/message_timer_atomic.h
@@ -302,13 +302,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      ++process_semaphore;
+      bool result = !active_list.empty();
+      --process_semaphore;
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       ++process_semaphore;
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
       --process_semaphore;
 
       return delta;
diff --git a/src/etl/message_timer_interrupt.h b/src/etl/message_timer_interrupt.h
index c906d8e..6f26789 100644
--- a/src/etl/message_timer_interrupt.h
+++ b/src/etl/message_timer_interrupt.h
@@ -311,15 +311,31 @@ namespace etl
       return false;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      TInterruptGuard guard;
+      (void)guard; // Silence 'unused variable warnings.
+      return !active_list.empty();
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
+
       TInterruptGuard guard;
       (void)guard; // Silence 'unused variable warnings.
 
-      uint32_t delta = active_list.front().delta;
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
 
       return delta;
     }
diff --git a/src/etl/message_timer_locked.h b/src/etl/message_timer_locked.h
index cd44702..5639dc2 100644
--- a/src/etl/message_timer_locked.h
+++ b/src/etl/message_timer_locked.h
@@ -318,14 +318,32 @@ namespace etl
       unlock   = unlock_;
     }
 
+    //*******************************************
+    /// Check if there is an active timer.
+    //*******************************************
+    bool has_active_timer() const
+    {
+      lock();
+      bool result = !active_list.empty();
+      unlock();
+
+      return result;
+    }
+
     //*******************************************
     /// Get the time to the next timer event.
+    /// Returns etl::timer::interval::No_Active_Interval if there is no active timer.
     //*******************************************
     uint32_t time_to_next() const
     {
-      lock();
+      uint32_t delta = static_cast<uint32_t>(etl::timer::interval::No_Active_Interval);
 
-      uint32_t delta = active_list.front().delta;
+      lock();
+      if (!active_list.empty())
+      {
+        delta = active_list.front().delta;
+      }
+      unlock();
 
       return delta;
     }
diff --git a/src/etl/multi_range.h b/src/etl/multi_range.h
index 44c0211..e8297ca 100644
--- a/src/etl/multi_range.h
+++ b/src/etl/multi_range.h
@@ -324,7 +324,7 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const = 0;
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const = 0;
     };
 
     //***************************************************************************
@@ -334,9 +334,9 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const ETL_OVERRIDE
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const ETL_OVERRIDE
       {
-        return etl::not_equal_to<value_type>()(current, last);
+        return etl::not_equal_to<value_type>()(lhs, rhs);
       }
     };
 
@@ -347,9 +347,9 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const ETL_OVERRIDE
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const ETL_OVERRIDE
       {
-        return etl::less<value_type>()(current, last);
+        return etl::less<value_type>()(lhs, rhs);
       }
     };
 
@@ -360,9 +360,9 @@ namespace etl
     {
       typedef T value_type;
 
-      virtual bool operator()(const value_type& current, const value_type& last) const ETL_OVERRIDE
+      virtual bool operator()(const value_type& lhs, const value_type& rhs) const ETL_OVERRIDE
       {
-        return etl::greater<value_type>()(current, last);
+        return etl::greater<value_type>()(lhs, rhs);
       }
     };
 
diff --git a/src/etl/multimap.h b/src/etl/multimap.h
index a6411cc..6d9dfa6 100644
--- a/src/etl/multimap.h
+++ b/src/etl/multimap.h
@@ -1542,10 +1542,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) const value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) const value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1554,20 +1554,20 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new (&node.value) const value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new (&node->value) const value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 #endif
 
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/src/etl/multiset.h b/src/etl/multiset.h
index d2c35f6..596c31d 100644
--- a/src/etl/multiset.h
+++ b/src/etl/multiset.h
@@ -1530,10 +1530,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1542,20 +1542,20 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 #endif
 
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/src/etl/optional.h b/src/etl/optional.h
index 6431efb..002d010 100644
--- a/src/etl/optional.h
+++ b/src/etl/optional.h
@@ -98,1022 +98,1460 @@ namespace etl
   };
 
   //*****************************************************************************
-  /// An optional type.
-  /// If the optional type is not initialised then a type is not constructed.
-  /// See http://en.cppreference.com/w/cpp/utility/optional
-  ///\tparam T The type to store.
-  ///\ingroup utilities
+  // Implementations for fundamental and non fundamental types.
   //*****************************************************************************
-  template <typename T, bool is_pod = etl::is_pod<T>::value>
-  class optional;
-
-  //*****************************************************************************
-  /// For non POD types.
-  //*****************************************************************************
-  template <typename T>
-  class optional<T, false>
+  namespace private_optional
   {
-  public:
+    template <typename T, bool IsDefaultConstructible = etl::is_integral<T>::value>
+    class optional_impl;
 
-    typedef T value_type;
-
-    //***************************************************************************
-    /// Constructor.
-    //***************************************************************************
-    ETL_CONSTEXPR
-    optional()
-      : storage()
+    //*****************************************************************************
+    // Implementation for non fundamental types.
+    //*****************************************************************************
+    template <typename T>
+    class optional_impl<T, false>
     {
-    }
+    protected:
 
-    //***************************************************************************
-    /// Constructor with nullopt.
-    //***************************************************************************
-    ETL_CONSTEXPR
-    optional(etl::nullopt_t)
-      : storage()
-    {
-    }
+      typedef T value_type;
+
+      //***************************************************************************
+      /// Constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl()
+        : storage()
+      {
+      }
+
+      //***************************************************************************
+      /// Constructor with nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(etl::nullopt_t)
+        : storage()
+      {
+      }
 
 #include "private/diagnostic_uninitialized_push.h"
-    //***************************************************************************
-    /// Copy constructor.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional(const optional& other)
-    {
-      if (other.has_value())
+      //***************************************************************************
+      /// Copy constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(const optional_impl<T>& other)
       {
-        storage.construct(other.value());
+        if (other.has_value())
+        {
+          storage.construct(other.value());
+        }
       }
-    }
 #include "private/diagnostic_pop.h"
 
 #if ETL_USING_CPP11
-    //***************************************************************************
-    /// Move constructor.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional(optional&& other)
-    {
-      if (other.has_value())
+      //***************************************************************************
+      /// Move constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(optional_impl<T>&& other)
       {
-        storage.construct(etl::move(other.value()));
+        if (other.has_value())
+        {
+          storage.construct(etl::move(other.value()));
+        }
       }
-    }
 #endif
 
-    //***************************************************************************
-    /// Constructor from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional(const T& value_)
-    {
-      storage.construct(value_);
-    }
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(const T& value_)
+      {
+        storage.construct(value_);
+      }
 
 #if ETL_USING_CPP11
-    //***************************************************************************
-    /// Constructor from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional(T&& value_)
-    {
-      storage.construct(etl::move(value_));
-    }
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl(T&& value_)
+      {
+        storage.construct(etl::move(value_));
+      }
+#endif
+
+      //***************************************************************************
+      /// Destructor.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      ~optional_impl()
+      {
+        storage.destroy();
+      }
+
+      //***************************************************************************
+      /// Assignment operator from nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(etl::nullopt_t)
+      {
+        if (has_value())
+        {
+          storage.destroy();
+        }
+
+        return *this;
+      }
+
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(const optional_impl<T>& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(other.value());
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(optional_impl&& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(etl::move(other.value()));
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
+      }
+#endif
+
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(const T& value_)
+      {
+        storage.construct(value_);
+
+        return *this;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      optional_impl& operator =(T&& value_)
+      {
+        storage.construct(etl::move(value_));
+
+        return *this;
+      }
+#endif
+
+  public:
+
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T* operator ->()
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return &storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T* operator ->() const
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return &storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T& operator *() ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T& operator *() const ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T&& operator *()&&
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.u.value);
+      }
+
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T&& operator *() const&&
+      {
+#if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.u.value);
+      }
+#endif
+
+      //***************************************************************************
+      // Check whether optional contains value
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      bool has_value() const ETL_NOEXCEPT
+      {
+        return storage.valid;
+      }
+
+      //***************************************************************************
+      /// Bool conversion operator.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      ETL_EXPLICIT operator bool() const
+      {
+        return has_value();
+      }
+
+      //***************************************************************************
+      /// Get a reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T& value() ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Get a const reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T& value() const ETL_LVALUE_REF_QUALIFIER
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return storage.u.value;
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
+      {
+        return has_value() ? value() : default_value;
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Get an rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      T&& value()&&
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-    //***************************************************************************
-    /// Destructor.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    ~optional()
+        return etl::move(storage.u.value);
+      }
+
+      //***************************************************************************
+      /// Get a const rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      const T&& value() const&&
+      {
+#if ETL_IS_DEBUG_BUILD
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+#endif
+
+        return etl::move(storage.u.value);
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR20_STL
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value) const&
+      {
+        return has_value() ? value() : etl::forward<T>(default_value);
+      }
+
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR20_STL
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value)&&
+      {
+        return has_value() ? etl::move(value()) : etl::forward<T>(default_value);
+      }
+#endif
+
+      //***************************************************************************
+      /// Swaps this value with another.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      void swap(optional_impl& other)
+      {
+        optional_impl temp(*this);
+        *this = other;
+        other = temp;
+      }
+
+      //***************************************************************************
+      /// Reset back to invalid.
+      //***************************************************************************
+      ETL_CONSTEXPR20_STL
+      void reset()
+      {
+        storage.destroy();
+      }
+
+#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
+      //*************************************************************************
+      /// Emplaces a value.
+      ///\param args The arguments to construct with.
+      //*************************************************************************
+      template <typename... TArgs>
+      ETL_CONSTEXPR20_STL
+      void emplace(TArgs&& ... args)
+      {
+        storage.construct(etl::forward<TArgs>(args)...);
+      }
+#else
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      T& emplace()
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T();
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      template <typename T1>
+      T& emplace(const T1& value1)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 2 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2>
+      T& emplace(const T1& value1, const T2& value2)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1, value2);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 3 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1, value2, value3);
+        storage.valid = true;
+
+        return *p;
+      }
+
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 4 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3, typename T4>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.u.value) T(value1, value2, value3, value4);
+        storage.valid = true;
+
+        return *p;
+      }
+#endif
+
+    private:
+
+      struct dummy_t {};
+
+      //*************************************
+      // The storage for the optional value.
+      //*************************************
+      struct storage_type
+      {
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        storage_type()
+          : u()
+          , valid(false)
+        {
+        }
+
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        void construct(const T& value_)
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+          }
+
+          etl::construct_at(&u.value, value_);
+          valid = true;
+        }
+
+#if ETL_USING_CPP11
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        void construct(T&& value_)
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+          }
+
+          etl::construct_at(&u.value, etl::move(value_));
+          valid = true;
+        }
+
+        //*******************************
+        template <typename... TArgs>
+        ETL_CONSTEXPR20_STL
+        void construct(TArgs&&... args)
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+          }
+
+          etl::construct_at(&u.value, etl::forward<TArgs>(args)...);
+          valid = true;
+        }
+#endif
+
+        //*******************************
+        ETL_CONSTEXPR20_STL
+        void destroy()
+        {
+          if (valid)
+          {
+            etl::destroy_at(&u.value);
+            valid = false;
+          }
+        }
+
+        //*******************************
+        union union_type
+        {
+          ETL_CONSTEXPR20_STL
+          union_type()
+            : dummy()
+          {
+          }
+
+          ETL_CONSTEXPR20_STL
+          ~union_type()
+          {
+          }
+
+          dummy_t dummy;
+          T       value;
+        } u;
+
+        bool valid;
+      };
+
+      storage_type storage;
+    };
+
+    //*****************************************************************************
+    // Implementation for fundamental types.
+    //*****************************************************************************
+    template <typename T>
+    class optional_impl<T, true>
     {
-      storage.destroy();
-    }
+    protected:
 
-    //***************************************************************************
-    /// Assignment operator from nullopt.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(etl::nullopt_t)
-    {
-      if (has_value())
+      typedef T value_type;
+
+      //***************************************************************************
+      /// Constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl()
+        : storage()
       {
-        storage.destroy();
       }
 
-      return *this;
-    }
+      //***************************************************************************
+      /// Constructor with nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(etl::nullopt_t)
+        : storage()
+      {
+      }
 
-    //***************************************************************************
-    /// Assignment operator from optional.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(const optional& other)
-    {
-      if (this != &other)
+#include "private/diagnostic_uninitialized_push.h"
+      //***************************************************************************
+      /// Copy constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(const optional_impl<T>& other)
       {
         if (other.has_value())
         {
           storage.construct(other.value());
         }
-        else
-        {
-          storage.destroy();
-        }
       }
-
-      return *this;
-    }
+#include "private/diagnostic_pop.h"
 
 #if ETL_USING_CPP11
-    //***************************************************************************
-    /// Assignment operator from optional.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(optional&& other)
-    {
-      if (this != &other)
+      //***************************************************************************
+      /// Move constructor.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(optional_impl&& other)
       {
         if (other.has_value())
         {
           storage.construct(etl::move(other.value()));
         }
-        else
+      }
+#endif
+
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(const T& value_)
+      {
+        storage.construct(value_);
+      }
+
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Constructor from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl(T&& value_)
+      {
+        storage.construct(etl::move(value_));
+      }
+#endif
+
+      //***************************************************************************
+      /// Assignment operator from nullopt.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(etl::nullopt_t)
+      {
+        if (has_value())
         {
           storage.destroy();
         }
+
+        return *this;
+      }
+
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(const optional_impl<T>& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(other.value());
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
       }
 
-      return *this;
-    }
+#if ETL_USING_CPP11
+      //***************************************************************************
+      /// Assignment operator from optional_impl.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(optional_impl&& other)
+      {
+        if (this != &other)
+        {
+          if (other.has_value())
+          {
+            storage.construct(etl::move(other.value()));
+          }
+          else
+          {
+            storage.destroy();
+          }
+        }
+
+        return *this;
+      }
 #endif
 
-    //***************************************************************************
-    /// Assignment operator from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(const T& value_)
-    {
-      storage.construct(value_);
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(const T& value_)
+      {
+        storage.construct(value_);
 
-      return *this;
-    }
+        return *this;
+      }
 
 #if ETL_USING_CPP11
-    //***************************************************************************
-    /// Assignment operator from value type.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    optional& operator =(T&& value_)
-    {
-      storage.construct(etl::move(value_));
+      //***************************************************************************
+      /// Assignment operator from value type.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      optional_impl& operator =(T&& value_)
+      {
+        storage.construct(etl::move(value_));
 
-      return *this;
-    }
+        return *this;
+      }
 #endif
 
-    //***************************************************************************
-    /// Pointer operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T* operator ->()
-    {
+  public:
+
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T* operator ->()
+      {
 #if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return &storage.u.value;
-    }
+        return &storage.value;
+      }
 
-    //***************************************************************************
-    /// Pointer operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T* operator ->() const
-    {
+      //***************************************************************************
+      /// Pointer operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T* operator ->() const
+      {
 #if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return &storage.u.value;
-    }
+        return &storage.value;
+      }
 
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T& operator *() ETL_LVALUE_REF_QUALIFIER
-    {
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T& operator *() ETL_LVALUE_REF_QUALIFIER
+      {
 #if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return storage.u.value;
-    }
+        return storage.value;
+      }
 
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T& operator *() const ETL_LVALUE_REF_QUALIFIER
-    {
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T& operator *() const ETL_LVALUE_REF_QUALIFIER
+      {
 #if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return storage.u.value;
-    }
+        return storage.value;
+      }
 
 #if ETL_USING_CPP11
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T&& operator *()&&
-    {
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T&& operator *()&&
+      {
 #if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return etl::move(storage.u.value);
-    }
+        return etl::move(storage.value);
+      }
 
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T&& operator *() const&&
-    {
+      //***************************************************************************
+      /// Dereference operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T&& operator *() const&&
+      {
 #if ETL_IS_DEBUG_BUILD && !(ETL_USING_CPP20 && ETL_USING_STL)
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return etl::move(storage.u.value);
-    }
+        return etl::move(storage.value);
+      }
 #endif
 
-    //***************************************************************************
-    // Check whether optional contains value
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    bool has_value() const ETL_NOEXCEPT
-    {
-      return storage.valid;
-    }
+      //***************************************************************************
+      // Check whether optional contains value
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      bool has_value() const ETL_NOEXCEPT
+      {
+        return storage.valid;
+      }
 
-    //***************************************************************************
-    /// Bool conversion operator.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    ETL_EXPLICIT operator bool() const
-    {
-      return has_value();
-    }
+      //***************************************************************************
+      /// Bool conversion operator.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      ETL_EXPLICIT operator bool() const
+      {
+        return has_value();
+      }
 
-    //***************************************************************************
-    /// Get a reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T& value() ETL_LVALUE_REF_QUALIFIER
-    {
+      //***************************************************************************
+      /// Get a reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T& value() ETL_LVALUE_REF_QUALIFIER
+      {
 #if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return storage.u.value;
-    }
+        return storage.value;
+      }
 
-    //***************************************************************************
-    /// Get a const reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T& value() const ETL_LVALUE_REF_QUALIFIER
-    {
+      //***************************************************************************
+      /// Get a const reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T& value() const ETL_LVALUE_REF_QUALIFIER
+      {
 #if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return storage.u.value;
-    }
+        return storage.value;
+      }
 
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
-    {
-      return has_value() ? value() : default_value;
-    }
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
+      {
+        return has_value() ? value() : default_value;
+      }
 
 #if ETL_USING_CPP11
-    //***************************************************************************
-    /// Get an rvalue reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    T&& value()&&
-    {
+      //***************************************************************************
+      /// Get an rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      T&& value()&&
+      {
 #if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return etl::move(storage.u.value);
-    }
+        return etl::move(storage.value);
+      }
 
-    //***************************************************************************
-    /// Get a const rvalue reference to the value.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    const T&& value() const&&
-    {
+      //***************************************************************************
+      /// Get a const rvalue reference to the value.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      const T&& value() const&&
+      {
 #if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
+        ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
 #endif
 
-      return etl::move(storage.u.value);
-    }
+        return etl::move(storage.value);
+      }
 
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    template <typename U>
-    ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) const&
-    {
-      return has_value() ? value() : etl::forward<T>(default_value);
-    }
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR14
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value) const&
+      {
+        return has_value() ? value() : etl::forward<T>(default_value);
+      }
 
-    //***************************************************************************
-    /// Gets the value or a default if not valid.
-    //***************************************************************************
-    template <typename U>
-    ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) &&
-    {
-      return has_value() ? etl::move(value()) : etl::forward<T>(default_value);
-    }
+      //***************************************************************************
+      /// Gets the value or a default if not valid.
+      //***************************************************************************
+      template <typename U>
+      ETL_CONSTEXPR14
+      etl::enable_if_t<etl::is_convertible<U, T>::value, T>
+        value_or(U&& default_value)&&
+      {
+        return has_value() ? etl::move(value()) : etl::forward<T>(default_value);
+      }
 #endif
 
-    //***************************************************************************
-    /// Swaps this value with another.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    void swap(optional& other)
-    {
-      optional temp(*this);
-      *this = other;
-      other = temp;
-    }
-
-    //***************************************************************************
-    /// Reset back to invalid.
-    //***************************************************************************
-    ETL_CONSTEXPR20_STL
-    void reset()
-    {
-      storage.destroy();
-    }
-
-#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
-    //*************************************************************************
-    /// Emplaces a value.
-    ///\param args The arguments to construct with.
-    //*************************************************************************
-    template <typename ... TArgs>
-    ETL_CONSTEXPR20_STL
-    void emplace(TArgs&& ... args)
-    {
-      storage.construct(etl::forward<TArgs>(args)...);
-    }
-#else
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 1 parameter.
-    //*************************************************************************
-    T& emplace()
-    {
-      if (has_value())
+      //***************************************************************************
+      /// Swaps this value with another.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      void swap(optional_impl& other)
       {
-        // Destroy the old one.
-        storage.destroy();
+        optional_impl temp(*this);
+        *this = other;
+        other = temp;
       }
 
-      T* p = ::new (&storage.u.value) T();
-      storage.valid = true;
-
-      return *p;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 1 parameter.
-    //*************************************************************************
-    template <typename T1>
-    T& emplace(const T1& value1)
-    {
-      if (has_value())
+      //***************************************************************************
+      /// Reset back to invalid.
+      //***************************************************************************
+      ETL_CONSTEXPR14
+      void reset()
       {
-        // Destroy the old one.
         storage.destroy();
       }
 
-      T* p = ::new (&storage.u.value) T(value1);
-      storage.valid = true;
-
-      return *p;
-    }
-
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 2 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2>
-    T& emplace(const T1& value1, const T2& value2)
-    {
-      if (has_value())
+#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
+      //*************************************************************************
+      /// Emplaces a value.
+      ///\param args The arguments to construct with.
+      //*************************************************************************
+      template <typename... TArgs>
+      ETL_CONSTEXPR14
+      void emplace(TArgs&& ... args)
       {
-        // Destroy the old one.
-        storage.destroy();
+        storage.construct(etl::forward<TArgs>(args)...);
       }
+#else
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      T& emplace()
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
 
-      T* p = ::new (&storage.u.value) T(value1, value2);
-      storage.valid = true;
+        T* p = ::new (&storage.value) T();
+        storage.valid = true;
 
-      return *p;
-    }
+        return *p;
+      }
 
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 3 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3>
-    T& emplace(const T1& value1, const T2& value2, const T3& value3)
-    {
-      if (has_value())
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 1 parameter.
+      //*************************************************************************
+      template <typename T1>
+      T& emplace(const T1& value1)
       {
-        // Destroy the old one.
-        storage.destroy();
-      }
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
 
-      T* p = ::new (&storage.u.value) T(value1, value2, value3);
-      storage.valid = true;
+        T* p = ::new (&storage.value) T(value1);
+        storage.valid = true;
 
-      return *p;
-    }
+        return *p;
+      }
 
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 4 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3, typename T4>
-    T& emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
-    {
-      if (has_value())
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 2 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2>
+      T& emplace(const T1& value1, const T2& value2)
       {
-        // Destroy the old one.
-        storage.destroy();
-      }
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
 
-      T* p = ::new (&storage.u.value) T(value1, value2, value3, value4);
-      storage.valid = true;
+        T* p = ::new (&storage.value) T(value1, value2);
+        storage.valid = true;
 
-      return *p;
-    }
-#endif
+        return *p;
+      }
 
-  private:
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 3 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
 
-    struct dummy_t {};
+        T* p = ::new (&storage.value) T(value1, value2, value3);
+        storage.valid = true;
 
-    struct storage_type
-    {
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      storage_type()
-        : u()
-        , valid(false)
-      {
+        return *p;
       }
 
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      ~storage_type()
-      {
-        destroy();
+      //*************************************************************************
+      /// Emplaces a value.
+      /// 4 parameters.
+      //*************************************************************************
+      template <typename T1, typename T2, typename T3, typename T4>
+      T& emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
+      {
+        if (has_value())
+        {
+          // Destroy the old one.
+          storage.destroy();
+        }
+
+        T* p = ::new (&storage.value) T(value1, value2, value3, value4);
+        storage.valid = true;
+
+        return *p;
       }
+#endif
 
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      void construct(const T& value_)
+    private:
+
+      //*************************************
+      // The storage for the optional value.
+      //*************************************
+      struct storage_type
       {
-        if (valid)
+        //*******************************
+        ETL_CONSTEXPR14
+        storage_type()
+          : value()
+          , valid(false)
         {
-          u.value = value_;
         }
-        else
+
+        //*******************************
+        ETL_CONSTEXPR14
+        void construct(const T& value_)
         {
-          etl::construct_at(&u.value, value_);
-          valid = true;
+          value = value_;
+          valid   = true;
         }
-      }
 
 #if ETL_USING_CPP11
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      void construct(T&& value_)
-      {
-        if (valid)
+        //*******************************
+        ETL_CONSTEXPR14
+        void construct(T&& value_)
         {
-          u.value = etl::move(value_);
+          value = value_;
+          valid = true;
         }
-        else
+
+        //*******************************
+        template <typename... TArgs>
+        ETL_CONSTEXPR14
+        void construct(TArgs&&... args)
         {
-          etl::construct_at(&u.value, etl::move(value_));
+          value = T(etl::forward<TArgs>(args)...);
           valid = true;
         }
-      }
-
-      //*******************************
-      template <typename... TArgs>
-      ETL_CONSTEXPR20_STL
-      void construct(TArgs&&... args)
-      {
-        destroy();
-        etl::construct_at(&u.value, etl::forward<TArgs>(args)...);
-        valid = true;
-      }
 #endif
 
-      //*******************************
-      ETL_CONSTEXPR20_STL
-      void destroy()
-      {
-        if (valid)
+        //*******************************
+        ETL_CONSTEXPR14
+        void destroy()
         {
-          etl::destroy_at(&u.value);
           valid = false;
         }
-      }
-
-      //*******************************
-      union union_type
-      {
-        ETL_CONSTEXPR20_STL
-        union_type()
-          : dummy()
-        {
-        }
-
-        ETL_CONSTEXPR20_STL
-        ~union_type()
-        {
-        }
 
-        dummy_t dummy;
-        T       value;
-      } u;
+        T    value;
+        bool valid;
+      };
 
-      bool valid;
+      storage_type storage;
     };
+  }
 
-    storage_type storage;
-  };
+#define ETL_OPTIONAL_ENABLE_CPP14     typename etl::enable_if< etl::is_pod<U>::value, int>::type = 0
+#define ETL_OPTIONAL_ENABLE_CPP20_STL typename etl::enable_if<!etl::is_pod<U>::value, int>::type = 0
+
+#define ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14     ETL_CONSTEXPR14     typename etl::enable_if< etl::is_pod<T>::value, bool>::type
+#define ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL ETL_CONSTEXPR20_STL typename etl::enable_if<!etl::is_pod<T>::value, bool>::type
 
   //*****************************************************************************
-  /// For arithmetic or pointer types.
+  /// An optional type.
+  /// If the optional type is not initialised then a type is not constructed.
+  /// See http://en.cppreference.com/w/cpp/utility/optional
   ///\tparam T The type to store.
   ///\ingroup utilities
   //*****************************************************************************
   template <typename T>
-  class optional<T, true>
+  class optional : public private_optional::optional_impl<T>
   {
+  private:
+
+    typedef private_optional::optional_impl<T> impl_t;
+    
   public:
 
     typedef T value_type;
 
+#if ETL_USING_CPP11
     //***************************************************************************
     /// Constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional()
-      : valid(false)
-      , storage()
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional()
+      : impl_t()
     {
     }
 
     //***************************************************************************
-    /// Constructor with nullopt.
+    /// Constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional(etl::nullopt_t)
-      : valid(false)
-      , storage()
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional()
+      : impl_t()
     {
     }
-
-    //***************************************************************************
-    /// Copy constructor.
-    //***************************************************************************
-    ETL_CONSTEXPR14 optional(const optional& other)
-      : valid(bool(other))
-      , storage(other.storage)
+#else
+    optional()
+      : impl_t()
     {
     }
+#endif
 
 #if ETL_USING_CPP11
     //***************************************************************************
-    /// Move constructor.
+    /// Constructor with nullopt.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional(optional&& other)
-      : valid(bool(other))
-      , storage(etl::move(other.storage))
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(etl::nullopt_t)
+      : impl_t(etl::nullopt)
     {
     }
-#endif
 
     //***************************************************************************
-    /// Constructor from value type.
+    /// Constructor with nullopt.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional(const T& value_)
-      : valid(true)
-      , storage(value_)
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(etl::nullopt_t)
+      : impl_t(etl::nullopt)
     {
     }
-
-#if ETL_USING_CPP11
+#else
     //***************************************************************************
-    /// Constructor from value type.
+    /// Constructor with nullopt.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional(T&& value_)
-      : valid(true)
-      , storage(etl::move(value_))
+    optional(etl::nullopt_t)
+      : impl_t(etl::nullopt)
     {
     }
 #endif
 
+#include "private/diagnostic_uninitialized_push.h"
+#if ETL_USING_CPP11
     //***************************************************************************
-    /// Assignment operator from nullopt.
+    /// Copy constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(etl::nullopt_t)
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(const optional& other)
+      : impl_t(other)
     {
-      valid = false;
-      return *this;
     }
 
     //***************************************************************************
-    /// Assignment operator from optional.
+    /// Copy constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(const optional& other)
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(const optional& other)
+      : impl_t(other)
     {
-      if (this != &other)
-      {
-        if (other.valid)
-        {
-          storage.value = other.storage.value;
-        }
-        valid = other.valid;
-      }
-
-      return *this;
     }
-
-#if ETL_USING_CPP11
+#else
     //***************************************************************************
-    /// Assignment operator from optional.
+    /// Copy constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(optional&& other)
+    optional(const optional& other)
+      : impl_t(other)
     {
-      if (this != &other)
-      {
-        if (other.valid)
-        {
-          storage.value = etl::move(other.storage.value);
-        }
-        valid = other.valid;
-      }
-
-      return *this;
     }
 #endif
+#include "private/diagnostic_pop.h"
 
+#if ETL_USING_CPP11
     //***************************************************************************
-    /// Assignment operator from value type.
+    /// Move constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(const T& value_)
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(optional&& other)
+      : impl_t(other)
     {
-      storage.value = value_;
-      valid = true;
-
-      return *this;
     }
 
-#if ETL_USING_CPP11
     //***************************************************************************
-    /// Assignment operator from value type.
+    /// Move constructor.
     //***************************************************************************
-    ETL_CONSTEXPR14 optional& operator =(T&& value_)
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(optional&& other)
+      : impl_t(other)
     {
-      storage.value = etl::move(value_);
-      valid = true;
-
-      return *this;
     }
 #endif
 
+#if ETL_USING_CPP11
     //***************************************************************************
-    /// Pointer operator.
+    /// Construct from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 T* operator ->()
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(const T& value_)
+      : impl_t(value_)
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return &storage.value;
     }
 
     //***************************************************************************
-    /// Pointer operator.
+    /// Construct from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 const T* operator ->() const
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(const T& value_)
+      : impl_t(value_)
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return &storage.value;
     }
-
+#else
     //***************************************************************************
-    /// Dereference operator.
+    /// Construct from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 T& operator *() ETL_LVALUE_REF_QUALIFIER
+    optional(const T& value_)
+      : impl_t(value_)
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return storage.value;
     }
-
-    //***************************************************************************
-    /// Dereference operator.
-    //***************************************************************************
-    ETL_CONSTEXPR14 const T& operator *() const ETL_LVALUE_REF_QUALIFIER
-    {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
 #endif
 
-      return storage.value;
-    }
 
 #if ETL_USING_CPP11
     //***************************************************************************
-    /// Dereference operator.
+    /// Move construct from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 T&& operator *()&&
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional(T&& value_)
+      : impl_t(etl::move(value_))
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.value);
     }
 
     //***************************************************************************
-    /// Dereference operator.
+    /// Move construct from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 const T&& operator *() const&&
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional(T&& value_)
+      : impl_t(etl::move(value_))
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
-
-      return etl::move(storage.value);
     }
 #endif
 
+#if ETL_USING_CPP11
     //***************************************************************************
-    /// Bool conversion operator.
+    /// Assignment operator from nullopt.
     //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
     ETL_CONSTEXPR14
-    ETL_EXPLICIT operator bool() const
+    optional& operator =(etl::nullopt_t)
     {
-      return valid;
-    }
+      impl_t::operator=(etl::nullopt);
 
-    //***************************************************************************
-    // Check whether optional contains value
-    //***************************************************************************
-    ETL_CONSTEXPR14 bool has_value() const ETL_NOEXCEPT
-    {
-      return valid;
+      return *this;
     }
 
     //***************************************************************************
-    /// Get a reference to the value.
+    /// Assignment operator from nullopt.
     //***************************************************************************
-    ETL_CONSTEXPR14 T& value() ETL_LVALUE_REF_QUALIFIER
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional& operator =(etl::nullopt_t)
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
+      impl_t::operator=(etl::nullopt);
 
-      return storage.value;
+      return *this;
     }
-
+#else
     //***************************************************************************
-    /// Get a const reference to the value.
+    /// Assignment operator from nullopt.
     //***************************************************************************
-    ETL_CONSTEXPR14 const T& value() const ETL_LVALUE_REF_QUALIFIER
+    optional& operator =(etl::nullopt_t)
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
+      impl_t::operator=(etl::nullopt);
 
-      return storage.value;
+      return *this;
     }
+#endif
 
+#if ETL_USING_CPP11
     //***************************************************************************
-    /// Gets the value or a default if no valid.
+    /// Assignment operator from optional.
     //***************************************************************************
-    ETL_CONSTEXPR14 T value_or(const T& default_value) const ETL_LVALUE_REF_QUALIFIER
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional& operator =(const optional& other)
     {
-      return valid ? value() : default_value;
+      impl_t::operator=(other);
+
+      return *this;
     }
 
-#if ETL_USING_CPP11
     //***************************************************************************
-    /// Get an rvalue reference to the value.
+    /// Assignment operator from optional.
     //***************************************************************************
-    ETL_CONSTEXPR14 T&& value()&&
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional& operator =(const optional& other)
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
+      impl_t::operator=(other);
 
-      return etl::move(storage.value);
+      return *this;
     }
-
+#else
     //***************************************************************************
-    /// Get a const rvalue reference to the value.
+    /// Assignment operator from optional.
     //***************************************************************************
-    ETL_CONSTEXPR14 const T&& value() const&&
+    optional& operator =(const optional& other)
     {
-#if ETL_IS_DEBUG_BUILD
-      ETL_ASSERT(valid, ETL_ERROR(optional_invalid));
-#endif
+      impl_t::operator=(other);
 
-      return etl::move(storage.value);
+      return *this;
     }
+#endif
 
+#if ETL_USING_CPP11
     //***************************************************************************
-    /// Gets the value or a default if not valid.
+    /// Move assignment operator from optional.
     //***************************************************************************
-    template <typename U>
-    ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) const&
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+      optional& operator =(optional&& other)
     {
-      if (has_value())
-      {
-        return value();
-      }
-      else
-      {
-        return static_cast<T>(etl::forward<U>(default_value));
-      }
+      impl_t::operator=(etl::move(other));
+
+      return *this;
     }
 
     //***************************************************************************
-    /// Gets the value or a default if not valid.
+    /// Move assignment operator from optional.
     //***************************************************************************
-    template <typename U>
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
     ETL_CONSTEXPR20_STL
-    etl::enable_if_t<etl::is_convertible<U, T>::value, T>
-      value_or(U&& default_value) &&
+      optional& operator =(optional&& other)
     {
-      if (has_value())
-      {
-        return etl::move(value());
-      }
-      else
-      {
-        return static_cast<T>(etl::forward<U>(default_value));
-      }
+      impl_t::operator=(etl::move(other));
+
+      return *this;
     }
 #endif
 
+#if ETL_USING_CPP11
     //***************************************************************************
-    /// Swaps this value with another.
+    /// Assignment operator from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 void swap(optional& other)
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+    optional& operator =(const T& value_)
     {
-      optional temp(*this);
-      *this = other;
-      other = temp;
+      impl_t::operator=(value_);
+
+      return *this;
     }
 
     //***************************************************************************
-    /// Reset back to invalid.
+    /// Assignment operator from value type.
     //***************************************************************************
-    ETL_CONSTEXPR14 void reset()
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+    optional& operator =(const T& value_)
     {
-      valid = false;
-    }
+      impl_t::operator=(value_);
 
-#if ETL_USING_CPP11  && ETL_NOT_USING_STLPORT && !defined(ETL_OPTIONAL_FORCE_CPP03_IMPLEMENTATION)
-    //*************************************************************************
-    /// Emplaces a value.
-    ///\param args The arguments to construct with.
-    //*************************************************************************
-    template <typename ... Args>
-    ETL_CONSTEXPR14 void emplace(Args && ... args)
-    {
-      storage.value = T(ETL_OR_STD::forward<Args>(args)...);
-      valid = true;
+      return *this;
     }
 #else
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 0 parameters.
-    //*************************************************************************
-    void emplace()
+    //***************************************************************************
+    /// Assignment operator from value type.
+    //***************************************************************************
+    optional& operator =(const T& value_)
     {
-      storage.value = value_type();
-      valid = true;
-    }
+      impl_t::operator=(value_);
 
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 1 parameter.
-    //*************************************************************************
-    template <typename T1>
-    void emplace(const T1& value1)
-    {
-      storage.value = value1;
-      valid = true;
+      return *this;
     }
+#endif
 
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 2 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2>
-    void emplace(const T1& value1, const T2& value2)
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Move assignment operator from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
+    ETL_CONSTEXPR14
+      optional& operator =(T&& value_)
     {
-      storage.value = T(value1, value2);
-      valid = true;
-    }
+      impl_t::operator=(etl::move(value_));
 
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 3 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3>
-    void emplace(const T1& value1, const T2& value2, const T3& value3)
-    {
-      storage.value = T(value1, value2, value3);
-      valid = true;
+      return *this;
     }
 
-    //*************************************************************************
-    /// Emplaces a value.
-    /// 4 parameters.
-    //*************************************************************************
-    template <typename T1, typename T2, typename T3, typename T4>
-    void emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
+    //***************************************************************************
+    /// Move assignment operator from value type.
+    //***************************************************************************
+    template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
+    ETL_CONSTEXPR20_STL
+      optional& operator =(T&& value_)
     {
-      storage.value = T(value1, value2, value3, value4);
-      valid = true;
+      impl_t::operator=(etl::move(value_));
+
+      return *this;
     }
 #endif
-
-  private:
-
-    bool valid;
-
-    struct dummy_t {};
-
-    union storage_type
-    {
-      dummy_t dummy;
-      T       value;
-
-      ETL_CONSTEXPR storage_type()
-        : dummy()
-      {
-      }
-
-      ETL_CONSTEXPR storage_type(const T& v)
-        : value(v) 
-      {
-      }
-    };
-
-    storage_type storage;
   };
 
 #include "private/diagnostic_uninitialized_push.h"
@@ -1122,7 +1560,27 @@ namespace etl
   /// Equality operator. cppreference 1
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    if (lhs.has_value() != rhs.has_value())
+    {
+      return false;
+    }
+    else if (!lhs.has_value() && !rhs.has_value())
+    {
+      return true;
+    }
+    else
+    {
+      return lhs.value() == rhs.value();
+    }
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 1
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     if (lhs.has_value() != rhs.has_value())
     {
@@ -1139,10 +1597,19 @@ namespace etl
   }
 
   //***************************************************************************
-  /// Equality operator. cppreference 2
+  /// Inequality operator. cppreference 2
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 2
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return !(lhs == rhs);
   }
@@ -1151,7 +1618,27 @@ namespace etl
   /// Less than operator. cppreference 3
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    if (!rhs.has_value())
+    {
+      return false;
+    }
+    else if (!lhs.has_value())
+    {
+      return true;
+    }
+    else
+    {
+      return lhs.value() < rhs.value();
+    }
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 3
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     if (!rhs.has_value())
     {
@@ -1171,7 +1658,16 @@ namespace etl
   /// Less than equal operator. cppreference 4
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return !(rhs < lhs);
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 4
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return !(rhs < lhs);
   }
@@ -1180,7 +1676,16 @@ namespace etl
   /// greater than operator. cppreference 5
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return (rhs < lhs);
+  }
+
+  //***************************************************************************
+  /// greater than operator. cppreference 5
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return (rhs < lhs);
   }
@@ -1189,7 +1694,16 @@ namespace etl
   /// greater than equal operator. cppreference 6
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
+  {
+    return !(lhs < rhs);
+  }
+
+  //***************************************************************************
+  /// greater than equal operator. cppreference 6
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
   {
     return !(lhs < rhs);
   }
@@ -1198,7 +1712,16 @@ namespace etl
   /// Equality operator. cppreference 7
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return !lhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 7
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return !lhs.has_value();
   }
@@ -1207,7 +1730,16 @@ namespace etl
   /// Equality operator. cppreference 8
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
+  {
+    return !rhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 8
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return !rhs.has_value();
   }
@@ -1216,7 +1748,16 @@ namespace etl
   /// Inequality operator. cppreference 9
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return !(lhs == etl::nullopt);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 9
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return !(lhs == etl::nullopt);
   }
@@ -1225,7 +1766,16 @@ namespace etl
   /// Inequality operator. cppreference 10
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator !=(etl::nullopt_t , const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(etl::nullopt_t , const etl::optional<T>& rhs)
+  {
+    return !(etl::nullopt == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 10
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return !(etl::nullopt == rhs);
   }
@@ -1234,7 +1784,16 @@ namespace etl
   /// Less than operator. cppreference 11
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>&, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const etl::optional<T>&, etl::nullopt_t)
+  {
+    return false;
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 11
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const etl::optional<T>&, etl::nullopt_t)
   {
     return false;
   }
@@ -1243,7 +1802,16 @@ namespace etl
   /// Less than operator. cppreference 12
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <(etl::nullopt_t, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(etl::nullopt_t, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 12
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return rhs.has_value();
   }
@@ -1252,7 +1820,16 @@ namespace etl
   /// Less than equal operator. cppreference 13
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return !lhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 13
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return !lhs.has_value();
   }
@@ -1261,7 +1838,16 @@ namespace etl
   /// Less than equal operator. cppreference 14
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator <=(etl::nullopt_t, const etl::optional<T>&)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(etl::nullopt_t, const etl::optional<T>&)
+  {
+    return true;
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 14
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(etl::nullopt_t, const etl::optional<T>&)
   {
     return true;
   }
@@ -1270,7 +1856,16 @@ namespace etl
   /// Greater than operator. cppreference 15
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const etl::optional<T>& lhs, etl::nullopt_t)
+  {
+    return lhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 15
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const etl::optional<T>& lhs, etl::nullopt_t)
   {
     return lhs.has_value();
   }
@@ -1279,7 +1874,16 @@ namespace etl
   /// Greater than operator. cppreference 16
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >(etl::nullopt_t, const etl::optional<T>&)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(etl::nullopt_t, const etl::optional<T>&)
+  {
+    return false;
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 16
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(etl::nullopt_t, const etl::optional<T>&)
   {
     return false;
   }
@@ -1288,7 +1892,16 @@ namespace etl
   /// Greater than equal operator. cppreference 17
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>&, etl::nullopt_t)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const etl::optional<T>&, etl::nullopt_t)
+  {
+    return true;
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 17
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const etl::optional<T>&, etl::nullopt_t)
   {
     return true;
   }
@@ -1297,7 +1910,16 @@ namespace etl
   /// Greater than equal operator. cppreference 18
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 bool operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
+  {
+    return !rhs.has_value();
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 18
+  //***************************************************************************
+  template <typename T>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
   {
     return !rhs.has_value();
   }
@@ -1306,7 +1928,16 @@ namespace etl
   /// Equality operator. cppreference 19
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() == rhs : false;
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 19
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() == rhs : false;
   }
@@ -1315,7 +1946,16 @@ namespace etl
   /// Inequality operator. cppreference 21
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator !=(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 21
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const etl::optional<T>& lhs, const U& rhs)
   {
     return !(lhs == rhs);
   }
@@ -1324,7 +1964,16 @@ namespace etl
   /// Equality operator. cppreference 20
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator ==(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator ==(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? rhs.value() == lhs : false;
+  }
+
+  //***************************************************************************
+  /// Equality operator. cppreference 20
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator ==(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? rhs.value() == lhs : false;
   }
@@ -1333,7 +1982,16 @@ namespace etl
   /// Inequality operator. cppreference 22
   //**************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator !=(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator !=(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Inequality operator. cppreference 22
+  //**************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator !=(const U& lhs, const etl::optional<T>& rhs)
   {
     return !(lhs == rhs);
   }
@@ -1342,7 +2000,16 @@ namespace etl
   /// Less than operator. cppreference 23
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() < rhs : true;
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 23
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() < rhs : true;
   }
@@ -1351,7 +2018,16 @@ namespace etl
   /// Less than operator. cppreference 24
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs < rhs.value() : false;
+  }
+
+  //***************************************************************************
+  /// Less than operator. cppreference 24
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs < rhs.value() : false;
   }
@@ -1360,7 +2036,16 @@ namespace etl
   /// Less than equal operator. cppreference 25
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() <= rhs : true;
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 25
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() <= rhs : true;
   }
@@ -1369,7 +2054,16 @@ namespace etl
   /// Less than equal operator. cppreference 26
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator <=(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator <=(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs <= rhs.value() : false;
+  }
+
+  //***************************************************************************
+  /// Less than equal operator. cppreference 26
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator <=(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs <= rhs.value() : false;
   }
@@ -1378,7 +2072,16 @@ namespace etl
   /// Greater than operator. cppreference 27
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() > rhs  : false;
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 27
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() > rhs  : false;
   }
@@ -1387,7 +2090,16 @@ namespace etl
   /// Greater than operator. cppreference 28
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs > rhs.value() : true;
+  }
+
+  //***************************************************************************
+  /// Greater than operator. cppreference 28
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs > rhs.value() : true;
   }
@@ -1396,7 +2108,16 @@ namespace etl
   /// Greater than equal operator. cppreference 29
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const U& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const etl::optional<T>& lhs, const U& rhs)
+  {
+    return lhs.has_value() ? lhs.value() >= rhs : false;
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 29
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const etl::optional<T>& lhs, const U& rhs)
   {
     return lhs.has_value() ? lhs.value() >= rhs : false;
   }
@@ -1405,7 +2126,16 @@ namespace etl
   /// Greater than equal operator. cppreference 30
   //***************************************************************************
   template <typename T, typename U>
-  ETL_CONSTEXPR14 bool operator >=(const U& lhs, const etl::optional<T>& rhs)
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator >=(const U& lhs, const etl::optional<T>& rhs)
+  {
+    return rhs.has_value() ? lhs >= rhs.value() : true;
+  }
+
+  //***************************************************************************
+  /// Greater than equal operator. cppreference 30
+  //***************************************************************************
+  template <typename T, typename U>
+  ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator >=(const U& lhs, const etl::optional<T>& rhs)
   {
     return rhs.has_value() ? lhs >= rhs.value() : true;
   }
@@ -1416,7 +2146,7 @@ namespace etl
   /// Make an optional.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR14 etl::optional<typename etl::decay<T>::type> make_optional(T& value)
+  ETL_CONSTEXPR20_STL etl::optional<typename etl::decay<T>::type> make_optional(T& value)
   {
     return etl::optional<typename etl::decay<T>::type>(value);
   }
@@ -1434,9 +2164,15 @@ namespace etl
 /// Swaps the values.
 //*************************************************************************
 template <typename T>
-ETL_CONSTEXPR14 void swap(etl::optional<T>& lhs, etl::optional<T>& rhs)
+ETL_CONSTEXPR20_STL void swap(etl::optional<T>& lhs, etl::optional<T>& rhs)
 {
   lhs.swap(rhs);
 }
 
+#undef ETL_OPTIONAL_ENABLE_CPP14
+#undef ETL_OPTIONAL_ENABLE_CPP20_STL
+
+#undef ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL
+#undef ETL_OPTIONAL_ENABLE_COMSTEXPR_BOOL_RETURN_CPP20_STL
+
 #endif
diff --git a/src/etl/platform.h b/src/etl/platform.h
index 294ee7c..17c7961 100644
--- a/src/etl/platform.h
+++ b/src/etl/platform.h
@@ -202,6 +202,14 @@ SOFTWARE.
   #define ETL_HAS_IDEQUE_REPAIR 0
 #endif
 
+//*************************************
+// Option to enable repair-after-memcpy for icircular_buffer.
+#if defined(ETL_ICIRCULAR_BUFFER_REPAIR_ENABLE)
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 1
+#else
+#define ETL_HAS_ICIRCULAR_BUFFER_REPAIR 0
+#endif
+
 //*************************************
 // Indicate if C++ exceptions are enabled.
 #if defined(ETL_THROW_EXCEPTIONS)
@@ -249,7 +257,6 @@ SOFTWARE.
   #define ETL_CONSTEXPR                   constexpr
   #define ETL_CONSTEXPR11                 constexpr // Synonym for ETL_CONSTEXPR
   #define ETL_CONSTANT                    constexpr
-  #define ETL_STATIC_CONSTANT             constexpr
   #define ETL_DELETE                      = delete
   #define ETL_EXPLICIT                    explicit
   #define ETL_OVERRIDE                    override
@@ -271,7 +278,6 @@ SOFTWARE.
   #define ETL_CONSTEXPR
   #define ETL_CONSTEXPR11
   #define ETL_CONSTANT                    const
-  #define ETL_STATIC_CONSTANT             static const
   #define ETL_DELETE
   #define ETL_EXPLICIT
   #define ETL_OVERRIDE
@@ -479,6 +485,7 @@ namespace etl
     static ETL_CONSTANT bool has_string_clear_after_use       = (ETL_HAS_STRING_CLEAR_AFTER_USE == 1);
     static ETL_CONSTANT bool has_istring_repair               = (ETL_HAS_ISTRING_REPAIR == 1);
     static ETL_CONSTANT bool has_ivector_repair               = (ETL_HAS_IVECTOR_REPAIR == 1);
+    static ETL_CONSTANT bool has_icircular_buffer_repair      = (ETL_HAS_ICIRCULAR_BUFFER_REPAIR == 1);
     static ETL_CONSTANT bool has_mutable_array_view           = (ETL_HAS_MUTABLE_ARRAY_VIEW == 1);
     static ETL_CONSTANT bool has_ideque_repair                = (ETL_HAS_IDEQUE_REPAIR == 1);
     static ETL_CONSTANT bool has_virtual_messages             = (ETL_HAS_VIRTUAL_MESSAGES == 1);
diff --git a/src/etl/private/bitset_legacy.h b/src/etl/private/bitset_legacy.h
index 24052e4..593f415 100644
--- a/src/etl/private/bitset_legacy.h
+++ b/src/etl/private/bitset_legacy.h
@@ -151,10 +151,10 @@ namespace etl
     typedef typename etl::make_unsigned<ETL_BITSET_ELEMENT_TYPE>::type element_type;
     typedef element_type element_t; // Backward compatibility
 
-    static ETL_CONSTANT element_type ALL_SET = etl::integral_limits<element_type>::max;
+    static ETL_CONSTANT element_type ALL_SET   = etl::integral_limits<element_type>::max;
     static ETL_CONSTANT element_type ALL_CLEAR = 0;
 
-    static ETL_CONSTANT size_t    Bits_Per_Element = etl::integral_limits<element_type>::bits;
+    static ETL_CONSTANT size_t       Bits_Per_Element  = etl::integral_limits<element_type>::bits;
 
 #if ETL_USING_CPP11
     typedef etl::span<element_type>       span_type;
@@ -311,7 +311,7 @@ namespace etl
     //*************************************************************************
     ibitset& set()
     {
-      ::memset(pdata, 0xFF, Number_Of_Elements);
+      etl::fill_n(pdata, Number_Of_Elements - 1U, ALL_SET);
       pdata[Number_Of_Elements - 1U] = Top_Mask;
 
       return *this;
@@ -429,7 +429,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const char* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -439,7 +446,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const wchar_t* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -449,7 +463,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const char16_t* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -459,7 +480,14 @@ namespace etl
     //*************************************************************************
     ibitset& set(const char32_t* text)
     {
-      from_string(text);
+      if (text == ETL_NULLPTR)
+      {
+        reset();
+      }
+      else
+      {
+        from_string(text);
+      }
 
       return *this;
     }
@@ -491,7 +519,7 @@ namespace etl
       return v;
     }
 
-    //*************************************************************************
+    //************************************************************************* 
     /// Put to a unsigned long.
     //*************************************************************************
     unsigned long to_ulong() const
@@ -512,7 +540,7 @@ namespace etl
     //*************************************************************************
     ibitset& reset()
     {
-      ::memset(pdata, 0x00, Number_Of_Elements);
+      etl::fill_n(pdata, Number_Of_Elements, ALL_CLEAR);
 
       return *this;
     }
@@ -554,10 +582,10 @@ namespace etl
     //*************************************************************************
     ibitset& flip()
     {
-      for (size_t i = 0UL; i < Number_Of_Elements; ++i)
-      {
-        pdata[i] = ~pdata[i];
-      }
+      etl::transform_n(pdata, 
+                       Number_Of_Elements, 
+                       pdata, 
+                       etl::binary_not<element_type>());
 
       clear_unused_bits_in_msb();
 
@@ -832,7 +860,7 @@ namespace etl
             --dst_index;
 
             // Shift lsb.
-            element_type lsb = element_type((pdata[src_index] & lsb_mask) << lsb_shift);
+            lsb = element_type((pdata[src_index] & lsb_mask) << lsb_shift);
             pdata[dst_index] = lsb;
             --src_index;
           }
@@ -1194,7 +1222,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const char* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
@@ -1205,7 +1232,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const wchar_t* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
@@ -1216,7 +1242,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const char16_t* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
@@ -1227,7 +1252,6 @@ namespace etl
     //*************************************************************************
     bitset<MaxN>& set(const char32_t* text)
     {
-      ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
       etl::ibitset::set(text);
 
       return *this;
diff --git a/src/etl/private/bitset_new.h b/src/etl/private/bitset_new.h
index 63462f2..323a4e4 100644
--- a/src/etl/private/bitset_new.h
+++ b/src/etl/private/bitset_new.h
@@ -45,11 +45,18 @@ SOFTWARE.
 #include "../error_handler.h"
 #include "../span.h"
 #include "../string.h"
+#include "../enum_type.h"
+#include "../largest.h"
+#include "../smallest.h"
 
 #include <string.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#if ETL_USING_STL
+#include <algorithm>
+#endif
+
 #include "minmax_push.h"
 
 #if defined(ETL_COMPILER_KEIL)
@@ -76,14 +83,26 @@ SOFTWARE.
 
 namespace etl
 {
-  template <typename T = void>
-  struct bitset_constants
+  //***************************************************************************
+  /// Flags to indicate whether the bitset is contained in a single element
+  /// or spread over an array of elements.
+  ///\ingroup bitset
+  //***************************************************************************
+  struct bitset_storage_model
   {
-    static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
-  };
+    enum enum_type
+    {
+      Undefined = 0,
+      Single    = 1,
+      Multi     = 2
+    };
 
-  template <typename T>
-  ETL_CONSTANT size_t bitset_constants<T>::npos;
+    ETL_DECLARE_ENUM_TYPE(bitset_storage_model, char)
+    ETL_ENUM_TYPE(Undefined, "Undefined")
+    ETL_ENUM_TYPE(Single,    "Single")
+    ETL_ENUM_TYPE(Multi,     "Multi")
+    ETL_END_ENUM_TYPE
+  };
 
   //***************************************************************************
   /// Exception base for bitset
@@ -127,122 +146,204 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Bitset nullptr buffer exception.
+  ///\ingroup bitset
+  //***************************************************************************
+  class bitset_invalid_buffer : public bitset_exception
+  {
+  public:
+
+    bitset_invalid_buffer(string_type file_name_, numeric_type line_number_)
+      : bitset_exception(ETL_ERROR_TEXT("bitset:invalid buffer", ETL_BITSET_FILE_ID"D"), file_name_, line_number_)
+    {
+    }
+  };
+
+  //***************************************************************************
+  namespace private_bitset
+  {
+    template <typename TElement>
+    class bitset_impl_common
+    {
+    public:
+
+      typedef TElement        element_type;
+      typedef TElement*       pointer;
+      typedef const TElement* const_pointer;
+
+      static ETL_CONSTANT size_t   npos              = etl::integral_limits<size_t>::max;
+      static ETL_CONSTANT size_t   Bits_Per_Element  = etl::integral_limits<TElement>::bits;
+      static ETL_CONSTANT TElement All_Set_Element   = etl::integral_limits<TElement>::max;
+      static ETL_CONSTANT TElement All_Clear_Element = element_type(0);
+    };
+
+    template <typename TElement>
+    ETL_CONSTANT size_t bitset_impl_common<TElement>::npos;
+
+    template <typename TElement>
+    ETL_CONSTANT size_t bitset_impl_common<TElement>::Bits_Per_Element;
+
+    template <typename TElement>
+    ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Set_Element;
+
+    template <typename TElement>
+    ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Clear_Element;
+  }
+
   //*************************************************************************
-  /// The implementation class for multi-element etl::bitset
+  /// Bitset implementation declaration.
+  ///\ingroup bitset
+  //*************************************************************************
+  template <typename TElement, char Bitset_Layout>
+  class bitset_impl;
+
+  //*************************************************************************
+  /// The implementation class for single element etl::bitset
   ///\ingroup bitset
   //*************************************************************************
   template <typename TElement>
-  class bitset_impl : public bitset_constants<>
+  class bitset_impl<TElement, etl::bitset_storage_model::Single> : public etl::private_bitset::bitset_impl_common<TElement>
   {
   public:
 
-    typedef typename etl::make_unsigned<TElement>::type element_type;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
 
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
+    using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
 
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<element_type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
+    using etl::private_bitset::bitset_impl_common<TElement>::npos;
 
     //*************************************************************************
-    /// Count the number of bits set.
+    /// Set all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t count(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    void set_all(pointer      pbuffer,
+                 size_t       /*number_of_elements*/,
+                 element_type top_mask) ETL_NOEXCEPT
     {
-      size_t n = 0UL;
-
-      for (size_t i = 0UL; i < number_of_elements; ++i)
-      {
-        n += etl::count_bits(pbuffer[i]);
-      }
-
-      return n;
+      *pbuffer = All_Set_Element & top_mask;
     }
 
     //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bool test(const_pointer pbuffer, size_t number_of_elements, size_t position) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void set_position(pointer pbuffer, 
+                      size_t  position, 
+                      bool    value = true)
     {
-      size_t       index = 0U;
-      element_type mask  = element_type(0);
+      const element_type mask = element_type(element_type(1) << position);
 
-      if (number_of_elements == 1U)
+      if (value == true)
       {
-        index = 0;
-        mask = element_type(1) << position;
+        *pbuffer |= mask;
       }
       else
       {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        mask = element_type(1) << (position & (Bits_Per_Element - 1));
+        *pbuffer &= ~mask;
       }
-
-      return (pbuffer[index] & mask) != 0;
     }
 
-
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t position, bool value = true) ETL_NOEXCEPT
+    template <size_t Position>
+    static
+    ETL_CONSTEXPR14
+    void set_position(pointer pbuffer,
+                      bool    value = true)
     {
-      size_t    index = 0;
-      element_type bit = 0;
+      const element_type mask = element_type(element_type(1) << Position);
 
-      if (number_of_elements == 0)
-      {
-        return;
-      }
-      else if (number_of_elements == 1U)
+      if (value == true)
       {
-        index = 0;
-        bit = element_type(1) << position;
+        *pbuffer |= mask;
       }
       else
       {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
+        *pbuffer &= ~mask;
       }
+    }
+
+    //*************************************************************************
+    /// Set the bit at the position.
+    //*************************************************************************
+    template <size_t Position, bool Value>
+    static
+    ETL_CONSTEXPR14
+    void set_position(pointer pbuffer)
+    {
+      const element_type mask = element_type(element_type(1) << Position);
 
-      if (value)
+      if (Value == true)
       {
-        pbuffer[index] |= bit;
+        *pbuffer |= mask;
       }
       else
       {
-        pbuffer[index] &= ~bit;
+        *pbuffer &= ~mask;
       }
     }
 
+    //*************************************************************************
+    /// Reset all of the bits.
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14
+    void reset_all(pointer pbuffer, 
+                   size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// Reset the bit at the position.
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14
+
+    void reset_position(pointer pbuffer, 
+                        size_t  position)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+      *pbuffer &= ~mask;
+    }
+
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void from_string(pointer     pbuffer, 
+                     size_t      /*number_of_elements*/, 
+                     size_t      active_bits, 
+                     const char* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
-      }
-      else
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
-
-        // Only reset elements we need to.
-        while (element_index != number_of_elements)
-        {
-          pbuffer[element_index++] = All_Clear_Element;
-        }
 
         // Build from the string.
-        size_t i = etl::min(total_bits, string_length);
+        string_length = etl::min(active_bits, string_length);
 
-        while (i > 0)
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STR('1'));
+          if (text[i] == ETL_STR('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
         }
       }
     }
@@ -250,29 +351,32 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void from_string(pointer        pbuffer, 
+                     size_t         /*number_of_elements*/, 
+                     size_t         active_bits, 
+                     const wchar_t* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
-      }
-      else
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
-
-        // Only reset elements we need to.
-        while (element_index != number_of_elements)
-        {
-          pbuffer[element_index++] = All_Clear_Element;
-        }
 
         // Build from the string.
-        size_t i = etl::min(total_bits, string_length);
+        string_length = etl::min(active_bits, string_length);
 
-        while (i > 0)
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRL('1'));
+          if (text[i] == ETL_STRL('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
         }
       }
     }
@@ -280,29 +384,32 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    void from_string(pointer         pbuffer, 
+                     size_t          /*number_of_elements*/, 
+                     size_t          active_bits, 
+                     const char16_t* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
-      }
-      else
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
-
-        // Only reset elements we need to.
-        while (element_index != number_of_elements)
-        {
-          pbuffer[element_index++] = All_Clear_Element;
-        }
 
         // Build from the string.
-        size_t i = etl::min(total_bits, string_length);
+        string_length = etl::min(active_bits, string_length);
 
-        while (i > 0)
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRu('1'));
+          if (text[i] == ETL_STRu('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
         }
       }
     }
@@ -310,206 +417,253 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    void from_string(pointer         pbuffer, 
+                     size_t          /*number_of_elements*/, 
+                     size_t          active_bits, 
+                     const char32_t* text) ETL_NOEXCEPT
     {
-      if (text == ETL_NULLPTR)
-      {
-        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
-      }
-      else
+      reset_all(pbuffer, 1U);
+
+      if (text != ETL_NULLPTR)
       {
         size_t string_length = etl::strlen(text);
-        size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
-
-        // Only reset elements we need to.
-        while (element_index != number_of_elements)
-        {
-          pbuffer[element_index++] = All_Clear_Element;
-        }
 
         // Build from the string.
-        size_t i = etl::min(total_bits, string_length);
+        string_length = etl::min(active_bits, string_length);
 
-        while (i > 0)
+        element_type mask = element_type(element_type(1) << (string_length - 1U));
+
+        for (size_t i = 0U; i < string_length; ++i)
         {
-          set(pbuffer, number_of_elements, --i, *text++ == ETL_STRU('1'));
+          if (text[i] == ETL_STRU('1'))
+          {
+            *pbuffer |= mask;
+          }
+
+          mask >>= 1U;
         }
       }
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Get as an integral value.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT
+    template <typename T>
+    static
+    ETL_CONSTEXPR14
+    T value(const_pointer pbuffer, 
+            size_t        /*number_of_elements*/) ETL_NOEXCEPT
     {
-      from_string(pbuffer, number_of_elements, total_bits, text);
+      return T(*pbuffer);
     }
 
     //*************************************************************************
-    /// Set from a wstring.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT
+    template <typename T>
+    static
+    ETL_CONSTEXPR14
+    T extract(const_pointer pbuffer, 
+              size_t        position, 
+              size_t        length = etl::integral_limits<T>::bits)
     {
-      from_string(pbuffer, number_of_elements, total_bits, text);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t>(length);
+      const unsigned_t Shift = position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
-    /// Set from a u16string.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT
+#if ETL_USING_CPP11
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+		template <typename T, size_t Position, size_t Length>
+#endif
+    static
+    ETL_CONSTEXPR14
+    T extract(const_pointer pbuffer)
     {
-      from_string(pbuffer, number_of_elements, total_bits, text);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      const unsigned_t Mask  = etl::make_lsb_mask<unsigned_t>(Length);
+      const unsigned_t Shift = Position % Bits_Per_Element;
+
+      unsigned_t value = static_cast<unsigned_t>(*pbuffer >> Shift) & Mask;
+
+      if ((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, Length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
-    /// Set from a u32string.
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will return <b>false</b>.
     //*************************************************************************
-    ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    bool test(const_pointer pbuffer, 
+              size_t        position)
     {
-      from_string(pbuffer, number_of_elements, total_bits, text);
+      const element_type mask = element_type(element_type(1) << position);
+      return (*pbuffer & mask) != 0U;
     }
 
     //*************************************************************************
-    /// Get as a value.
+    /// Count the number of bits set.
     //*************************************************************************
-    template <typename T>
+    static
     ETL_CONSTEXPR14
-    typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    size_t count(const_pointer pbuffer, 
+                 size_t        /*number_of_elements*/) ETL_NOEXCEPT
     {
-      T v = T(0);
-
-      const bool OK = (sizeof(T) * CHAR_BIT) >= (number_of_elements * Bits_Per_Element);
-
-      if (OK)
-      {
-        uint_least8_t shift = 0U;
-
-        for (size_t i = 0UL; i < number_of_elements; ++i)
-        {
-          v |= T(typename etl::make_unsigned<T>::type(pbuffer[i]) << shift);
-          shift += uint_least8_t(Bits_Per_Element);
-        }
-      }
-
-      return v;
+      return etl::count_bits(*pbuffer);
     }
 
     //*************************************************************************
-    /// Reset the bit at the position.
+    // Are all the bits sets?
     //*************************************************************************
-    ETL_CONSTEXPR14 void reset(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    bool all(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  top_mask) ETL_NOEXCEPT
     {
-      size_t       index = 0U;
-      element_type bit = element_type(0);
-
-      if (number_of_elements == 0)
-      {
-        return;
-      }
-      else if (number_of_elements == 1)
-      {
-        index = 0;
-        bit = element_type(1) << position;
-      }
-      else
-      {
-        index = position >> etl::log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
-      }
-
-      pbuffer[index] &= ~bit;
+      return (*pbuffer & top_mask) == top_mask;
     }
 
     //*************************************************************************
-    /// Flip all of the bits.
+    // Are all the mask bits sets?
     //*************************************************************************
-    ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    bool all(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  top_mask, 
+             element_type  mask) ETL_NOEXCEPT
     {
-      for (size_t i = 0UL; i < number_of_elements; ++i)
-      {
-        pbuffer[i] = ~pbuffer[i];
-      }
+      return (*pbuffer & top_mask & mask) == mask;
     }
 
     //*************************************************************************
-    /// Flip the bit at the position.
+    /// Are none of the bits set?
     //*************************************************************************
-    ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    bool none(const_pointer pbuffer, 
+              size_t        /*number_of_elements*/) ETL_NOEXCEPT
     {
-      size_t       index = 0U;
-      element_type bit = element_type(0);
-      
-      if (number_of_elements == 0)
-      {
-        return;
-      }
-      else if (number_of_elements == 1)
-      {
-        index = 0;
-        bit = element_type(1) << position;
-      }
-      else
-      {
-        index = position >> log2<Bits_Per_Element>::value;
-        bit = element_type(1) << (position & (Bits_Per_Element - 1));
-      }
-
-      pbuffer[index] ^= bit;
+      return *pbuffer == All_Clear_Element;
     }
 
     //*************************************************************************
-    // Are all the bits sets?
+    /// Are none of the mask bits set?
     //*************************************************************************
-    ETL_CONSTEXPR14 bool all(const_pointer pbuffer, size_t number_of_elements, element_type top_mask) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    bool none(const_pointer pbuffer, 
+              size_t        /*number_of_elements*/, 
+              element_type  mask) ETL_NOEXCEPT
     {
-      if (number_of_elements == 0UL)
-      {
-        return true;
-      }
+      return (*pbuffer & mask) == All_Clear_Element;
+    }
 
-      // All but the last.
-      for (size_t i = 0UL; i < (number_of_elements - 1U); ++i)
-      {
-        if (pbuffer[i] != All_Set_Element)
-        {
-          return false;
-        }
-      }
+    //*************************************************************************
+    /// Are any of the bits set?
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    bool any(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return *pbuffer != All_Clear_Element;
+    }
 
-      // The last.
-      if (pbuffer[number_of_elements - 1U] != (All_Set_Element & top_mask))
-      {
-        return false;
-      }
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    bool any(const_pointer pbuffer, 
+             size_t        /*number_of_elements*/, 
+             element_type  mask) ETL_NOEXCEPT
+    {
+      return (*pbuffer & mask) != All_Clear_Element;
+    }
 
-      return true;
+    //*************************************************************************
+    /// Flip all of the bits.
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    void flip_all(pointer pbuffer, 
+                     size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = ~*pbuffer;
     }
 
     //*************************************************************************
-    /// Are none of the bits set?
+    /// Flip some of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bool none(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    void flip_bits(pointer      pbuffer, 
+                   element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
     {
-      for (size_t i = 0UL; i < number_of_elements; ++i)
-      {
-        if (pbuffer[i] != 0)
-        {
-          return false;
-        }
-      }
+      *pbuffer ^= mask;
+    }
 
-      return true;
+    //*************************************************************************
+    /// Flip the bit at the position.
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    void flip_position(pointer pbuffer, 
+                       size_t  position)
+    {
+      const element_type mask = element_type(element_type(1) << position);
+      *pbuffer ^= mask;
     }
 
     //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or Number_Of_Elements if none were found.
+    /// Returns a string representing the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state) const ETL_NOEXCEPT
+    template <typename TString>
+    static
+    ETL_CONSTEXPR14 
+    TString to_string(const_pointer pbuffer,
+                      size_t active_bits,
+                      typename TString::value_type zero = typename TString::value_type('0'),
+                      typename TString::value_type one  = typename TString::value_type('1'))
     {
-      return find_next(pbuffer, number_of_elements, total_bits, state, 0);
+      TString result;
+
+      result.resize(active_bits, '\0');
+
+      // Check that the string type can contain the digits.
+      ETL_ASSERT_OR_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result);
+
+      for (size_t i = active_bits; i > 0; --i)
+      {
+        result[active_bits - i] = test(pbuffer, i - 1) ? one : zero;
+      }
+
+      return result;
     }
 
     //*************************************************************************
@@ -518,1664 +672,791 @@ namespace etl
     ///\param position The position to start from.
     ///\returns The position of the bit or npos if none were found.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state, size_t position) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    size_t find_next(const_pointer pbuffer, 
+                     size_t        /*number_of_elements*/, 
+                     size_t        active_bits, 
+                     bool          state, 
+                     size_t        position) ETL_NOEXCEPT
     {
-      // Where to start.
-      size_t index = position >> log2<Bits_Per_Element>::value;
-      size_t bit   = position & (Bits_Per_Element - 1);
-
-      element_type mask = 1 << bit;
-
-      // For each element in the bitset...
-      while (index < number_of_elements)
+      if (position < active_bits)
       {
-        element_type value = pbuffer[index];
+        // Where to start.
+        size_t bit = position;
+
+        element_type mask = 1U << position;
 
         // Needs checking?
-        if ((state && (value != All_Clear_Element)) ||
-            (!state && (value != All_Set_Element)))
+        if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element)))
         {
           // For each bit in the element...
-          while ((bit < Bits_Per_Element) && (position < total_bits))
+          while (bit < active_bits)
           {
             // Equal to the required state?
-            if (((value & mask) != 0) == state)
+            if (((*pbuffer & mask) != 0) == state)
             {
-              return position;
+              return bit;
             }
 
             // Move on to the next bit.
             mask <<= 1;
-            ++position;
             ++bit;
           }
         }
-        else
-        {
-          position += (Bits_Per_Element - bit);
-        }
-
-        // Start at the beginning for all other elements.
-        bit = 0;
-        mask = 1;
-
-        ++index;
       }
 
       return npos;
     }
 
     //*************************************************************************
-    /// Returns a string representing the bitset.
+    /// operator assignment
+    /// Assigns rhs to lhs
     //*************************************************************************
-    template <typename TString>
-    ETL_CONSTEXPR14 TString to_string(const_pointer                pbuffer,
-                                      size_t                       number_of_elements, 
-                                      size_t                       active_bits, 
-                                      typename TString::value_type zero, 
-                                      typename TString::value_type one) const
+    static
+    ETL_CONSTEXPR14 
+    void operator_assignment(pointer       lhs_pbuffer, 
+                             const_pointer rhs_pbuffer, 
+                             size_t        /*number_of_elements*/) ETL_NOEXCEPT
     {
-      TString result;
+      *lhs_pbuffer = *rhs_pbuffer;
+    }
 
-      result.resize(active_bits, '\0');
+    //*************************************************************************
+    /// operator and
+    /// AND lhs and rhs and put the result in lhs
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    void operator_and(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer &= *rhs_pbuffer;
+    }
 
-      // Check that the string type can contain the digits.
-      ETL_ASSERT_OR_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result);      
+    //*************************************************************************
+    /// operator or
+    /// OR lhs and rhs and put the result in lhs
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    void operator_or(pointer       lhs_pbuffer, 
+                     const_pointer rhs_pbuffer, 
+                     size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer |= *rhs_pbuffer;
+    }
 
-      for (size_t i = active_bits; i > 0; --i)
-      {
-        result[active_bits - i] = test(pbuffer, number_of_elements, i - 1) ? one : zero;
-      }
+    //*************************************************************************
+    /// operator xor
+    /// XOR lhs and rhs and put the result in lhs
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    void operator_xor(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *lhs_pbuffer ^= *rhs_pbuffer;
+    }
 
-      return result;
+    //*************************************************************************
+    /// operator ~
+    /// NOT the value in the buffer
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    void operator_not(pointer pbuffer, 
+                      size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      *pbuffer = ~*pbuffer;
     }
 
     //*************************************************************************
-    /// shift_left_equals
+    /// operator_shift_left
     //*************************************************************************
-    ETL_CONSTEXPR14 void shift_left_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    void operator_shift_left(pointer pbuffer, 
+                             size_t  /*number_of_elements*/, 
+                             size_t  active_bits, 
+                             size_t  shift) ETL_NOEXCEPT
     {
-      if (number_of_elements == 1U)
-      {
-        // Just one element.
-        pbuffer[0] <<= shift;
-      }
-      else if ((shift % Bits_Per_Element) == 0U)
+      if (shift >= active_bits)
       {
-        // Shift by whole element.
-        const size_t element_shift = shift / Bits_Per_Element;
-        etl::copy_backward(pbuffer, pbuffer + number_of_elements - element_shift, pbuffer + number_of_elements);
-        etl::fill_n(pbuffer, element_shift, All_Clear_Element);
+        reset_all(pbuffer, 1U);
       }
       else
       {
-        // The place where the elements are split when shifting.
-        const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element);
-
-        // Where we are shifting from.
-        int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U);
-
-        // Where we are shifting to.
-        int dst_index = int(number_of_elements - 1U);
-
-        // Shift control constants.
-        const size_t lsb_shift = Bits_Per_Element - split_position;
-        const size_t msb_shift = split_position;
-
-        const element_type lsb_mask         = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-        const element_type msb_mask         = etl::integral_limits<element_type>::max - lsb_mask;
-        const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift);
-          
-        // First lsb.
-        element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-        pbuffer[dst_index] = lsb;
-        --src_index;
-
-        // Now do the shifting.
-        while (src_index >= 0)
-        {
-          // Shift msb.
-          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-          pbuffer[dst_index] = pbuffer[dst_index] | msb;
-          --dst_index;
-
-          // Shift lsb.
-          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-          pbuffer[dst_index] = lsb;
-          --src_index;
-        }
-
-        // Clear the remaining bits.
-        // First lsb.
-        pbuffer[dst_index] &= lsb_shifted_mask;
-//        --dst_index;
-
-        // The other remaining bytes on the right.
-        for (int i = 0; i < dst_index; ++i)
-        {
-          pbuffer[i] = 0;
-        }
+        *pbuffer <<= shift;
       }
     }
 
     //*************************************************************************
-    /// shift_right_equals
+    /// operator_shift_right
     //*************************************************************************
-    ETL_CONSTEXPR14 void shift_right_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    void operator_shift_right(pointer pbuffer, 
+                              size_t  /*number_of_elements*/, 
+                              size_t  active_bits, 
+                              size_t  shift) ETL_NOEXCEPT
     {
-      if (number_of_elements == 1U)
+      if (shift >= active_bits)
       {
-        // Just one element.
-        pbuffer[0] >>= shift;
-      }
-      else if ((shift % Bits_Per_Element) == 0U)
-      {
-        // Shift by whole elements.
-        const size_t element_shift = (shift / Bits_Per_Element);
-        pointer pzeros_begin = etl::copy(pbuffer + element_shift, pbuffer + number_of_elements, pbuffer);      
-        etl::fill_n(pzeros_begin, element_shift, All_Clear_Element);
+        reset_all(pbuffer, 1U);
       }
       else
       {
-        // The place where the elements are split when shifting.
-        const size_t split_position = shift % Bits_Per_Element;
+        *pbuffer >>= shift;
+      }
+    }
 
-        // Where we are shifting from.
-        int src_index = int(shift / Bits_Per_Element);
+    //*************************************************************************
+    /// operator_equality
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    bool operator_equality(const_pointer lhs_pbuffer, 
+                           const_pointer rhs_pbuffer, 
+                           size_t        /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      return (*lhs_pbuffer == *rhs_pbuffer);
+    }
 
-        // Where we are shifting to.
-        int dst_index = 0;
+    //*************************************************************************
+    /// Initialise from an unsigned long long.
+    //*************************************************************************
+    template <typename TElementType>
+    static
+    ETL_CONSTEXPR14 
+    void initialise(pointer            pbuffer, 
+                    size_t             /*number_of_elements*/,
+                    unsigned long long value) ETL_NOEXCEPT
+    {
+      *pbuffer = static_cast<TElementType>(value);
+    }
 
-        // Shift control constants.
-        const size_t lsb_shift = Bits_Per_Element - split_position;
-        const size_t msb_shift = split_position;
+    //*************************************************************************
+    /// swap
+    //*************************************************************************
+    static
+    ETL_CONSTEXPR14 
+    void swap(pointer lhs_pbuffer, 
+              pointer rhs_pbuffer, 
+              size_t  /*number_of_elements*/) ETL_NOEXCEPT
+    {
+      element_type temp = *lhs_pbuffer;
+      *lhs_pbuffer = *rhs_pbuffer;
+      *rhs_pbuffer = temp;
+    }
+  };
 
-        const element_type lsb_mask         = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
-        const element_type msb_mask         = etl::integral_limits<element_type>::max - lsb_mask;
-        const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift);
+  //*************************************************************************
+  /// The implementation class for multi element etl::bitset
+  ///\ingroup bitset
+  //*************************************************************************
+  template <typename TElement>
+  class bitset_impl<TElement, etl::bitset_storage_model::Multi> : public etl::private_bitset::bitset_impl_common<TElement>
+  {
+  private:
 
-        // Now do the shifting.
-        while (src_index < int(number_of_elements - 1))
-        {
-          // Shift msb.
-          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-          ++src_index;
-            
-          // Shift lsb.
-          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
-            
-          // Combine them.
-          pbuffer[dst_index] = lsb | msb;
-          ++dst_index;
-        }
+    typedef etl::private_bitset::bitset_impl_common<TElement> common;
 
-        // Final msb.
-        element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
-        pbuffer[dst_index] = msb;
+  public:
 
-        // Clear the remaining bits.
-        // First msb.
-        pbuffer[dst_index] &= msb_shifted_mask;
-        ++dst_index;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
+    using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
 
-        // The other remaining bytes.
-        while (dst_index < int(number_of_elements))
-        {
-          pbuffer[dst_index] = 0;
-          ++dst_index;
-        }
-      }
-    }
+    using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
+
+    using etl::private_bitset::bitset_impl_common<TElement>::npos;
 
     //*************************************************************************
-    /// and_equals
+    /// Check to see if the requested extract is contained within one element.
     //*************************************************************************
-    ETL_CONSTEXPR14 void and_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
+    template <size_t Position, size_t Length, size_t Bits_Per_Element>
+    struct value_is_in_one_element
     {
-      for (size_t i = 0U; i < number_of_elements; ++i)
-      {
-        pbuffer[i] &= pbuffer2[i];
-      }
-    }
+      static ETL_CONSTANT bool value = ((Position + Length - 1) >> etl::log2<Bits_Per_Element>::value) == (Position >> etl::log2<Bits_Per_Element>::value);
+    };
 
     //*************************************************************************
-    /// or_equals
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will return <b>false</b>.
     //*************************************************************************
-    ETL_CONSTEXPR14 void or_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    bool test(const_pointer pbuffer,
+              size_t        position) ETL_NOEXCEPT
     {
-      for (size_t i = 0U; i < number_of_elements; ++i)
-      {
-        pbuffer[i] |= pbuffer2[i];
-      }
+      size_t index      = position >> etl::log2<Bits_Per_Element>::value;
+      element_type mask = element_type(1) << (position & (Bits_Per_Element - 1));
+
+      return (pbuffer[index] & mask) != 0;
     }
 
     //*************************************************************************
-    /// xor_equals
+    /// Count the number of bits set.
     //*************************************************************************
-    ETL_CONSTEXPR14 void xor_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    size_t count(const_pointer pbuffer,
+                 size_t        number_of_elements) ETL_NOEXCEPT
     {
-      for (size_t i = 0U; i < number_of_elements; ++i)
+      size_t count = 0;
+
+      while (number_of_elements-- != 0)
       {
-        pbuffer[i] ^= pbuffer2[i];
+        count += etl::count_bits(*pbuffer++);
       }
+
+      return count;
     }
 
     //*************************************************************************
-    /// Initialise from an unsigned long long.
+    // Are all the bits sets?
     //*************************************************************************
-    ETL_CONSTEXPR14 void initialise(pointer pbuffer, size_t number_of_elements, unsigned long long value) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    bool all(const_pointer pbuffer,
+             size_t        number_of_elements,
+             element_type  top_mask) ETL_NOEXCEPT
     {
-      const size_t Shift = (etl::integral_limits<unsigned long long>::bits <= (int)Bits_Per_Element) ? 0 : Bits_Per_Element;
-
-      // Can we do it in one hit?
-      if (Shift == 0)
-      {
-        pbuffer[0] = element_type(value);
-      }
-      else
+      // All but the last.
+      while (number_of_elements-- != 1U)
       {
-        size_t i = 0UL;
-
-        // Set the non-zero elements.
-        while ((value != 0) && (i != number_of_elements))
+        if (*pbuffer++ != All_Set_Element)
         {
-          pbuffer[i++] = value & All_Set_Element;
-          value = value >> Shift;
+          return false;
         }
+      }
 
-        // Clear the remaining elements.
-        while (i != number_of_elements)
-        {
-          pbuffer[i++] = All_Clear_Element;
-        }
+      // The last.
+      if ((*pbuffer & top_mask) != top_mask)
+      {
+        return false;
       }
-    }
 
-    //*************************************************************************
-    /// Swap bitset buffers.
-    //*************************************************************************
-    ETL_CONSTEXPR14 void swap(pointer pbuffer1, pointer pbuffer2, size_t number_of_elements)
-    {
-      const pointer pbuffer1_end = pbuffer1 + number_of_elements;
-
-      while (pbuffer1 != pbuffer1_end)
-      {
-        element_type temp = *pbuffer1;
-        *pbuffer1 = *pbuffer2;
-        *pbuffer2 = temp;
-        ++pbuffer1;
-        ++pbuffer2;
-      }
+      return true;
     }
-  };
- 
-  template <typename TElement>
-  ETL_CONSTANT size_t bitset_impl<TElement>::Bits_Per_Element;
-
-  template <typename TElement>
-  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Set_Element;
-
-  template <typename TElement>
-  ETL_CONSTANT typename bitset_impl<TElement>::element_type bitset_impl<TElement>::All_Clear_Element;
-
-  //***************************************************************************
-  template <size_t Active_Bits = 0U,
-            typename TElement = char,
-            bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
-  class bitset;
-
-  //***************************************************************************
-  /// Specialisation for zero bits.
-  /// Just defines 'npos'.
-  //***************************************************************************
-  template <>
-  class bitset<0U, char, true> : public bitset_constants<>
-  {
-  };
-
-  //***************************************************************************
-  /// Specialisation for zero bits.
-  //***************************************************************************
-  template <>
-  class bitset<0U, char, false> : public bitset_constants<>
-  {
-  };
-
-  //***************************************************************************
-  /// Specialisation that uses a single element if the element type is the 
-  /// same size as the number of active bits.
-  //***************************************************************************
-  template <size_t   Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, true> : public bitset_constants<>
-  {
-  public:
-
-    // The element type is the unsigned variant of 'TElement'.
-    typedef typename etl::make_unsigned<TElement>::type element_type;
-
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 1U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Bits_Per_Element;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<typename etl::make_unsigned<element_type>::type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = All_Set_Element;
-
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
 
     //*************************************************************************
-    /// The reference type returned.
+    /// Are none of the bits set?
     //*************************************************************************
-    class bit_reference
+    static
+    ETL_CONSTEXPR14
+    bool none(const_pointer pbuffer,
+              size_t        number_of_elements) ETL_NOEXCEPT
     {
-    public:
-
-      friend class bitset;
-
-      //*******************************
-      /// Copy constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
-        : p_bitset(other.p_bitset)
-        , position(other.position)
-      {
-      }
-
-      //*******************************
-      /// Conversion operator.
-      //*******************************
-      ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT
-      {
-        return p_bitset->test(position);
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, b);
-        return *this;
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, bool(r));
-        return *this;
-      }
-
-      //*******************************
-      /// Flip the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT
-      {
-        p_bitset->flip(position);
-        return *this;
-      }
-
-      //*******************************
-      /// Return the logical inverse of the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT
-      {
-        return !p_bitset->test(position);
-      }
-
-    private:
-
-      //*******************************
-      /// Default constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT
-        : p_bitset(ETL_NULLPTR)
-        , position(0)
-      {
-      }
-
-      //*******************************
-      /// Constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(bitset<Active_Bits, TElement, true>& r_bitset, size_t position_) ETL_NOEXCEPT
-        : p_bitset(&r_bitset)
-        , position(position_)
+      while (number_of_elements-- != 0)
       {
+        if (*pbuffer++ != 0)
+        {
+          return false;
+        }
       }
 
-      bitset<Active_Bits, TElement, true>* p_bitset; ///< The bitset.
-      size_t position; ///< The position in the bitset.
-    };
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-    }
-
-    //*************************************************************************
-    /// Copy constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-      : buffer(other.buffer)
-    {
-    }
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT
-      : buffer(element_type(value))
-    {
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT
-      : buffer(All_Clear_Element)
-    {
-      set(text);
+      return true;
     }
 
     //*************************************************************************
-    /// Assignment operator.
+    /// Are any of the bits set?
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    bool any(const_pointer pbuffer,
+             size_t        number_of_elements) ETL_NOEXCEPT
     {
-      buffer = other.buffer;
-
-      return *this;
-    }
+      bool any_set = false;
 
-    //*************************************************************************
-    /// Set all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set() ETL_NOEXCEPT
-    {
-      buffer = All_Set_Element;
+      while (number_of_elements-- != 0)
+      {
+        if (*pbuffer++ != All_Clear_Element)
+        {
+          any_set = true;
+          break;
+        }
+      }
 
-      return *this;
+      return any_set;
     }
 
     //*************************************************************************
-    /// Set from a value.
+    /// Set all bits
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(element_type value) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void set_all(pointer      pbuffer,
+                 size_t       number_of_elements,
+                 element_type top_mask) ETL_NOEXCEPT
     {
-      buffer = value;
+      while (number_of_elements-- != 1U)
+      {
+        *pbuffer++ = All_Set_Element;
+      }
 
-      return *this;
+      *pbuffer = (All_Set_Element & top_mask);
     }
 
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(size_t position, bool value = true)
+    static
+    ETL_CONSTEXPR14
+    void set_position(pointer pbuffer, 
+                      size_t  position, 
+                      bool    value = true) ETL_NOEXCEPT
     {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
+      size_t       index = position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
+
       if (value == true)
       {
-        buffer |= mask;
+        pbuffer[index] |= bit;
       }
       else
       {
-        buffer &= ~mask;
+        pbuffer[index] &= ~bit;
       }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char* text) ETL_NOEXCEPT
-    {      
-      from_string(text);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const wchar_t* text) ETL_NOEXCEPT
-    {
-      from_string(text);
-
-      return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char16_t* text) ETL_NOEXCEPT
+    template <size_t Position>
+    static
+    ETL_CONSTEXPR14
+    void set_position(pointer pbuffer,
+                      bool    value = true)
     {
-      from_string(text);
+      size_t       index = Position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit   = element_type(1) << (Position & (Bits_Per_Element - 1));
 
-      return *this;
+      if (value == true)
+      {
+        pbuffer[index] |= bit;
+      }
+      else
+      {
+        pbuffer[index] &= ~bit;
+      }
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& set(const char32_t* text) ETL_NOEXCEPT
+    template <size_t Position, bool Value>
+    static
+    ETL_CONSTEXPR14
+    void set_position(pointer pbuffer)
     {
-      from_string(text);
+      size_t       index = Position >> etl::log2<Bits_Per_Element>::value;
+      element_type bit = element_type(1) << (Position & (Bits_Per_Element - 1));
 
-      return *this;
+      if (Value == true)
+      {
+        pbuffer[index] |= bit;
+      }
+      else
+      {
+        pbuffer[index] &= ~bit;
+      }
     }
 
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14 
+    void from_string(pointer     pbuffer, 
+                     size_t      number_of_elements, 
+                     size_t      total_bits, 
+                     const char* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
-        reset();
+        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
       }
       else
       {
         size_t string_length = etl::strlen(text);
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
+        // Only reset elements we need to.
+        while (index != number_of_elements)
+        {
+          pbuffer[index++] = All_Clear_Element;
+        }
 
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
+        // Build from the string.
+        size_t i = etl::min(total_bits, string_length);
 
-        for (size_t i = 0U; i < string_length; ++i)
+        while (i > 0)
         {
-          if (text[i] == ETL_STR('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
+          set_position(pbuffer, --i, *text++ == ETL_STR('1'));
         }
       }
-
-      return *this;
     }
 
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void from_string(pointer        pbuffer, 
+                     size_t         number_of_elements, 
+                     size_t         total_bits, 
+                     const wchar_t* text) ETL_NOEXCEPT
     {
       if (text == ETL_NULLPTR)
       {
-        reset();
+        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
       }
       else
       {
         size_t string_length = etl::strlen(text);
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRL('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u16 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char16_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
+        // Only reset elements we need to.
+        while (index != number_of_elements)
         {
-          if (text[i] == ETL_STRu('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
+          pbuffer[index++] = All_Clear_Element;
         }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set from a u32 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& from_string(const char32_t* text) ETL_NOEXCEPT
-    {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
 
         // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRU('1'))
-          {
-            buffer |= mask;
-          }
-          else
-          {
-            buffer &= ~mask;
-          }
-
-          mask >>= 1U;
-        }
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Get as an integral value.
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
-    {
-      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small");
-
-      T v = T(0);
-
-      const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element;
-
-      if (OK)
-      {
-        v = T(typename etl::make_unsigned<T>::type(buffer));
-      }
-
-      return v;
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long>();
-    }
-
-    //*************************************************************************
-    /// Get as an unsigned long long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long long>();
-    }
-
-    //*************************************************************************
-    /// Reset all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& reset() ETL_NOEXCEPT
-    {
-      buffer = All_Clear_Element;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Reset the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& reset(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      buffer &= ~mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool test(size_t position) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
-
-      const element_type mask = element_type(element_type(1) << position);
-      return (buffer & mask) != 0U;
-    }
-
-    //*************************************************************************
-    /// The number of bits in the bitset.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
-    {
-      return Active_Bits;
-    }
-
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
-    {
-      return etl::count_bits(buffer);
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
-    {
-      return buffer == All_Set_Element;
-    }
-
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
-    {
-      return buffer == (All_Set_Element & mask);
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
-    {
-      return buffer == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
-    {
-      return (buffer & mask) == All_Clear_Element;
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
-    {
-      return !none();
-    }
-
-    //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
-    {
-      return !none(mask);
-    }
-
-    //*************************************************************************
-    /// Flip all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip() ETL_NOEXCEPT
-    {
-      buffer = ~buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip some of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip_bits(element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
-    {
-      buffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Flip the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& flip(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      buffer ^= mask;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Read [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        const element_type mask = element_type(element_type(1) << position);
-        return (buffer & mask) != 0U;
-      }
-
-      return false;
-    }
-
-    //*************************************************************************
-    /// Write [] operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT
-    {
-      return bit_reference(*this, position);
-    }
-
-    //*************************************************************************
-    /// Returns a string representing the bitset.
-    //*************************************************************************
-#if ETL_USING_CPP11
-    template <typename TString = etl::string<Active_Bits>>
-#else
-    template <typename TString>
-#endif
-    ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-                                      typename TString::value_type one  = typename TString::value_type('1')) const
-    {
-      TString result;
-
-      result.resize(Active_Bits, '\0');
-
-      // Check that the string type can contain the digits.
-      ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result);
-
-      for (size_t i = Active_Bits; i > 0; --i)
-      {
-        result[Active_Bits - i] = test(i - 1) ? one : zero;
-      }
+        size_t i = etl::min(total_bits, string_length);
 
-      return result;
-    }
-
-    //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
-    {
-      return find_next(state, 0U);
-    }
-
-    //*************************************************************************
-    /// Finds the next bit in the specified state.
-    ///\param state    The state to search for.
-    ///\param position The position to start from.
-    ///\returns The position of the bit or npos if none were found.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
-    {
-      if (position < Active_Bits)
-      {
-        // Where to start.
-        size_t bit = position;
-
-        element_type mask = 1U << position;
-
-        // Needs checking?
-        if ((state && (buffer != All_Clear_Element)) || (!state && (buffer != All_Set_Element)))
-        {
-          // For each bit in the element...
-          while (bit < Active_Bits)
-          {
-            // Equal to the required state?
-            if (((buffer & mask) != 0) == state)
-            {
-              return bit;
-            }
-
-            // Move on to the next bit.
-            mask <<= 1;
-            ++bit;
-          }
-        }
-      }
-
-      return npos;
-    }
-
-    //*************************************************************************
-    /// operator &
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator &(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp &= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator &=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator &=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer &= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator |
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator |(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp |= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator |=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator |=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer |= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ^
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator ^(const bitset<Active_Bits, TElement, true>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp ^= other;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator ^=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator ^=(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      buffer ^= other.buffer;
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ~
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator ~() const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp.flip();
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator <<
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator <<(size_t shift) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, true> temp(*this);
-
-      temp <<= shift;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator <<=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator <<=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        buffer <<= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator >>
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true> operator >>(size_t shift) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement> temp(*this);
-
-      temp >>= shift;
-
-      return temp;
-    }
-
-    //*************************************************************************
-    /// operator >>=
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, true>& operator >>=(size_t shift) ETL_NOEXCEPT
-    {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        buffer >>= shift;
-      }
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// operator ==
-    //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement, true>& lhs, const bitset<Active_Bits, TElement, true>& rhs) ETL_NOEXCEPT
-    {
-      return (lhs.buffer == rhs.buffer);
-    }
-
-    //*************************************************************************
-    /// swap
-    //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
-    {
-      element_type temp = buffer;
-      buffer = other.buffer;
-      other.buffer = temp;
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
-    {
-      return span_type(&buffer, 1);
-    }
-
-    //*************************************************************************
-    /// span
-    /// Returns a const span of the underlying buffer.
-    //*************************************************************************
-    ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT
-    {
-      return const_span_type(&buffer, 1);
-    }
-
-  private:
-
-    element_type buffer;
-  };
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Bits_Per_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Number_Of_Elements;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Allocated_Bits;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Set_Element;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::All_Clear_Element;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, true>::Top_Mask_Shift;
-
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, true>::element_type bitset<Active_Bits, TElement, true>::Top_Mask;
-
-  //*************************************************************************
-  /// The specialisation that uses an array of the default element type.
-  //*************************************************************************
-  template <size_t Active_Bits, typename TElement>
-  class bitset<Active_Bits, TElement, false> : public bitset_constants<>
-  {
-  private:
-
-    //*************************************************************************
-    // If the 'TElement' is the default 'void', then use 'char', otherwise uses
-    // the unsigned variant of 'TElement'.
-    //*************************************************************************
-    struct select_element_type
-    {
-      typedef typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
-    };  
-
-  public:
-
-    typedef typename select_element_type::type element_type;
-    typedef element_type*       pointer;
-    typedef const element_type* const_pointer;
-      
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::bitset_impl<element_type>::Bits_Per_Element;
-    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type All_Set_Element    = etl::bitset_impl<element_type>::All_Set_Element;
-    static ETL_CONSTANT element_type All_Clear_Element  = etl::bitset_impl<element_type>::All_Clear_Element;
-    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
-
-    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
-
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-
-    //*************************************************************************
-    /// The reference type returned.
-    //*************************************************************************
-    class bit_reference
-    {
-    public:
-
-      friend class bitset;
-
-      //*******************************
-      /// Copy constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT
-        : p_bitset(other.p_bitset)
-        , position(other.position)
-      {
-      }
-
-      //*******************************
-      /// Conversion operator.
-      //*******************************
-      ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT
-      {
-        return p_bitset->test(position);
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, b);
-        return *this;
-      }
-
-      //*******************************
-      /// Assignment operator.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT
-      {
-        p_bitset->set(position, bool(r));
-        return *this;
-      }
-
-      //*******************************
-      /// Flip the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT
-      {
-        p_bitset->flip(position);
-        return *this;
-      }
-
-      //*******************************
-      /// Return the logical inverse of the bit.
-      //*******************************
-      ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT
-      {
-        return !p_bitset->test(position);
-      }
-
-    private:
-
-      //*******************************
-      /// Default constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT
-        : p_bitset(ETL_NULLPTR)
-        , position(0)
-      {
-      }
-
-      //*******************************
-      /// Constructor.
-      //*******************************
-      ETL_CONSTEXPR14 bit_reference(bitset<Active_Bits, TElement>& r_bitset, size_t position_) ETL_NOEXCEPT
-        : p_bitset(&r_bitset)
-        , position(position_)
-      {
-      }
-
-      bitset<Active_Bits, TElement, false>* p_bitset; ///< The bitset.
-      size_t position; ///< The position in the bitset.
-    };
-
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
-      : buffer()
-    {
-      reset();
-    }
-
-    //*************************************************************************
-    /// Copy constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
-      : buffer()
-    {
-      etl::copy_n(other.buffer, Number_Of_Elements, buffer);
-    }
-
-    //*************************************************************************
-    /// Construct from a value.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT
-      : buffer()
-    {
-      ibitset.initialise(buffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT
-      : buffer()
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT
-      : buffer()
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT
-      : buffer()
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
-    }
-
-    //*************************************************************************
-    /// Construct from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT
-      : buffer()
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
-    }
-
-    //*************************************************************************
-    /// Assignment operator.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
-    {
-      etl::copy_n(other.buffer, Number_Of_Elements, buffer);
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set() ETL_NOEXCEPT
-    {
-      etl::fill_n(buffer, Number_Of_Elements, All_Set_Element);
-      clear_unused_bits_in_msb();
-
-      return *this;
-    }
-
-    //*************************************************************************
-    /// Set the bit at the position.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(size_t position, bool value = true)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-
-      ibitset.set(buffer, Number_Of_Elements, position, value);
-      clear_unused_bits_in_msb();
-      
-      return *this;
+        while (i > 0)
+        {
+          set_position(pbuffer, --i, *text++ == ETL_STRL('1'));
+        }
+      }
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void from_string(pointer         pbuffer, 
+                     size_t          number_of_elements, 
+                     size_t          total_bits, 
+                     const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+      if (text == ETL_NULLPTR)
+      {
+        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
+      }
+      else
+      {
+        size_t string_length = etl::strlen(text);
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
-      return *this;
-    }
+        // Only reset elements we need to.
+        while (index != number_of_elements)
+        {
+          pbuffer[index++] = All_Clear_Element;
+        }
 
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const wchar_t* text) ETL_NOEXCEPT
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+        // Build from the string.
+        size_t i = etl::min(total_bits, string_length);
 
-      return *this;
+        while (i > 0)
+        {
+          set_position(pbuffer, --i, *text++ == ETL_STRu('1'));
+        }
+      }
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char16_t* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void from_string(pointer         pbuffer, 
+                     size_t          number_of_elements, 
+                     size_t          total_bits, 
+                     const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+      if (text == ETL_NULLPTR)
+      {
+        etl::fill_n(pbuffer, number_of_elements, All_Clear_Element);
+      }
+      else
+      {
+        size_t string_length = etl::strlen(text);
+        size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element));
 
-      return *this;
-    }
+        // Only reset elements we need to.
+        while (index != number_of_elements)
+        {
+          pbuffer[index++] = All_Clear_Element;
+        }
 
-    //*************************************************************************
-    /// Set from a string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set(const char32_t* text) ETL_NOEXCEPT
-    {
-      ibitset.set(buffer, Number_Of_Elements, Active_Bits, text);
+        // Build from the string.
+        size_t i = etl::min(total_bits, string_length);
 
-      return *this;
+        while (i > 0)
+        {
+          set_position(pbuffer, --i, *text++ == ETL_STRU('1'));
+        }
+      }
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Reset all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void reset_all(pointer pbuffer,
+                   size_t  number_of_elements) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
-
-      return *this;
+      while (number_of_elements-- != 0U)
+      {
+        *pbuffer++ = All_Clear_Element;
+      }
     }
 
     //*************************************************************************
-    /// Set from a wide string.
+    /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void reset_position(pointer pbuffer, 
+                        size_t  position) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
+      const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1));
 
-      return *this;
+      pbuffer[index] &= ~bit;
     }
 
     //*************************************************************************
-    /// Set from a u16 string.
+    /// Get as a value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char16_t* text) ETL_NOEXCEPT
+    template <typename T>
+    static
+    ETL_CONSTEXPR14
+    T value(const_pointer pbuffer, 
+            size_t        number_of_elements) ETL_NOEXCEPT
     {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      T v = T(0);
 
-      return *this;
-    }
+      const bool OK = (sizeof(T) * CHAR_BIT) >= (number_of_elements * Bits_Per_Element);
 
-    //*************************************************************************
-    /// Set from a u32 string.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& from_string(const char32_t* text) ETL_NOEXCEPT
-    {
-      ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text);
+      if (OK)
+      {
+        uint_least8_t shift = 0U;
 
-      return *this;
+        for (size_t i = 0UL; i < number_of_elements; ++i)
+        {
+          v |= T(typename etl::make_unsigned<T>::type(pbuffer[i]) << shift);
+          shift += uint_least8_t(Bits_Per_Element);
+        }
+      }
+
+      return v;
     }
 
     //*************************************************************************
-    /// Get as an integral value.
+    /// Extract an value from multiple elements.
     //*************************************************************************
     template <typename T>
+    static
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
+    typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer,
+                                                                        int                 element_index,
+                                                                        size_t              active_bits_in_msb,
+                                                                        size_t              length) ETL_NOEXCEPT
     {
-      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return ibitset.template value<T>(buffer, Number_Of_Elements);
-    }
+      unsigned_t value(0);
 
-    //*************************************************************************
-    /// Get as an unsigned long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long>();
-    }
+      // Extract the first element, if partially filled.
+      if (active_bits_in_msb < Bits_Per_Element)
+      {
+        element_type mask = etl::make_lsb_mask< element_type>(active_bits_in_msb);
+        value = pbuffer[element_index] & mask;
+        length -= active_bits_in_msb;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
 
-    //*************************************************************************
-    /// Get as an unsigned long long.
-    //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
-    {
-      return value<unsigned long long>();
-    }
-    //*************************************************************************
-    /// Reset all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& reset() ETL_NOEXCEPT
-    {
-      etl::fill_n(buffer, Number_Of_Elements, All_Clear_Element);
+      // Loop through the fully filled elements
+      while (length >= Bits_Per_Element)
+      {
+        value |= pbuffer[element_index];
+        length -= Bits_Per_Element;
+        if (length >= Bits_Per_Element)
+        {
+          value = value << Bits_Per_Element;
+        }
+        --element_index;
+      }
 
-      return *this;
+      // Extract the last element, if partially filled.
+      if (length != 0)
+      {
+        value = value << length;
+        element_type mask = etl::make_lsb_mask< element_type>(length);
+        value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask;
+      }
+
+      return value;
     }
 
     //*************************************************************************
-    /// Reset the bit at the position.
+    /// Extract an integral value from an arbitrary position and length.
+    /// Run time position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& reset(size_t position)
+    template <typename T>
+    static
+    ETL_CONSTEXPR14
+    typename etl::make_unsigned<T>::type extract_from_buffer(const_pointer pbuffer, 
+                                                             size_t        position, 
+                                                             size_t        length) ETL_NOEXCEPT
     {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      ibitset.reset(buffer, Number_Of_Elements, position);
+      unsigned_t value(0);
 
-      return *this;
-    }
+      const int Msb_Element_Index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const int Lsb_Element_Index = position >> etl::log2<Bits_Per_Element>::value;
 
-    //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool test(size_t position) const
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
+      // Is the value contained within one element?
+      if (Msb_Element_Index == Lsb_Element_Index)
+      {
+        const unsigned_t Mask  = etl::make_lsb_mask< unsigned_t>(length);
+        const unsigned_t Shift = position % Bits_Per_Element;
 
-      return ibitset.test(buffer, Number_Of_Elements, position);
-    }
- 
-    //*************************************************************************
-    /// The number of bits in the bitset.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
-    {
-      return Active_Bits;
-    }
+        value = static_cast<unsigned_t>(pbuffer[Msb_Element_Index] >> Shift) & Mask;
+      }
+      else
+      {
+        // Get the number of active bits in the msb element 
+        size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element);
 
-    //*************************************************************************
-    /// Count the number of bits set.
-    //*************************************************************************
-    ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
-    {
-      return ibitset.count(buffer, Number_Of_Elements);
-    }
+        // Start with index of the element containing the msb.
+        int element_index = Msb_Element_Index;
 
-    //*************************************************************************
-    // Are all the bits sets?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
-    {
-      return ibitset.all(buffer, Number_Of_Elements, Top_Mask);
-    }
+        value = extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
+      }
 
-    //*************************************************************************
-    /// Are none of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
-    {
-      return ibitset.none(buffer, Number_Of_Elements);
+      return value;
     }
 
     //*************************************************************************
-    /// Are any of the bits set?
-    //*************************************************************************
-    ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
-    {
-      return !none();
-    }
- 
-    //*************************************************************************
-    /// Flip all of the bits.
+    /// Extract an integral value when the value fits in one element.
+    /// Compile time position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& flip() ETL_NOEXCEPT
+    template <typename T, size_t Position, size_t Length>
+    static
+    ETL_CONSTEXPR14
+    typename etl::enable_if<value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
+      extract_from_buffer(const_pointer pbuffer)
     {
-      ibitset.flip(buffer, Number_Of_Elements);
-      clear_unused_bits_in_msb();
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
 
-      return *this;
+      const int        Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
+      const unsigned_t Mask          = etl::lsb_mask<unsigned_t, Length>::value;
+      const unsigned_t Shift         = Position % Bits_Per_Element;
+      
+      return  static_cast<unsigned_t>(pbuffer[Element_Index] >> Shift) & Mask;
     }
 
     //*************************************************************************
-    /// Flip the bit at the position.
+    /// Extract an integral value when the value spans more than one element.
+    /// Compile time position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& flip(size_t position)
-    {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
+    template <typename T, size_t Position, size_t Length>
+    static
+    ETL_CONSTEXPR14
+    typename etl::enable_if<!value_is_in_one_element<Position, Length, Bits_Per_Element>::value, typename etl::make_unsigned<T>::type>::type
+      extract_from_buffer(const_pointer pbuffer)
+    {      
+      // Start with index of the element containing the msb.
+      const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
 
-      ibitset.flip(buffer, Number_Of_Elements, position);
+      // Get the number of active bits in the first element 
+      const size_t Active_Bits_In_Msb = ((Position + Length - 1) % Bits_Per_Element) + 1;
 
-      return *this;
+      return extract_from_multiple_elements<T>(pbuffer, Msb_Element_Index, Active_Bits_In_Msb, Length);
     }
 
     //*************************************************************************
-    /// Read [] operator.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
+    template <typename T>
+    static
+    ETL_CONSTEXPR14
+    T extract(const_pointer pbuffer,
+              size_t        position,
+              size_t        length = etl::integral_limits<T>::bits)
     {
-      return ibitset.test(buffer, Number_Of_Elements, position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = extract_from_buffer<unsigned_t>(pbuffer, position, length);
+
+      if ((length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
-    /// Write [] operator.
+    /// Extract an integral value from an arbitrary position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT
+    template <typename T, size_t Position, size_t Length>
+    static
+    ETL_CONSTEXPR14
+    T extract(const_pointer pbuffer)
     {
-      return bit_reference(*this, position);
+      typedef typename etl::make_unsigned<T>::type unsigned_t;
+
+      unsigned_t value = extract_from_buffer<unsigned_t, Position, Length>(pbuffer);
+
+      if ((Length != etl::integral_limits<T>::bits) && etl::integral_limits<T>::is_signed)
+      {
+        value = etl::sign_extend<T>(value, Length);
+      }
+
+      return static_cast<T>(value);
     }
 
     //*************************************************************************
-    /// Returns a string representing the bitset.
+    /// Flip all of the bits.
     //*************************************************************************
-#if ETL_USING_CPP11
-    template <typename TString = etl::string<Active_Bits>>
-#else
-    template <typename TString>
-#endif
-    ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-                                      typename TString::value_type one  = typename TString::value_type('1')) const
+    static
+    ETL_CONSTEXPR14
+    void flip_all(pointer pbuffer, 
+                     size_t  number_of_elements) ETL_NOEXCEPT
     {
-      return ibitset.template to_string<TString>(buffer, Number_Of_Elements, Active_Bits, zero, one);
+      operator_not(pbuffer, number_of_elements);
     }
 
     //*************************************************************************
-    /// Finds the first bit in the specified state.
-    ///\param state The state to search for.
-    ///\returns The position of the bit or npos if none were found.
+    /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void flip_position(pointer pbuffer, 
+                       size_t  position) ETL_NOEXCEPT
     {
-      return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, 0);
+      const size_t       index = position >> etl::log2<Bits_Per_Element>::value;;
+      const element_type bit   = element_type(1) << (position & (Bits_Per_Element - 1));
+
+      pbuffer[index] ^= bit;
     }
 
     //*************************************************************************
@@ -2184,331 +1465,486 @@ namespace etl
     ///\param position The position to start from.
     ///\returns The position of the bit or npos if none were found.
     //*************************************************************************
-    ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    size_t find_next(const_pointer pbuffer, 
+                     size_t        number_of_elements, 
+                     size_t        total_bits, 
+                     bool          state, 
+                     size_t        position) ETL_NOEXCEPT
     {
-      return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, position);
-    }
+      // Where to start.
+      size_t index = position >> log2<Bits_Per_Element>::value;
+      size_t bit   = position & (Bits_Per_Element - 1);
 
-    //*************************************************************************
-    /// operator &
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator &(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      element_type mask = 1 << bit;
+
+      // For each element in the bitset...
+      while (index < number_of_elements)
+      {
+        element_type value = pbuffer[index];
+
+        // Needs checking?
+        if ((state && (value != All_Clear_Element)) ||
+            (!state && (value != All_Set_Element)))
+        {
+          // For each bit in the element...
+          while ((bit < Bits_Per_Element) && (position < total_bits))
+          {
+            // Equal to the required state?
+            if (((value & mask) != 0) == state)
+            {
+              return position;
+            }
+
+            // Move on to the next bit.
+            mask <<= 1;
+            ++position;
+            ++bit;
+          }
+        }
+        else
+        {
+          position += (Bits_Per_Element - bit);
+        }
+
+        // Start at the beginning for all other elements.
+        bit = 0;
+        mask = 1;
 
-      temp &= other;
+        ++index;
+      }
 
-      return temp;
+      return npos;
     }
 
     //*************************************************************************
-    /// operator &=
+    /// Returns a string representing the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator &=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    template <typename TString>
+    static
+    ETL_CONSTEXPR14
+    TString to_string(const_pointer                pbuffer,
+                      size_t                       active_bits, 
+                      typename TString::value_type zero, 
+                      typename TString::value_type one)
     {
-      ibitset.and_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
+      TString result;
 
-      return *this;
-    }
+      result.resize(active_bits, '\0');
 
-    //*************************************************************************
-    /// operator |
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator |(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
-    {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
+      // Check that the string type can contain the digits.
+      ETL_ASSERT_OR_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result);      
 
-      temp |= other;
+      for (size_t i = active_bits; i > 0; --i)
+      {
+        result[active_bits - i] = test(pbuffer, i - 1) ? one : zero;
+      }
 
-      return temp;
+      return result;
     }
 
     //*************************************************************************
-    /// operator |=
+    /// operator assignment
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator |=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void operator_assignment(pointer       lhs_pbuffer, 
+                             const_pointer rhs_pbuffer, 
+                             size_t        number_of_elements) ETL_NOEXCEPT
     {
-      ibitset.or_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
-
-      return *this;
+      while (number_of_elements-- != 0)
+      {
+        *lhs_pbuffer = *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
+      }
     }
 
     //*************************************************************************
-    /// operator ^
+    /// operator and
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator ^(const bitset<Active_Bits, TElement, false>& other) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void operator_and(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        number_of_elements) ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
-
-      temp ^= other;
-
-      return temp;
+      while (number_of_elements-- != 0)
+      {
+        *lhs_pbuffer &= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
+      }
     }
 
     //*************************************************************************
-    /// operator ^=
+    /// operator or
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator ^=(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void operator_or(pointer       lhs_pbuffer, 
+                     const_pointer rhs_pbuffer, 
+                     size_t        number_of_elements) ETL_NOEXCEPT
     {
-      ibitset.xor_equals(&buffer[0], &other.buffer[0], Number_Of_Elements);
-
-      return *this;
+      while (number_of_elements-- != 0)
+      {
+        *lhs_pbuffer |= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
+      }
     }
 
     //*************************************************************************
-    /// operator ~
+    /// operator xor
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator ~() const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void operator_xor(pointer       lhs_pbuffer, 
+                      const_pointer rhs_pbuffer, 
+                      size_t        number_of_elements) ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
-
-      temp.flip();
-
-      return temp;
+      while (number_of_elements-- != 0)
+      {
+        *lhs_pbuffer ^= *rhs_pbuffer;
+        ++lhs_pbuffer;
+        ++rhs_pbuffer;
+      }
     }
 
     //*************************************************************************
-    /// operator <<
+    /// operator not
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator <<(size_t shift) const ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void operator_not(pointer pbuffer, 
+                      size_t  number_of_elements) ETL_NOEXCEPT
     {
-      etl::bitset<Active_Bits, TElement, false> temp(*this);
-
-      temp <<= shift;
-
-      return temp;
+      while (number_of_elements-- != 0)
+      {
+        *pbuffer = ~*pbuffer;
+        ++pbuffer;
+      }
     }
 
     //*************************************************************************
-    /// operator <<=
+    /// operator_shift_left
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator <<=(size_t shift) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void operator_shift_left(pointer pbuffer, 
+                             size_t  number_of_elements, 
+                             size_t  active_bits, 
+                             size_t  shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
+      if (shift >= active_bits)
       {
-        reset();
+        reset_all(pbuffer, number_of_elements);
       }
       else
       {
-        ibitset.shift_left_equals(buffer, Number_Of_Elements, shift);
-        clear_unused_bits_in_msb();
-      }
-      
-      return *this;
-    }
+        // The place where the elements are split when shifting.
+        const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element);
 
-    //*************************************************************************
-    /// operator >>
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false> operator >>(size_t shift) const ETL_NOEXCEPT
-    {
-      bitset<Active_Bits, TElement, false> temp(*this);
+        // Where we are shifting from.
+        int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U);
 
-      temp >>= shift;
+        // Where we are shifting to.
+        int dst_index = int(number_of_elements - 1U);
 
-      return temp;
+        // Shift control constants.
+        const size_t lsb_shift = Bits_Per_Element - split_position;
+        const size_t msb_shift = split_position;
+
+        const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+        const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
+        const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift);
+
+        // First lsb.
+        element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+        pbuffer[dst_index] = lsb;
+        --src_index;
+
+        // Now do the shifting.
+        while (src_index >= 0)
+        {
+          // Shift msb.
+          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+          pbuffer[dst_index] = pbuffer[dst_index] | msb;
+          --dst_index;
+
+          // Shift lsb.
+          lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+          pbuffer[dst_index] = lsb;
+          --src_index;
+        }
+
+        // Clear the remaining bits.
+        // First lsb.
+        pbuffer[dst_index] &= lsb_shifted_mask;
+
+        // The other remaining bytes on the right.
+        for (int i = 0; i < dst_index; ++i)
+        {
+          pbuffer[i] = 0;
+        }
+      }
     }
 
     //*************************************************************************
-    /// operator >>=
+    /// operator_shift_right
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& operator >>=(size_t shift) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void operator_shift_right(pointer pbuffer, 
+                              size_t  number_of_elements, 
+                              size_t  active_bits, 
+                              size_t  shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
+      if (shift >= active_bits)
       {
-        reset();
+        reset_all(pbuffer, number_of_elements);
       }
       else
       {
-        ibitset.shift_right_equals(buffer, Number_Of_Elements, shift);
-      }
+        // The place where the elements are split when shifting.
+        const size_t split_position = shift % Bits_Per_Element;
 
-      return *this;
-    }
+        // Where we are shifting from.
+        int src_index = int(shift / Bits_Per_Element);
 
-    //*************************************************************************
-    /// operator ==
-    //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement, false>& lhs, const bitset<Active_Bits, TElement, false>& rhs) ETL_NOEXCEPT
-    {
-      return etl::equal(lhs.buffer, 
-                        lhs.buffer + lhs.Number_Of_Elements,
-                        rhs.buffer);
+        // Where we are shifting to.
+        int dst_index = 0;
+
+        // Shift control constants.
+        const size_t lsb_shift = Bits_Per_Element - split_position;
+        const size_t msb_shift = split_position;
+
+        const element_type lsb_mask = element_type(etl::integral_limits<element_type>::max >> (Bits_Per_Element - split_position));
+        const element_type msb_mask = etl::integral_limits<element_type>::max - lsb_mask;
+        const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift);
+
+        // Now do the shifting.
+        while (src_index < int(number_of_elements - 1))
+        {
+          // Shift msb.
+          element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+          ++src_index;
+
+          // Shift lsb.
+          element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift);
+
+          // Combine them.
+          pbuffer[dst_index] = lsb | msb;
+          ++dst_index;
+        }
+
+        // Final msb.
+        element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift);
+        pbuffer[dst_index] = msb;
+
+        // Clear the remaining bits.
+        // First msb.
+        pbuffer[dst_index] &= msb_shifted_mask;
+        ++dst_index;
+
+        // The other remaining bytes.
+        while (dst_index < int(number_of_elements))
+        {
+          pbuffer[dst_index] = 0;
+          ++dst_index;
+        }
+      }
     }
 
     //*************************************************************************
-    /// swap
+    /// operator_equality
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    bool operator_equality(const_pointer lhs_pbuffer, 
+                           const_pointer rhs_pbuffer, 
+                           size_t        number_of_elements) ETL_NOEXCEPT
     {
-      ibitset.swap(buffer, other.buffer, Number_Of_Elements);
+      return etl::equal(lhs_pbuffer, lhs_pbuffer + number_of_elements, rhs_pbuffer);
     }
 
     //*************************************************************************
-    /// span
-    /// Returns a span of the underlying buffer.
+    /// Initialise from an unsigned long long.
+    /// Enabled if the number of bits in the element equals the number of bits in an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
+    template <typename TElementType>
+    static
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::integral_limits<TElementType>::bits == etl::integral_limits<unsigned long long>::bits, void>::type
+      initialise(pointer            pbuffer, 
+                 size_t             number_of_elements, 
+                 unsigned long long value) ETL_NOEXCEPT
     {
-      return span_type(buffer, Number_Of_Elements);
+      size_t i = 0UL;
+      
+      // Set the non-zero elements.
+      pbuffer[i++] = value;
+
+      // Clear the remaining elements.
+      while (i != number_of_elements)
+      {
+        pbuffer[i++] = All_Clear_Element;
+      }
     }
 
     //*************************************************************************
-    /// span
-    /// Returns a const span of the underlying buffer.
+    /// Initialise from an unsigned long long.
+    /// Enabled if the number of bits in the element doesn't equal the number of bits in an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT
+    template <typename TElementType>
+    static
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::integral_limits<TElementType>::bits != etl::integral_limits<unsigned long long>::bits, void>::type
+      initialise(pointer            pbuffer,
+                 size_t             number_of_elements,
+                 unsigned long long value) ETL_NOEXCEPT
     {
-      return const_span_type(buffer, Number_Of_Elements);
-    }
+      size_t i = 0UL;
 
-  private:
+      // Set the non-zero elements.
+      const unsigned long long Shift = etl::integral_limits<element_type>::bits;
+
+      while ((value != 0) && (i != number_of_elements))
+      {
+        pbuffer[i++] = value & All_Set_Element;
+        value = value >> Shift;
+      }
+
+      // Clear the remaining elements.
+      while (i != number_of_elements)
+      {
+        pbuffer[i++] = All_Clear_Element;
+      }
+    }
 
     //*************************************************************************
-    /// Correct the unused top bits after bit manipulation.
+    /// Swap bitset buffers.
     //*************************************************************************
-    ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT
+    static
+    ETL_CONSTEXPR14
+    void swap(pointer pbuffer1, 
+              pointer pbuffer2, 
+              size_t  number_of_elements)
     {
-      buffer[Number_Of_Elements - 1U] &= Top_Mask;
+      etl::swap_ranges(pbuffer1, pbuffer1 + number_of_elements, pbuffer2);
     }
-
-    etl::bitset_impl<element_type> ibitset;
-
-    element_type buffer[Number_Of_Elements > 0U ? Number_Of_Elements : 1U];
   };
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Bits_Per_Element;
+  namespace private_bitset
+  {
+    //***************************************************************************
+    template <size_t Active_Bits, typename TElement>
+    class bitset_common : public etl::private_bitset::bitset_impl_common<TElement>
+    {
+    public:
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Number_Of_Elements;
+      typedef typename etl::private_bitset::bitset_impl_common<TElement>::element_type element_type;
+      
+      using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
+      using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
+      using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Allocated_Bits;
+      static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
+      static ETL_CONSTANT size_t Size               = Active_Bits;
+      static ETL_CONSTANT size_t Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Set_Element;
+#if ETL_USING_CPP11
+      static ETL_CONSTANT etl::bitset_storage_model Storage_Model = (bitset_common<Active_Bits, TElement>::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+#else
+      static ETL_CONSTANT etl::bitset_storage_model Storage_Model;
+#endif
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::All_Clear_Element;
+      typedef etl::span<element_type,       Number_Of_Elements> span_type;
+      typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset<Active_Bits, TElement, false>::Top_Mask_Shift;
+    private:
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset<Active_Bits, TElement, false>::element_type bitset<Active_Bits, TElement, false>::Top_Mask;
+      static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - ((Number_Of_Elements * Bits_Per_Element) - Active_Bits)) % Bits_Per_Element);
 
-  //***************************************************************************
-  /// operator &
-  ///\ingroup bitset
-  //***************************************************************************
-  template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator & (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
-  {
-    bitset<Active_Bits> temp(lhs);
-    temp &= rhs;
-    return temp;
-  }
+    public:
 
-  //***************************************************************************
-  /// operator |
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator | (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
-  {
-    bitset<Active_Bits> temp(lhs);
-    temp |= rhs;
-    return temp;
-  }
+      static ETL_CONSTANT TElement Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+    };
 
-  //***************************************************************************
-  /// operator ^
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bitset<Active_Bits> operator ^ (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
-  {
-    bitset<Active_Bits> temp(lhs);
-    temp ^= rhs;
-    return temp;
-  }
 
-  //***************************************************************************
-  /// operator !=
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset<Active_Bits, TElement, IsSingleElement>& lhs, const bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
-  {
-    return !(lhs == rhs);
-  }
-}
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Number_Of_Elements;
 
-//*************************************************************************
-/// swap
-//*************************************************************************
-template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement, IsSingleElement>& lhs, etl::bitset<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
-{
-  lhs.swap(rhs);
-}
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Size;
+
+#if ETL_USING_CPP11
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model;
+#else
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model = (bitset_common<Active_Bits, TElement>::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
+#endif
 
-//***************************************************************************
-/// bitset_ext
-//***************************************************************************
-namespace etl
-{
-  //***************************************************************************
-  template <size_t Active_Bits = 0U,
-            typename TElement = char,
-            bool IsSingleElement = etl::integral_limits<TElement>::bits == Active_Bits>
-    class bitset_ext;
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Top_Mask_Shift;
+
+    template <size_t Active_Bits, typename TElement>
+    ETL_CONSTANT TElement bitset_common<Active_Bits, TElement>::Top_Mask;  
+  }
 
   //***************************************************************************
-  /// Specialisation for zero bits.
-  /// Just defines 'npos'.
+  /// Bitset forward declaration
   //***************************************************************************
-  template <>
-  class bitset_ext<0U, char, true> : public bitset_constants<>
-  {
-  };
+  template <size_t   Active_Bits = 0U,
+            typename TElement    = unsigned char>
+  class bitset;
 
   //***************************************************************************
   /// Specialisation for zero bits.
   //***************************************************************************
   template <>
-  class bitset_ext<0U, char, false> : public bitset_constants<>
+  class bitset<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
   {
+  public:
+
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
+
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
   };
 
-  //***************************************************************************
-  /// Specialisation that uses a single element if the element type is the 
-  /// same size as the number of active bits.
-  //***************************************************************************
-  template <size_t   Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, true> : public bitset_constants<>
+  //*************************************************************************
+  /// The bitset top level template.
+  //*************************************************************************
+  template <size_t Active_Bits, typename TElement>
+  class bitset : public etl::private_bitset::bitset_common<Active_Bits, TElement>
   {
   public:
 
-    // The element type is the unsigned variant of 'TElement'.
-    typedef typename etl::make_unsigned<TElement>::type element_type;
-
-    typedef element_type* pointer;
-    typedef const element_type* const_pointer;
+    ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
 
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::integral_limits<element_type>::bits;
-    static ETL_CONSTANT size_t       Number_Of_Elements = 1U;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Bits_Per_Element;
-    static ETL_CONSTANT element_type All_Set_Element    = etl::integral_limits<typename etl::make_unsigned<element_type>::type>::max;
-    static ETL_CONSTANT element_type All_Clear_Element  = element_type(0);
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = 0U;
-    static ETL_CONSTANT element_type Top_Mask           = All_Set_Element;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
 
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
-
-    typedef element_type buffer_type;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
 
     //*************************************************************************
     /// The reference type returned.
@@ -2517,7 +1953,7 @@ namespace etl
     {
     public:
 
-      friend class bitset_ext;
+      friend class bitset;
 
       //*******************************
       /// Copy constructor.
@@ -2585,459 +2021,413 @@ namespace etl
       //*******************************
       /// Constructor.
       //*******************************
-      ETL_CONSTEXPR14 bit_reference(bitset_ext<Active_Bits, TElement, true>& r_bitset, size_t position_) ETL_NOEXCEPT
+      ETL_CONSTEXPR14 bit_reference(bitset<Active_Bits, TElement>& r_bitset, size_t position_) ETL_NOEXCEPT
         : p_bitset(&r_bitset)
         , position(position_)
       {
       }
 
-      bitset_ext<Active_Bits, TElement, true>* p_bitset; ///< The bitset.
+      bitset<Active_Bits, TElement>* p_bitset; ///< The bitset.
       size_t position; ///< The position in the bitset.
     };
 
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
+    ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT
+      : buffer()
     {
-      *pbuffer = All_Clear_Element;
+      implementation::reset_all(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
-    /// Default constructor.
+    /// Copy constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
+    ETL_CONSTEXPR14 bitset(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
+      : buffer()
     {
-      *pbuffer = All_Clear_Element;
+      implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
-    /// Construct copy.
+    /// Construct from a value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
+    template <typename TValue>
+    ETL_CONSTEXPR14 bitset(TValue value, typename etl::enable_if<is_integral<TValue>::value>::type* = 0) ETL_NOEXCEPT
+      : buffer()
     {
-      *pbuffer = *other.pbuffer;
+      implementation::template initialise<element_type>(buffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
-    /// Construct copy.
+    /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const char*>::value>::type* = 0) ETL_NOEXCEPT
+      : buffer()
     {
-      *pbuffer = *other.pbuffer;
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
-    /// Copy Constructor (Deleted).
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT ETL_DELETE;
-
-    //*************************************************************************
-    /// Construct from a value.
+    /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const wchar_t*>::value>::type* = 0) ETL_NOEXCEPT
+      : buffer()
     {
-      *pbuffer = element_type(value);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
-    /// Construct from a value.
+    /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const char16_t*>::value>::type* = 0) ETL_NOEXCEPT
+      : buffer()
     {
-      *pbuffer = element_type(value);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset(TPString text, typename etl::enable_if<is_same<TPString, const char32_t*>::value>::type* = 0) ETL_NOEXCEPT
+      : buffer()
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Assignment operator.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
+    ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Set all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      implementation::set_all(buffer, Number_Of_Elements, Top_Mask);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
+    ETL_CONSTEXPR14
+    bitset<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
+
+      implementation::set_position(buffer, position, value);
+      
+      return *this;
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
+    template <size_t Position>
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(bool value = true)
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position>(buffer, value);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set()
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position, Value>(buffer);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) ETL_NOEXCEPT
-      : pbuffer(pbuffer_)
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(&buffer)
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      *pbuffer = All_Clear_Element;
-      set(text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Assignment operator.
+    /// Set from a char16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      *pbuffer = *other.pbuffer;
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set all of the bits.
+    /// Set from a char32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set() ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 
+    typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      *pbuffer = All_Set_Element;
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set the bit at the position.
+    /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(size_t position, bool value = true)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char* text) ETL_NOEXCEPT
     {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      if (value == true)
-      {
-        *pbuffer |= mask;
-      }
-      else
-      {
-        *pbuffer &= ~mask;
-      }
-      
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
+
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const wchar_t* text) ETL_NOEXCEPT
     {
-      from_string(text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char16_t* text) ETL_NOEXCEPT
     {
-      from_string(text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& from_string(const char32_t* text) ETL_NOEXCEPT
     {
-      from_string(text);
+      implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Get as an integral value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& set(const char32_t* text) ETL_NOEXCEPT
+    template <typename T>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_integral<T>::value, T>::type
+      value() const ETL_NOEXCEPT
     {
-      from_string(text);
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
+      ETL_STATIC_ASSERT(etl::integral_limits<T>::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
 
-      return *this;
+      return implementation::template value<T>(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Extract an integral value from an arbitrary position and length.
+    /// Run time position and length.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char* text) ETL_NOEXCEPT
+    template <typename T>
+    ETL_CONSTEXPR14
+    T extract(size_t position, size_t length = etl::integral_limits<T>::bits) const
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
 
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
 
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STR('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
+      return implementation::template extract<T>(buffer, position, length);
+    }
 
-          mask >>= 1U;
-        }
-      }
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Compile time position and length.
+    //*************************************************************************
+#if ETL_USING_CPP11    
+		template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+	  template <typename T, size_t Position, size_t Length>
+#endif
+    ETL_CONSTEXPR14
+    T extract() const
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value,              "Only integral types are supported");
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
 
-      return *this;
+      return implementation::template extract<T, Position, Length>(buffer);
     }
 
     //*************************************************************************
-    /// Set from a wide string.
+    /// Get as an unsigned long.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    unsigned long to_ulong() const
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
+      ETL_ASSERT(etl::integral_limits<unsigned long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
 
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
+      return implementation::template value<unsigned long>(buffer, Number_Of_Elements);
+    }
 
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
+    //*************************************************************************
+    /// Get as an unsigned long long.
+    //*************************************************************************
+    unsigned long long to_ullong() const
+    {
+      ETL_ASSERT(etl::integral_limits<unsigned long long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
 
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRL('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
+      return implementation::template value<unsigned long long>(buffer, Number_Of_Elements);
+    }
 
-          mask >>= 1U;
-        }
-      }
+    //*************************************************************************
+    /// Reset all of the bits.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& reset() ETL_NOEXCEPT
+    {
+      implementation::reset_all(buffer, Number_Of_Elements);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a u16 string.
+    /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& reset(size_t position)
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRu('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
+      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-          mask >>= 1U;
-        }
-      }
+      implementation::reset_position(buffer, position);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a u32 string.
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will return <b>false</b>.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& from_string(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bool test(size_t position) const
     {
-      if (text == ETL_NULLPTR)
-      {
-        reset();
-      }
-      else
-      {
-        size_t string_length = etl::strlen(text);
-
-        // Build from the string.
-        string_length = etl::min(Active_Bits, string_length);
-
-        element_type mask = element_type(element_type(1) << (string_length - 1U));
-
-        for (size_t i = 0U; i < string_length; ++i)
-        {
-          if (text[i] == ETL_STRU('1'))
-          {
-            *pbuffer |= mask;
-          }
-          else
-          {
-            *pbuffer &= ~mask;
-          }
+      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
 
-          mask >>= 1U;
-        }
-      }
+      return implementation::test(buffer, position);
+    }
+ 
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will not compile.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14 bool test() const
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
 
-      return *this;
+      return implementation::test(buffer, Position);
     }
 
     //*************************************************************************
-    /// Get as an integral value.
+    /// The number of bits in the bitset.
     //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
     {
-      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small");
-
-      T v = T(0);
-
-      const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element;
-
-      if (OK)
-      {
-        v = T(typename etl::make_unsigned<T>::type(*pbuffer));
-      }
-
-      return v;
+      return Active_Bits;
     }
 
     //*************************************************************************
-    /// Get as an unsigned long.
+    /// The number of storage elements in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
     {
-      return value<unsigned long>();
+      return Number_Of_Elements;
     }
 
     //*************************************************************************
-    /// Get as an unsigned long long.
+    /// The value of a set element.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
     {
-      return value<unsigned long long>();
+      return All_Set_Element;
     }
 
     //*************************************************************************
-    /// Reset all of the bits.
+    /// The value of a clear element.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& reset() ETL_NOEXCEPT
+    static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
     {
-      *pbuffer = All_Clear_Element;
-
-      return *this;
+      return All_Clear_Element;
     }
 
     //*************************************************************************
-    /// Reset the bit at the position.
+    /// The number of bits in an element.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& reset(size_t position)
+    static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
     {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      const element_type mask = element_type(element_type(1) << position);
-      *pbuffer &= ~mask;
-
-      return *this;
+      return Bits_Per_Element;
     }
 
     //*************************************************************************
-    /// Tests a bit at a position.
-    /// Positions greater than the number of configured bits will return <b>false</b>.
+    /// The mask for the msb element.
     //*************************************************************************
-    ETL_CONSTEXPR14 bool test(size_t position) const
+    static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
     {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
+      return Top_Mask;
+    }
 
-      const element_type mask = element_type(element_type(1) << position);
-      return (*pbuffer & mask) != 0U;
+    //*************************************************************************
+    /// The total number of bits of storage, including unused.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements * Bits_Per_Element;
     }
 
     //*************************************************************************
-    /// The number of bits in the bitset.
+    /// The storage model for the bitset.
+    /// etl::bitset_storage_model::Single
+    /// etl::bitset_storage_model::Multi
     //*************************************************************************
-    ETL_CONSTEXPR14  size_t size() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
     {
-      return Active_Bits;
+      return Storage_Model;
     }
 
     //*************************************************************************
@@ -3045,7 +2435,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
     {
-      return etl::count_bits(*pbuffer);
+      return implementation::count(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -3053,15 +2443,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
     {
-      return *pbuffer == All_Set_Element;
+      return implementation::all(buffer, Number_Of_Elements, Top_Mask);
     }
 
     //*************************************************************************
-    // Are all the bits sets?
+    // Are all the mask bits sets?
     //*************************************************************************
     ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
     {
-      return *pbuffer == (All_Set_Element & mask);
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::all(buffer, Number_Of_Elements, Top_Mask, mask);
     }
 
     //*************************************************************************
@@ -3069,15 +2461,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
     {
-      return *pbuffer == All_Clear_Element;
+      return implementation::none(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
-    /// Are none of the bits set?
+    /// Are none of the mask bits set?
     //*************************************************************************
     ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
     {
-      return (*pbuffer & mask) == All_Clear_Element;
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::none(buffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
@@ -3085,33 +2479,25 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
     {
-      return !none();
+      return implementation::any(buffer, Number_Of_Elements);
     }
-
+ 
     //*************************************************************************
-    /// Are any of the bits set?
+    /// Are any of the mask bits set?
     //*************************************************************************
     ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
     {
-      return !none(mask);
-    }
-
-    //*************************************************************************
-    /// Flip all of the bits.
-    //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip() ETL_NOEXCEPT
-    {
-      *pbuffer = ~*pbuffer;
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
 
-      return *this;
+      return implementation::any(buffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
-    /// Flip some of the bits.
+    /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip_bits(element_type mask = etl::integral_limits<element_type>::max) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      *pbuffer ^= mask;
+      implementation::flip_all(buffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3119,12 +2505,11 @@ namespace etl
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& flip(size_t position)
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& flip(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      const element_type mask = element_type(element_type(1) << position);
-      *pbuffer ^= mask;
+      implementation::flip_position(buffer, position);
 
       return *this;
     }
@@ -3134,13 +2519,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      if (position < Active_Bits)
-      {
-        const element_type mask = element_type(element_type(1) << position);
-        return (*pbuffer & mask) != 0U;
-      }
-
-      return false;
+      return implementation::test(buffer, position);
     }
 
     //*************************************************************************
@@ -3162,19 +2541,7 @@ namespace etl
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
                                       typename TString::value_type one  = typename TString::value_type('1')) const
     {
-      TString result;
-
-      result.resize(Active_Bits, '\0');
-
-      // Check that the string type can contain the digits.
-      ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result);
-
-      for (size_t i = Active_Bits; i > 0; --i)
-      {
-        result[Active_Bits - i] = test(i - 1) ? one : zero;
-      }
-
-      return result;
+      return implementation::template to_string<TString>(buffer, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -3184,7 +2551,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
     {
-      return find_next(state, 0U);
+      return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, 0);
     }
 
     //*************************************************************************
@@ -3195,94 +2562,140 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
     {
-      if (position < Active_Bits)
-      {
-        // Where to start.
-        size_t bit = position;
-
-        element_type mask = 1U << position;
+      return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, position);
+    }
 
-        // Needs checking?
-        if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element)))
-        {
-          // For each bit in the element...
-          while (bit < Active_Bits)
-          {
-            // Equal to the required state?
-            if (((*pbuffer & mask) != 0) == state)
-            {
-              return bit;
-            }
+    //*************************************************************************
+    /// operator &
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator &(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
+    {
+      etl::bitset<Active_Bits, TElement> temp(*this);
 
-            // Move on to the next bit.
-            mask <<= 1;
-            ++bit;
-          }
-        }
-      }
+      implementation::operator_and(temp.buffer, other.buffer, Number_Of_Elements);
 
-      return npos;
+      return temp;
     }
 
     //*************************************************************************
     /// operator &=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator &=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator &=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      *pbuffer &= *other.pbuffer;
+      implementation::operator_and(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
 
+    //*************************************************************************
+    /// operator |
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator |(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
+    {
+      etl::bitset<Active_Bits, TElement> temp(*this);
+
+      implementation::operator_or(temp.buffer, other.buffer, Number_Of_Elements);
+
+      return temp;
+    }
+
     //*************************************************************************
     /// operator |=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator |=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator |=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      *pbuffer |= *other.pbuffer;
+      implementation::operator_or(&buffer[0], &other.buffer[0], Number_Of_Elements);
 
       return *this;
     }
 
+    //*************************************************************************
+    /// operator ^
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator ^(const bitset<Active_Bits, TElement>& other) const ETL_NOEXCEPT
+    {
+      etl::bitset<Active_Bits, TElement> temp(*this);
+
+      implementation::operator_xor(temp.buffer, other.buffer, Number_Of_Elements);
+
+      return temp;
+    }
+
     //*************************************************************************
     /// operator ^=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator ^=(const bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator ^=(const bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      *pbuffer ^= *other.pbuffer;
+      implementation::operator_xor(buffer, other.buffer, Number_Of_Elements);
 
       return *this;
     }
 
+    //*************************************************************************
+    /// operator ~
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator ~() const ETL_NOEXCEPT
+    {
+      etl::bitset<Active_Bits, TElement> temp(*this);
+
+      implementation::flip_all(temp.buffer, Number_Of_Elements);
+
+      return temp;
+    }
+
+    //*************************************************************************
+    /// operator <<
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator <<(size_t shift) const ETL_NOEXCEPT
+    {
+      etl::bitset<Active_Bits, TElement> temp(*this);
+
+      implementation::operator_shift_left(temp.buffer, Number_Of_Elements, Active_Bits, shift);
+
+      return temp;
+    }
+
     //*************************************************************************
     /// operator <<=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator <<=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator <<=(size_t shift) ETL_NOEXCEPT
     {
       if (shift >= Active_Bits)
       {
-        reset();
+        implementation::reset_all(buffer, Number_Of_Elements);
       }
       else
       {
-        *pbuffer <<= shift;
+        implementation::operator_shift_left(buffer, Number_Of_Elements, Active_Bits, shift);
       }
-
+      
       return *this;
     }
 
+    //*************************************************************************
+    /// operator >>
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement> operator >>(size_t shift) const ETL_NOEXCEPT
+    {
+      bitset<Active_Bits, TElement> temp(*this);
+
+      implementation::operator_shift_right(temp.buffer, Number_Of_Elements, Active_Bits, shift);
+
+      return temp;
+    }
+
     //*************************************************************************
     /// operator >>=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, true>& operator >>=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& operator >>=(size_t shift) ETL_NOEXCEPT
     {
       if (shift >= Active_Bits)
       {
-        reset();
+        implementation::reset_all(buffer, Number_Of_Elements);
       }
       else
       {
-        *pbuffer >>= shift;
+        implementation::operator_shift_right(buffer, Number_Of_Elements, Active_Bits, shift);
       }
 
       return *this;
@@ -3291,19 +2704,25 @@ namespace etl
     //*************************************************************************
     /// operator ==
     //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement, true>& lhs, const bitset_ext<Active_Bits, TElement, true>& rhs) ETL_NOEXCEPT
+    friend ETL_CONSTEXPR14 bool operator ==(const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+    {
+      return implementation::operator_equality(lhs.buffer, rhs.buffer, lhs.Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// operator !=
+    //*************************************************************************
+    friend ETL_CONSTEXPR14 bool operator !=(const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
-      return (*lhs.pbuffer == *rhs.pbuffer);
+      return !(lhs == rhs);
     }
 
     //*************************************************************************
     /// swap
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      element_type temp = *pbuffer;
-      *pbuffer = *other.pbuffer;
-      *other.pbuffer = temp;
+      implementation::swap(buffer, other.buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -3312,7 +2731,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
     {
-      return span_type(pbuffer, 1);
+      return span_type(buffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -3321,72 +2740,130 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT
     {
-      return const_span_type(pbuffer, 1);
+      return const_span_type(buffer, Number_Of_Elements);
     }
 
   private:
 
-    element_type* pbuffer;
+    // The implementation of the bitset functionality.
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;
+
+    // The storage for the bitset.
+    element_type buffer[Number_Of_Elements];
   };
 
+  //***************************************************************************
+  /// operator &
+  ///\ingroup bitset
+  //***************************************************************************
   template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Bits_Per_Element;
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator & (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+  {
+    bitset<Active_Bits> temp(lhs);
+    temp &= rhs;
+    return temp;
+  }
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Number_Of_Elements;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Allocated_Bits;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Set_Element;
-    
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::All_Clear_Element;
-    
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, true>::Top_Mask_Shift;
-  
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, true>::element_type bitset_ext<Active_Bits, TElement, true>::Top_Mask;
+  //***************************************************************************
+  /// operator |
+  ///\ingroup bitset
+  //***************************************************************************
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator | (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+  {
+    bitset<Active_Bits> temp(lhs);
+    temp |= rhs;
+    return temp;
+  }
 
-  //*************************************************************************
-  /// The specialisation that uses an array of the default element type.
-  //*************************************************************************
-  template <size_t Active_Bits, typename TElement>
-  class bitset_ext<Active_Bits, TElement, false> : public bitset_constants<>
+  //***************************************************************************
+  /// operator ^
+  ///\ingroup bitset
+  //***************************************************************************
+  template<size_t Active_Bits, typename TElement>
+  ETL_CONSTEXPR14 bitset<Active_Bits> operator ^ (const bitset<Active_Bits, TElement>& lhs, const bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
   {
-  private:
+    bitset<Active_Bits> temp(lhs);
+    temp ^= rhs;
+    return temp;
+  }
+}
 
-    //*************************************************************************
-    // If the 'TElement' is the default 'void', then use 'char', otherwise uses
-    // the unsigned variant of 'TElement'.
-    //*************************************************************************
-    struct select_element_type
-    {
-      typedef typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
-    };
+//***************************************************************************
+/// operator !=
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 bool operator != (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//*************************************************************************
+/// swap
+//*************************************************************************
+template <size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 void swap(etl::bitset<Active_Bits, TElement>& lhs, etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  lhs.swap(rhs);
+}
+
+//***************************************************************************
+/// bitset_ext
+//***************************************************************************
+namespace etl
+{
+  //***************************************************************************
+  template <size_t Active_Bits = 0U,
+            typename TElement = unsigned char>
+  class bitset_ext;
 
+  //***************************************************************************
+  /// Specialisation for zero bits.
+  //***************************************************************************
+  template <>
+  class bitset_ext<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
+  {
   public:
 
-    typedef typename select_element_type::type element_type;
-    typedef element_type* pointer;
-    typedef const element_type* const_pointer;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type    element_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type       span_type;
+    typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
+
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
+    using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
+  };
 
-    static ETL_CONSTANT size_t       Bits_Per_Element   = etl::bitset_impl<element_type>::Bits_Per_Element;
-    static ETL_CONSTANT size_t       Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
-    static ETL_CONSTANT size_t       Allocated_Bits     = Number_Of_Elements * Bits_Per_Element;
-    static ETL_CONSTANT size_t       Top_Mask_Shift     = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
-    static ETL_CONSTANT element_type All_Set_Element    = etl::bitset_impl<element_type>::All_Set_Element;
-    static ETL_CONSTANT element_type All_Clear_Element  = etl::bitset_impl<element_type>::All_Clear_Element;
-    static ETL_CONSTANT element_type Top_Mask           = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
+  //*************************************************************************
+  /// A bitset that uses externally declared storage.
+  //*************************************************************************
+  template <size_t Active_Bits, typename TElement>
+  class bitset_ext : public etl::private_bitset::bitset_common<Active_Bits, TElement>
+  {
+  public:
 
-    static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
+    ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
 
-    typedef etl::span<element_type, Number_Of_Elements>       span_type;
-    typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type    element_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type       span_type;
+    typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
+    
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
+    using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
 
-    typedef etl::array<element_type, Number_Of_Elements> buffer_type;
+    typedef etl::array<TElement, Number_Of_Elements> buffer_type;
 
     //*************************************************************************
     /// The reference type returned.
@@ -3469,168 +2946,200 @@ namespace etl
       {
       }
 
-      bitset_ext<Active_Bits, TElement, false>* p_bitset; ///< The bitset.
+      bitset_ext<Active_Bits, TElement>* p_bitset; ///< The bitset.
       size_t position; ///< The position in the bitset.
     };
 
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(element_type* pbuffer_) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 explicit bitset_ext(element_type* pbuffer_)
       : pbuffer(pbuffer_)
     {
-      reset();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::reset_all(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 explicit bitset_ext(buffer_type& buffer)
       : pbuffer(buffer.data())
     {
-      reset();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::reset_all(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Construct copy.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, element_type* pbuffer_) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other, element_type* pbuffer_)
       : pbuffer(pbuffer_)
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Construct copy.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, buffer_type& buffer) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other, buffer_type& buffer) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Copy Constructor (Deleted).
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT ETL_DELETE;
+    ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT ETL_DELETE;
 
     //*************************************************************************
     /// Construct from a value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_)
       : pbuffer(pbuffer_)
     {
-      ibitset.initialise(pbuffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::template initialise<element_type>(pbuffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
     /// Construct from a value.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TValue>
+    ETL_CONSTEXPR14 bitset_ext(TValue value, buffer_type& buffer, typename etl::enable_if<is_integral<TValue>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.initialise(pbuffer, Number_Of_Elements, value);
-      clear_unused_bits_in_msb();
+      implementation::template initialise<element_type>(pbuffer, Number_Of_Elements, value);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const char*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const char*>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const wchar_t*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const wchar_t*>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const char16_t*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const char16_t*>::value>::type* = 0) ETL_NOEXCEPT
       : pbuffer(buffer.data())
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
     }
 
     //*************************************************************************
     /// Construct from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, element_type* pbuffer_, typename etl::enable_if<is_same<TPString, const char32_t*>::value>::type* = 0)
       : pbuffer(pbuffer_)
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+    }
+
+    //*************************************************************************
+    /// Construct from a string.
+    //*************************************************************************
+    template <typename TPString>
+    ETL_CONSTEXPR14 bitset_ext(TPString text, buffer_type& buffer, typename etl::enable_if<is_same<TPString, const char32_t*>::value>::type* = 0) ETL_NOEXCEPT
+      : pbuffer(buffer.data())
+    {
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+    }
+
+    //*************************************************************************
+    /// Assignment operator.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
+    {
+      implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Construct from a string.
+    /// Set all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT
-      : pbuffer(buffer.data())
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set() ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
-      clear_unused_bits_in_msb();
+      implementation::set_all(pbuffer, Number_Of_Elements, Top_Mask);
+
+      return *this;
     }
 
     //*************************************************************************
-    /// Assignment operator.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14
+      bitset_ext<Active_Bits, TElement>& set(size_t position, bool value = true)
     {
-      etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
+      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
+
+      implementation::set_position(pbuffer, position, value);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set all of the bits.
+    /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set() ETL_NOEXCEPT
+    template <size_t Position>
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(bool value = true)
     {
-      etl::fill_n(pbuffer, Number_Of_Elements, All_Set_Element);
-      clear_unused_bits_in_msb();
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position>(pbuffer, value);
 
       return *this;
     }
@@ -3638,12 +3147,12 @@ namespace etl
     //*************************************************************************
     /// Set the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(size_t position, bool value = true)
+    template <size_t Position, bool Value>
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set()
     {
-      ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
-      
-      ibitset.set(pbuffer, Number_Of_Elements, position, value);
-      clear_unused_bits_in_msb();
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      implementation::template set_position<Position, Value>(pbuffer);
 
       return *this;
     }
@@ -3651,39 +3160,51 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const wchar_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a char16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char16_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
 
     //*************************************************************************
-    /// Set from a string.
+    /// Set from a char32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& set(const char32_t* text) ETL_NOEXCEPT
+    template <typename TPString>
+    ETL_CONSTEXPR14
+    typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
+      set(TPString text) ETL_NOEXCEPT
     {
-      ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3691,9 +3212,9 @@ namespace etl
     //*************************************************************************
     /// Set from a string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3701,9 +3222,9 @@ namespace etl
     //*************************************************************************
     /// Set from a wide string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const wchar_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const wchar_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3711,9 +3232,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u16 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char16_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char16_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3721,9 +3242,9 @@ namespace etl
     //*************************************************************************
     /// Set from a u32 string.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& from_string(const char32_t* text) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& from_string(const char32_t* text) ETL_NOEXCEPT
     {
-      ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
+      implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
 
       return *this;
     }
@@ -3733,36 +3254,75 @@ namespace etl
     //*************************************************************************
     template <typename T>
     ETL_CONSTEXPR14
-      typename etl::enable_if<etl::is_integral<T>::value, T>::type
-      value() const ETL_NOEXCEPT
+    T value() const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
+      ETL_STATIC_ASSERT(etl::integral_limits<T>::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
+
+      return implementation::template value<T>(pbuffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Run time position and length.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14
+      T extract(size_t position, size_t length = etl::integral_limits<T>::bits)
     {
       ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
-      ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small");
 
-      return ibitset.template value<T>(pbuffer, Number_Of_Elements);
+      ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits<T>::bits, ETL_ERROR(bitset_overflow), 0);
+      ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits,      ETL_ERROR(bitset_overflow), 0);
+
+      return implementation::template extract<T>(pbuffer, position, length);
+    }
+
+    //*************************************************************************
+    /// Extract an integral value from an arbitrary position and length.
+    /// Compile time position and length.
+    //*************************************************************************
+#if ETL_USING_CPP11
+    template <typename T, size_t Position, size_t Length = etl::integral_limits<T>::bits>
+#else
+    template <typename T, size_t Position, size_t Length>
+#endif
+    ETL_CONSTEXPR14
+    T extract() const
+    {
+      ETL_STATIC_ASSERT(etl::is_integral<T>::value,              "Only integral types are supported");
+      ETL_STATIC_ASSERT(Length <= etl::integral_limits<T>::bits, "Length is larger that the required type");
+      ETL_STATIC_ASSERT((Position + Length) <= Active_Bits,      "Position/Length overflows bitset");
+
+      return implementation::template extract<T, Position, Length>(pbuffer);
     }
 
     //*************************************************************************
     /// Get as an unsigned long.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT
+    unsigned long to_ulong() const
     {
-      return value<unsigned long>();
+      ETL_ASSERT(etl::integral_limits<unsigned long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
+
+      return implementation::template value<unsigned long>(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
     /// Get as an unsigned long long.
     //*************************************************************************
-    ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT
+    unsigned long long to_ullong() const
     {
-      return value<unsigned long long>();
+      ETL_ASSERT(etl::integral_limits<unsigned long long>::bits >= Active_Bits, ETL_ERROR(etl::bitset_overflow));
+
+      return implementation::template value<unsigned long long>(pbuffer, Number_Of_Elements);
     }
+
     //*************************************************************************
     /// Reset all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& reset() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& reset() ETL_NOEXCEPT
     {
-      etl::fill_n(pbuffer, Number_Of_Elements, All_Clear_Element);
+      implementation::reset_all(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3770,11 +3330,11 @@ namespace etl
     //*************************************************************************
     /// Reset the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& reset(size_t position)
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& reset(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
 
-      ibitset.reset(pbuffer, Number_Of_Elements, position);
+      implementation::reset_position(pbuffer, position);
 
       return *this;
     }
@@ -3787,23 +3347,93 @@ namespace etl
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false);
       
-      return ibitset.test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, position);
+    }
+
+    //*************************************************************************
+    /// Tests a bit at a position.
+    /// Positions greater than the number of configured bits will not compile.
+    //*************************************************************************
+    template <size_t Position>
+    ETL_CONSTEXPR14 bool test() const
+    {
+      ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
+
+      return implementation::test(pbuffer, Position);
     }
 
     //*************************************************************************
     /// The number of bits in the bitset.
     //*************************************************************************
-    ETL_CONSTEXPR14  size_t size() const ETL_NOEXCEPT
+    static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
     {
       return Active_Bits;
     }
 
+    //*************************************************************************
+    /// The number of storage elements in the bitset.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements;
+    }
+
+    //*************************************************************************
+    /// The value of a set element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
+    {
+      return All_Set_Element;
+    }
+
+    //*************************************************************************
+    /// The value of a clear element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
+    {
+      return All_Clear_Element;
+    }
+
+    //*************************************************************************
+    /// The mask for the msb element.
+    //*************************************************************************
+    static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
+    {
+      return Top_Mask;
+    }
+
+    //*************************************************************************
+    /// The number of bits in an element.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
+    {
+      return Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The total number of bits of storage, including unused.
+    //*************************************************************************
+    static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
+    {
+      return Number_Of_Elements * Bits_Per_Element;
+    }
+
+    //*************************************************************************
+    /// The storage model for the bitset.
+    /// etl::bitset_storage_model::Single
+    /// etl::bitset_storage_model::Multi
+    //*************************************************************************
+    static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
+    {
+      return Storage_Model;
+    }
+
     //*************************************************************************
     /// Count the number of bits set.
     //*************************************************************************
     ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT
     {
-      return ibitset.count(pbuffer, Number_Of_Elements);
+      return implementation::count(pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -3811,7 +3441,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT
     {
-      return ibitset.all(pbuffer, Number_Of_Elements, Top_Mask);
+      return implementation::all(pbuffer, Number_Of_Elements, Top_Mask);
+    }
+
+    //*************************************************************************
+    // Are all the mask bits sets?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::all(pbuffer, Number_Of_Elements, Top_Mask, mask);
     }
 
     //*************************************************************************
@@ -3819,7 +3459,17 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT
     {
-      return ibitset.none(pbuffer, Number_Of_Elements);
+      return implementation::none(pbuffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Are none of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::none(pbuffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
@@ -3827,16 +3477,25 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT
     {
-      return !none();
+      return implementation::any(pbuffer, Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// Are any of the mask bits set?
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT
+    {
+      ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model");
+
+      return implementation::any(pbuffer, Number_Of_Elements, mask);
     }
 
     //*************************************************************************
     /// Flip all of the bits.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& flip() ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& flip() ETL_NOEXCEPT
     {
-      ibitset.flip(pbuffer, Number_Of_Elements);
-      clear_unused_bits_in_msb();
+      implementation::flip_all(pbuffer, Number_Of_Elements);
 
       return *this;
     }
@@ -3844,11 +3503,11 @@ namespace etl
     //*************************************************************************
     /// Flip the bit at the position.
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& flip(size_t position)
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& flip(size_t position)
     {
       ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
       
-      ibitset.flip(pbuffer, Number_Of_Elements, position);
+      implementation::flip_position(pbuffer, position);
 
       return *this;
     }
@@ -3858,7 +3517,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.test(pbuffer, Number_Of_Elements, position);
+      return implementation::test(pbuffer, position);
     }
 
     //*************************************************************************
@@ -3878,9 +3537,9 @@ namespace etl
     template <typename TString>
 #endif
     ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'),
-      typename TString::value_type one = typename TString::value_type('1')) const
+                                      typename TString::value_type one  = typename TString::value_type('1')) const
     {
-      return ibitset.template to_string<TString>(pbuffer, Number_Of_Elements, Active_Bits, zero, one);
+      return implementation::template to_string<TString>(pbuffer, Active_Bits, zero, one);
     }
 
     //*************************************************************************
@@ -3890,7 +3549,7 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0);
+      return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0);
     }
 
     //*************************************************************************
@@ -3901,15 +3560,15 @@ namespace etl
     //*************************************************************************
     ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT
     {
-      return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position);
+      return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position);
     }
 
     //*************************************************************************
     /// operator &=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator &=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator &=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.and_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_and(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -3917,9 +3576,9 @@ namespace etl
     //*************************************************************************
     /// operator |=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator |=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator |=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.or_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -3927,9 +3586,9 @@ namespace etl
     //*************************************************************************
     /// operator ^=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator ^=(const bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator ^=(const bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.xor_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
+      implementation::operator_xor(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements);
 
       return *this;
     }
@@ -3937,17 +3596,9 @@ namespace etl
     //*************************************************************************
     /// operator <<=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator <<=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator <<=(size_t shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        ibitset.shift_left_equals(pbuffer, Number_Of_Elements, shift);
-        clear_unused_bits_in_msb();
-      }
+      implementation::operator_shift_left(pbuffer, Number_Of_Elements, Active_Bits, shift);
 
       return *this;
     }
@@ -3955,16 +3606,9 @@ namespace etl
     //*************************************************************************
     /// operator >>=
     //*************************************************************************
-    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement, false>& operator >>=(size_t shift) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& operator >>=(size_t shift) ETL_NOEXCEPT
     {
-      if (shift >= Active_Bits)
-      {
-        reset();
-      }
-      else
-      {
-        ibitset.shift_right_equals(pbuffer, Number_Of_Elements, shift);
-      }
+      implementation::operator_shift_right(pbuffer, Number_Of_Elements, Active_Bits, shift);
 
       return *this;
     }
@@ -3972,19 +3616,25 @@ namespace etl
     //*************************************************************************
     /// operator ==
     //*************************************************************************
-    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement, false>& lhs, const bitset_ext<Active_Bits, TElement, false>& rhs) ETL_NOEXCEPT
+    friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+    {
+      return implementation::operator_equality(lhs.pbuffer, rhs.pbuffer, lhs.Number_Of_Elements);
+    }
+
+    //*************************************************************************
+    /// operator !=
+    //*************************************************************************
+    friend ETL_CONSTEXPR14 bool operator !=(const bitset_ext<Active_Bits, TElement>& lhs, const bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
     {
-      return etl::equal(lhs.pbuffer,
-        lhs.pbuffer + lhs.Number_Of_Elements,
-        rhs.pbuffer);
+      return !(lhs == rhs);
     }
 
     //*************************************************************************
     /// swap
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement>& other) ETL_NOEXCEPT
     {
-      ibitset.swap(pbuffer, other.pbuffer, Number_Of_Elements);
+      implementation::swap(pbuffer, other.pbuffer, Number_Of_Elements);
     }
 
     //*************************************************************************
@@ -4007,59 +3657,301 @@ namespace etl
 
   private:
 
+    // The implementation of the bitset functionality.
+    typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;
+
+    // Pointer to the storage for the bitset.
+    element_type* pbuffer;
+  };
+}
+
+//***************************************************************************
+/// operator !=
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 bool operator != (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//*************************************************************************
+/// swap
+//*************************************************************************
+template <size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement>& lhs, etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  lhs.swap(rhs);
+}
+
+namespace etl
+{
+  namespace private_bitset
+  {
     //*************************************************************************
-    /// Correct the unused top bits after bit manipulation.
+    /// Compare bitset spans.
+    /// Assumes that the lhs span's element type is larger than rhs's.
     //*************************************************************************
-    ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT
+    template <typename TLhsSpan, typename TRhsSpan>
+    bool compare_bitset_spans(const TLhsSpan& lhs_span, const TRhsSpan& rhs_span)
     {
-      pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
+      typedef typename TLhsSpan::value_type lhs_element_t;
+      typedef typename TRhsSpan::value_type rhs_element_t;
+
+      const int steps = static_cast<int>(sizeof(lhs_element_t) / sizeof(rhs_element_t));
+
+      typename TLhsSpan::iterator lhs_itr = lhs_span.begin();
+      typename TRhsSpan::iterator rhs_itr = rhs_span.begin();
+
+      while (lhs_itr != lhs_span.end())
+      {
+        const lhs_element_t& lhs_value = *lhs_itr;
+
+        // Build the rhs element in terms of the lhs element type.
+        lhs_element_t rhs_value = 0;
+
+        const int shift_step = etl::integral_limits<rhs_element_t>::bits;
+        int shift = 0;
+
+        for (int i = 0; i < steps; ++i)
+        {
+          rhs_value |= (static_cast<lhs_element_t>(*rhs_itr) << shift);
+          ++rhs_itr;
+          shift += shift_step;
+        }
+
+        if (lhs_value != rhs_value)
+        {
+          return false;
+        }
+
+        ++lhs_itr;
+      }
+
+      return true;
     }
+  }
+}
 
-    etl::bitset_impl<element_type> ibitset;
-    element_type* pbuffer;
-  };
+//***************************************************************************
+/// operator ==
+/// bitset 
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Bits_Per_Element;
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Number_Of_Elements;
+//***************************************************************************
+/// operator !=
+/// bitset 
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Allocated_Bits;
+//***************************************************************************
+/// operator ==
+/// bitset_ext
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset_ext<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Set_Element;
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
+}
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::All_Clear_Element;
+//***************************************************************************
+/// operator !=
+/// bitset_ext
+/// Different element types
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT size_t bitset_ext<Active_Bits, TElement, false>::Top_Mask_Shift;
+//***************************************************************************
+/// operator ==
+/// bitset compared with bitset_ext, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator == (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  const char   Storage_Model      = etl::bitset<Active_Bits, TElement>::Storage_Model;
+  const size_t Number_Of_Elements = etl::bitset<Active_Bits, TElement>::Number_Of_Elements;
 
-  template <size_t Active_Bits, typename TElement>
-  ETL_CONSTANT typename bitset_ext<Active_Bits, TElement, false>::element_type bitset_ext<Active_Bits, TElement, false>::Top_Mask;
+  typename etl::bitset<Active_Bits, TElement>::const_span_type     lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TElement>::const_span_type rhs_span = rhs.span();
 
-  //***************************************************************************
-  /// operator !=
-  ///\ingroup bitset
-  //***************************************************************************
-  template<size_t Active_Bits, typename TElement, bool IsSingleElement>
-  ETL_CONSTEXPR14 bool operator != (const bitset_ext<Active_Bits, TElement, IsSingleElement>& lhs, const bitset_ext<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+  typedef etl::bitset_impl<TElement, Storage_Model> implementation;
+
+  return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements);
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset compared with bitset_ext, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator != (const etl::bitset<Active_Bits, TElement>& lhs, const etl::bitset_ext<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext compared with bitset, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator == (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  const char   Storage_Model      = etl::bitset<Active_Bits, TElement>::Storage_Model;
+  const size_t Number_Of_Elements = etl::bitset<Active_Bits, TElement>::Number_Of_Elements;
+
+  typename etl::bitset_ext<Active_Bits, TElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TElement>::const_span_type     rhs_span = rhs.span();
+
+  typedef etl::bitset_impl<TElement, Storage_Model> implementation;
+
+  return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements);
+}
+
+//***************************************************************************
+/// operator !=
+/// bitset_ext compared with bitset, same element types.
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TElement>
+ETL_CONSTEXPR14
+bool operator != (const etl::bitset_ext<Active_Bits, TElement>& lhs, const etl::bitset<Active_Bits, TElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset compared with bitset_ext, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+operator == (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset<Active_Bits, TLhsElement>::const_span_type     lhs_span = lhs.span();
+  typename etl::bitset_ext<Active_Bits, TRhsElement>::const_span_type rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
   {
-    return !(lhs == rhs);
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
   }
 }
 
-//*************************************************************************
-/// swap
-//*************************************************************************
-template <size_t Active_Bits, typename TElement, bool IsSingleElement>
-ETL_CONSTEXPR14 void swap(etl::bitset_ext<Active_Bits, TElement, IsSingleElement>& lhs, etl::bitset_ext<Active_Bits, TElement, IsSingleElement>& rhs) ETL_NOEXCEPT
+//***************************************************************************
+/// operator !=
+/// bitset compared with bitset_ext, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset<Active_Bits, TLhsElement>& lhs, const etl::bitset_ext<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
 {
-  lhs.swap(rhs);
+  return !(lhs == rhs);
+}
+
+//***************************************************************************
+/// operator ==
+/// bitset_ext compared with bitset, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator == (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  // Get a span of each type.
+  typename etl::bitset_ext<Active_Bits, TLhsElement>::const_span_type lhs_span = lhs.span();
+  typename etl::bitset<Active_Bits, TRhsElement>::const_span_type     rhs_span = rhs.span();
+
+  // Put the bitset with the largest element type as the first argument.
+  if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement))
+  {
+    return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span);
+  }
+  else
+  {
+    return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span);
+  }
 }
 
+//***************************************************************************
+/// operator !=
+/// bitset_ext compared with bitset, different element types. 
+///\ingroup bitset
+//***************************************************************************
+template<size_t Active_Bits, typename TLhsElement, typename TRhsElement>
+ETL_CONSTEXPR14
+typename etl::enable_if<!etl::is_same<TLhsElement, TRhsElement>::value, bool>::type
+  operator != (const etl::bitset_ext<Active_Bits, TLhsElement>& lhs, const etl::bitset<Active_Bits, TRhsElement>& rhs) ETL_NOEXCEPT
+{
+  return !(lhs == rhs);
+}
 
 #include "minmax_pop.h"
 
diff --git a/src/etl/private/crc_parameters.h b/src/etl/private/crc_parameters.h
index 72cd1ef..705684c 100644
--- a/src/etl/private/crc_parameters.h
+++ b/src/etl/private/crc_parameters.h
@@ -79,6 +79,8 @@ namespace etl
     typedef crc_parameters<uint8_t, 0x07U, 0x00U, 0x55U, false> crc8_itu_parameters;
     typedef crc_parameters<uint8_t, 0x31U, 0x00U, 0x00U, true>  crc8_maxim_parameters;
     typedef crc_parameters<uint8_t, 0x9BU, 0x00U, 0x00U, true>  crc8_wcdma_parameters;
+    typedef crc_parameters<uint8_t, 0x1DU, 0xFFU, 0xFFU, false> crc8_j1850_parameters;
+    typedef crc_parameters<uint8_t, 0x1DU, 0x00U, 0x00U, false> crc8_j1850_zero_parameters;
 
     // 16 bit.
     typedef crc_parameters<uint16_t, 0x8005U, 0x0000U, 0x0000U, true>  crc16_parameters;
diff --git a/src/etl/private/diagnostic_null_dereference_push.h b/src/etl/private/diagnostic_null_dereference_push.h
new file mode 100644
index 0000000..3f48168
--- /dev/null
+++ b/src/etl/private/diagnostic_null_dereference_push.h
@@ -0,0 +1,44 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2024 John Wellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+
+/*
+ * The header include guard has been intentionally omitted.
+ * This file is intended to evaluated multiple times by design.
+ */
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__llvm__)
+  #pragma GCC diagnostic push 
+  #pragma GCC diagnostic ignored "-Wnull-dereference"
+#endif
+
+#if defined(__clang__) || defined(__llvm__)
+  #pragma clang diagnostic push 
+  #pragma clang diagnostic ignored "-Wnull-dereference"
+#endif
diff --git a/src/etl/private/ivectorpointer.h b/src/etl/private/ivectorpointer.h
index 52b9924..52f938f 100644
--- a/src/etl/private/ivectorpointer.h
+++ b/src/etl/private/ivectorpointer.h
@@ -986,7 +986,7 @@ namespace etl
   /// Less than or equal operator.
   ///\param lhs Reference to the first vector.
   ///\param rhs Reference to the second vector.
-  ///\return <b>true</b> if the first vector is lexigraphically less than or equal to the second, otherwise <b>false</b>
+  ///\return <b>true</b> if the first vector is lexicographically less than or equal to the second, otherwise <b>false</b>
   ///\ingroup vector
   //***************************************************************************
   template <typename T>
@@ -999,7 +999,7 @@ namespace etl
   /// Greater than or equal operator.
   ///\param lhs Reference to the first vector.
   ///\param rhs Reference to the second vector.
-  ///\return <b>true</b> if the first vector is lexigraphically greater than or equal to the second, otherwise <b>false</b>
+  ///\return <b>true</b> if the first vector is lexicographically greater than or equal to the second, otherwise <b>false</b>
   ///\ingroup vector
   //***************************************************************************
   template <typename T>
diff --git a/src/etl/private/variant_variadic.h b/src/etl/private/variant_variadic.h
index 28b2d99..486988a 100644
--- a/src/etl/private/variant_variadic.h
+++ b/src/etl/private/variant_variadic.h
@@ -41,6 +41,7 @@ SOFTWARE.
 #include "../placement_new.h"
 #include "../visitor.h"
 #include "../memory.h"
+#include "../compare.h"
 #include "../initializer_list.h"
 
 #include <stdint.h>
@@ -387,6 +388,12 @@ namespace etl
 	constexpr bool operator <=(etl::monostate, etl::monostate) noexcept { return true; }
 	constexpr bool operator >=(etl::monostate, etl::monostate) noexcept { return true; }
 	constexpr bool operator ==(etl::monostate, etl::monostate) noexcept { return true; }
+#if ETL_USING_CPP20 && ETL_USING_STL && !(defined(ETL_DEVELOPMENT_OS_APPLE) && defined(ETL_COMPILER_CLANG))
+  constexpr std::strong_ordering operator<=>(monostate, monostate) noexcept
+  {
+    return std::strong_ordering::equal;
+  }
+#endif
 
 #if ETL_NOT_USING_STL && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
   template <>
@@ -701,6 +708,29 @@ namespace etl
       return *static_cast<T*>(data);
     }
 
+#if ETL_HAS_INITIALIZER_LIST
+    //***************************************************************************
+    /// Emplace by type with variadic constructor parameters.
+    //***************************************************************************
+    template <typename T, typename U, typename... TArgs>
+    T& emplace(std::initializer_list<U> il, TArgs&&... args)
+    {
+      static_assert(etl::is_one_of<T, TTypes...>::value, "Unsupported type");
+
+      using type = etl::remove_cvref_t<T>;
+
+      operation(private_variant::Destroy, data, nullptr);
+
+      construct_in_place_args<type>(data, il, etl::forward<TArgs>(args)...);
+
+      operation = operation_type<type, etl::is_copy_constructible<type>::value, etl::is_move_constructible<type>::value>::do_operation;
+
+      type_id = etl::private_variant::parameter_pack<TTypes...>::template index_of_type<T>::value;
+
+      return *static_cast<T*>(data);
+    }
+#endif
+
     //***************************************************************************
     /// Emplace by index with variadic constructor parameters.
     //***************************************************************************
@@ -722,6 +752,29 @@ namespace etl
       return *static_cast<type*>(data);
     }
 
+#if ETL_HAS_INITIALIZER_LIST
+    //***************************************************************************
+    /// Emplace by index with variadic constructor parameters.
+    //***************************************************************************
+    template <size_t Index, typename U, typename... TArgs>
+    typename etl::variant_alternative<Index, variant<TArgs...>>::type& emplace(std::initializer_list<U> il, TArgs&&... args)
+    {
+      static_assert(Index < etl::private_variant::parameter_pack<TTypes...>::size, "Index out of range");
+
+      using type = typename etl::private_variant::parameter_pack<TTypes...>::template type_from_index<Index>::type;
+
+      operation(private_variant::Destroy, data, nullptr);
+
+      construct_in_place_args<type>(data, il, etl::forward<TArgs>(args)...);
+
+      operation = operation_type<type, etl::is_copy_constructible<type>::value, etl::is_move_constructible<type>::value>::do_operation;
+
+      type_id = Index;
+
+      return *static_cast<type*>(data);
+    }
+#endif
+
     //***************************************************************************
     /// Move assignment operator for type.
     ///\param value The value to assign.
@@ -997,7 +1050,7 @@ namespace etl
 
 #if ETL_USING_CPP17 && !defined(ETL_VARIANT_FORCE_CPP11)
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_visitor(TVisitor& visitor, etl::index_sequence<I...>)
@@ -1006,7 +1059,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_visitor(TVisitor& visitor, etl::index_sequence<I...>) const
@@ -1015,7 +1068,7 @@ namespace etl
     }
 #else
     //***************************************************************************
-    /// /// Call the relevent visitor.
+    /// /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_visitor(TVisitor& visitor)
@@ -1065,7 +1118,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// /// Call the relevent visitor.
+    /// /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_visitor(TVisitor& visitor) const
@@ -1125,7 +1178,7 @@ namespace etl
       {
         // Workaround for MSVC (2023/05/13)
         // It doesn't compile 'visitor.visit(etl::get<Index>(*this))' correctly for C++17 & C++20.
-        // Changed all of the instances for consistancy.
+        // Changed all of the instances for consistency.
         auto& v = etl::get<Index>(*this);
         visitor.visit(v);
         return true;
@@ -1146,7 +1199,7 @@ namespace etl
       {
         // Workaround for MSVC (2023/05/13)
         // It doesn't compile 'visitor.visit(etl::get<Index>(*this))' correctly for C++17 & C++20.
-        // Changed all of the instances for consistancy.
+        // Changed all of the instances for consistency.
         auto& v = etl::get<Index>(*this);
         visitor.visit(v);
         return true;
@@ -1159,7 +1212,7 @@ namespace etl
 
 #if ETL_USING_CPP17 && !defined(ETL_VARIANT_FORCE_CPP11)
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_operator(TVisitor& visitor, etl::index_sequence<I...>)
@@ -1168,7 +1221,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Call the relevent visitor by attempting each one.
+    /// Call the relevant visitor by attempting each one.
     //***************************************************************************
     template <typename TVisitor, size_t... I>
     void do_operator(TVisitor& visitor, etl::index_sequence<I...>) const
@@ -1177,7 +1230,7 @@ namespace etl
     }
 #else
     //***************************************************************************
-    /// Call the relevent visitor.
+    /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_operator(TVisitor& visitor)
@@ -1241,7 +1294,7 @@ namespace etl
     }
 
     //***************************************************************************
-    /// Call the relevent visitor.
+    /// Call the relevant visitor.
     //***************************************************************************
     template <typename TVisitor>
     void do_operator(TVisitor& visitor) const
@@ -1693,7 +1746,7 @@ namespace etl
 
     //***************************************************************************
     /// Helper to instantiate the function pointers needed for the "jump table".
-    /// Embedds the 'TVarRest' (remaining variants) into its type to come around
+    /// Embeds the 'TVarRest' (remaining variants) into its type to come around
     /// the "double expansion" otherwise needed in "do_visit".
     //***************************************************************************
     template <typename TRet, typename TCallable, typename TCurVariant, typename... TVarRest>
@@ -1770,7 +1823,7 @@ namespace etl
   }  // namespace private_variant
 
   //***************************************************************************
-  /// c++11/14 compatible etl::visit for etl::variant. Supports both c++17
+  /// C++11/14 compatible etl::visit for etl::variant. Supports both c++17
   /// "auto return type" signature and c++20 explicit template return type.
   //***************************************************************************
   template <typename TRet = private_variant::visit_auto_return, typename... TVariants, typename TCallable, typename TDeducedReturn = private_variant::visit_result_t<TRet, TCallable, TVariants...> >
@@ -1778,5 +1831,221 @@ namespace etl
   {
     return private_variant::visit<TDeducedReturn>(static_cast<TCallable&&>(f), static_cast<TVariants&&>(vs)...);
   }
+
+  namespace private_variant
+  {
+    //***************************************************************************
+    /// C++11 compatible visitor function for testing variant equality.
+    /// Assumes that the two variants are already known to contain the same type.
+    //***************************************************************************
+    template <typename TVariant>
+    struct equality_visitor
+    {
+      equality_visitor(const TVariant& rhs_)
+        : rhs(rhs_)
+      {
+      }
+
+      template <typename TValue>
+      bool operator()(const TValue& lhs_downcasted)
+      {
+        return lhs_downcasted == etl::get<TValue>(rhs);
+      }
+
+      const TVariant& rhs;
+    };
+
+    //***************************************************************************
+    /// C++11 compatible visitor function for testing variant '<' (less than).
+    /// Assumes that the two variants are already known to contain the same type.
+    //***************************************************************************
+    template <typename TVariant>
+    struct less_than_visitor
+    {
+      less_than_visitor(const TVariant& rhs_)
+        : rhs(rhs_)
+      {
+      }
+
+      template <typename TValue>
+      bool operator()(const TValue& lhs_downcasted)
+      {
+        return lhs_downcasted < etl::get<TValue>(rhs);
+      }
+
+      const TVariant& rhs;
+    };
+  }
+
+  //***************************************************************************
+  /// Checks if the variants are equal.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator ==(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    // If both variants are valueless, they are considered equal
+    if (lhs.valueless_by_exception() && rhs.valueless_by_exception())
+    {
+      return true;
+    }
+
+    // If one variant is valueless and the other is not, they are not equal
+    if (lhs.valueless_by_exception() || rhs.valueless_by_exception())
+    {
+      return false;
+    }
+
+    // If variants have different types, they are not equal
+    if (lhs.index() != rhs.index())
+    {
+      return false;
+    }
+
+    // Variants have the same type, apply the equality operator for the contained values
+    private_variant::equality_visitor<etl::variant<TTypes...>> visitor(rhs);
+
+    return etl::visit(visitor, lhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the variants not equal.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator !=(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is less than rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator <(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    // If both variants are valueless, they are considered equal, so not less than
+    if (lhs.valueless_by_exception() && rhs.valueless_by_exception())
+    {
+      return false;
+    }
+
+    // A valueless variant is always less than a variant with a value
+    if (lhs.valueless_by_exception())
+    {
+      return true;
+    }
+
+    // A variant with a value is never less than a valueless variant
+    if (rhs.valueless_by_exception())
+    {
+      return false;
+    }
+
+    // If variants have different types, compare the type index
+    if (lhs.index() != rhs.index())
+    {
+      return lhs.index() < rhs.index();
+    }
+
+    // Variants have the same type, apply the less than operator for the contained values
+    private_variant::less_than_visitor<etl::variant<TTypes...>> visitor(rhs);
+
+    return etl::visit(visitor, lhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is greater than rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator >(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return (rhs < lhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is less than or equal to rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator <=(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return  !(lhs > rhs);
+  }
+
+  //***************************************************************************
+  /// Checks if the lhs variant is greater than or equal to rhs.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 bool operator >=(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    return !(lhs < rhs);
+  }
+
+  namespace private_variant
+  {
+#if ETL_USING_CPP20 && ETL_USING_STL && !(defined(ETL_DEVELOPMENT_OS_APPLE) && defined(ETL_COMPILER_CLANG))
+    //***************************************************************************
+    /// C++20 compatible visitor function for testing variant '<=>'.
+    /// Assumes that the two variants are already known to contain the same type.
+    //***************************************************************************
+    template <typename TVariant>
+    struct compare_visitor
+    {
+      compare_visitor(const TVariant& rhs_)
+        : rhs(rhs_)
+      {
+      }
+
+      template <typename TValue>
+      std::strong_ordering operator()(const TValue& lhs_downcasted)
+      {
+        return lhs_downcasted <=> etl::get<TValue>(rhs);
+      }
+
+      const TVariant& rhs;
+    };
+#endif
+  }
+
+  //***************************************************************************
+  /// Defines the 'spaceship' <=> operator for comparing variants.
+  /// Only defined if using C++20 and STL.
+  /// https://en.cppreference.com/w/cpp/utility/variant/operator_cmp
+  //***************************************************************************
+#if ETL_USING_CPP20 && ETL_USING_STL && !(defined(ETL_DEVELOPMENT_OS_APPLE) && defined(ETL_COMPILER_CLANG))
+  template <typename... TTypes>
+  ETL_CONSTEXPR14 
+  std::common_comparison_category_t<std::compare_three_way_result_t<TTypes>...>
+    operator <=>(const etl::variant<TTypes...>& lhs, const etl::variant<TTypes...>& rhs)
+  {
+    if (lhs.valueless_by_exception() && rhs.valueless_by_exception())
+    {
+      return std::strong_ordering::equal;
+    }
+    else if (lhs.valueless_by_exception())
+    {
+      return std::strong_ordering::less;
+    }
+    else if (rhs.valueless_by_exception())
+    {
+      return std::strong_ordering::greater;
+    }
+    else if (lhs.index() != rhs.index())
+    {
+      return lhs.index() <=> rhs.index();
+    }
+    else
+    {
+      // Variants have the same type, apply the equality operator for the contained values
+      private_variant::compare_visitor<etl::variant<TTypes...>> visitor(rhs);
+
+      return etl::visit(visitor, lhs);
+    }
+  }
+#endif
 }
 #endif
diff --git a/src/etl/queue.h b/src/etl/queue.h
index 7512709..0f66cef 100644
--- a/src/etl/queue.h
+++ b/src/etl/queue.h
@@ -662,7 +662,7 @@ namespace etl
     {
       if (&rhs != this)
       {
-        base_t::move_clone(rhs);
+        base_t::move_clone(etl::move(rhs));
       }
 
       return *this;
diff --git a/src/etl/queue_spsc_locked.h b/src/etl/queue_spsc_locked.h
index a5e7ca1..0ac26b5 100644
--- a/src/etl/queue_spsc_locked.h
+++ b/src/etl/queue_spsc_locked.h
@@ -868,9 +868,9 @@ namespace etl
     /// Default constructor.
     //*************************************************************************
 
-    queue_spsc_locked(const etl::ifunction<void>& lock,
-                      const etl::ifunction<void>& unlock)
-      : base_t(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, lock, unlock)
+    queue_spsc_locked(const etl::ifunction<void>& lock_,
+                      const etl::ifunction<void>& unlock_)
+      : base_t(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, lock_, unlock_)
     {
     }
 
diff --git a/src/etl/radix.h b/src/etl/radix.h
index 63bf47f..88a6273 100644
--- a/src/etl/radix.h
+++ b/src/etl/radix.h
@@ -47,19 +47,19 @@ namespace etl
   {
     enum enum_type
     {
-      undefined = 0,
-      binary    = 2,
-      octal     = 8,
-      decimal   = 10,
-      hex       = 16
+      undefined   = 0,
+      binary      = 2,
+      octal       = 8,
+      decimal     = 10,
+      hexadecimal = 16
     };
 
     ETL_DECLARE_ENUM_TYPE(radix, uint_least8_t)
-    ETL_ENUM_TYPE(undefined, "undefined")
-    ETL_ENUM_TYPE(binary,    "binary")
-    ETL_ENUM_TYPE(octal,     "octal")
-    ETL_ENUM_TYPE(decimal,   "decimal")
-    ETL_ENUM_TYPE(hex,       "hex")
+    ETL_ENUM_TYPE(undefined,   "undefined")
+    ETL_ENUM_TYPE(binary,      "binary")
+    ETL_ENUM_TYPE(octal,       "octal")
+    ETL_ENUM_TYPE(decimal,     "decimal")
+    ETL_ENUM_TYPE(hexadecimal, "hexadecimal")
     ETL_END_ENUM_TYPE
   };
 }
diff --git a/src/etl/random.h b/src/etl/random.h
index e24bb84..2a48050 100644
--- a/src/etl/random.h
+++ b/src/etl/random.h
@@ -462,12 +462,12 @@ namespace etl
 
     random_pcg()
     {
-#include "etl/private/diagnostic_useless_cast_push.h"
+#include "private/diagnostic_useless_cast_push.h"
       // An attempt to come up with a unique non-zero seed,
       // based on the address of the instance.
       uintptr_t n = reinterpret_cast<uintptr_t>(this);
       value = static_cast<uint64_t>(n);
-#include "etl/private/diagnostic_pop.h"
+#include "private/diagnostic_pop.h"
     }
 
     //***************************************************************************
diff --git a/src/etl/reference_counted_message.h b/src/etl/reference_counted_message.h
index 69c35e2..fd615df 100644
--- a/src/etl/reference_counted_message.h
+++ b/src/etl/reference_counted_message.h
@@ -69,14 +69,19 @@ namespace etl
     typedef TMessage message_type;
     typedef TCounter counter_type;
 
+#if ETL_USING_CPP11
     //***************************************************************************
     /// Constructor
     /// \param owner The message owner.
+    /// \param args  The constructor arguments.
     //***************************************************************************
-    reference_counted_message(etl::ireference_counted_message_pool& owner_)
-      : owner(owner_)
+    template <typename... TArgs>
+    reference_counted_message(etl::ireference_counted_message_pool& owner_, TArgs&&... args)
+      : rc_object(etl::forward<TArgs>(args)...)
+      , owner(owner_)
     {
     }
+#endif
 
     //***************************************************************************
     /// Constructor
@@ -222,4 +227,4 @@ namespace etl
 #endif
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/etl/reference_counted_message_pool.h b/src/etl/reference_counted_message_pool.h
index d678f9f..fe18a1e 100644
--- a/src/etl/reference_counted_message_pool.h
+++ b/src/etl/reference_counted_message_pool.h
@@ -100,6 +100,35 @@ namespace etl
     {
     }
 
+#if ETL_USING_CPP11
+    //*************************************************************************
+    /// Allocate a reference counted message from the pool.
+    //*************************************************************************
+    template <typename TMessage, typename... TArgs>
+    etl::reference_counted_message<TMessage, TCounter>* allocate(TArgs&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage>::value), "Not a message type");
+
+      typedef etl::reference_counted_message<TMessage, TCounter> rcm_t;
+      typedef rcm_t* prcm_t;
+
+      prcm_t p = ETL_NULLPTR;
+
+      lock();
+      p = static_cast<prcm_t>(memory_block_allocator.allocate(sizeof(rcm_t), etl::alignment_of<rcm_t>::value));
+      unlock();
+
+      if (p != ETL_NULLPTR)
+      {
+        ::new(p) rcm_t(*this, etl::forward<TArgs>(args)...);
+      }
+
+      ETL_ASSERT((p != ETL_NULLPTR), ETL_ERROR(etl::reference_counted_message_pool_allocation_failure));
+
+      return p;
+    }
+#endif
+
     //*************************************************************************
     /// Allocate a reference counted message from the pool.
     //*************************************************************************
@@ -182,13 +211,13 @@ namespace etl
       // Size of the first pool message type.
       static constexpr size_t size1 = sizeof(etl::reference_counted_message<TMessage1, TCounter>);
 
-      // Maximum size of the the rest of the pool message types.
+      // Maximum size of the rest of the pool message types.
       static constexpr size_t size2 = pool_message_parameters<TMessages...>::max_size;
 
       // Size of the first pool message type.
       static constexpr size_t alignment1 = etl::alignment_of<etl::reference_counted_message<TMessage1, TCounter>>::value;
 
-      // Maximum size of the the rest of the pool message types.
+      // Maximum size of the rest of the pool message types.
       static constexpr size_t alignment2 = pool_message_parameters<TMessages...>::max_alignment;
 
     public:
@@ -216,8 +245,8 @@ namespace etl
     };
 
 #else
-    template <typename TMessage1,              typename TMessage2  = TMessage1, typename TMessage3  = TMessage1, typename TMessage4  = TMessage1,
-              typename TMessage5  = TMessage1, typename TMessage6  = TMessage1, typename TMessage7  = TMessage1, typename TMessage8  = TMessage1>
+    template <typename TMessage1,             typename TMessage2 = TMessage1, typename TMessage3 = TMessage1, typename TMessage4 = TMessage1,
+              typename TMessage5 = TMessage1, typename TMessage6 = TMessage1, typename TMessage7 = TMessage1, typename TMessage8 = TMessage1>
     struct pool_message_parameters
     {
       ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage1>::value), "TMessage1 not derived from etl::imessage");
@@ -230,23 +259,23 @@ namespace etl
       ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage1>::value), "TMessage8 not derived from etl::imessage");
 
       static ETL_CONSTANT size_t max_size = etl::largest<etl::reference_counted_message<TMessage1, TCounter>,
-                                                  etl::reference_counted_message<TMessage2, TCounter>,
-                                                  etl::reference_counted_message<TMessage3, TCounter>,
-                                                  etl::reference_counted_message<TMessage4, TCounter>,
-                                                  etl::reference_counted_message<TMessage5, TCounter>,
-                                                  etl::reference_counted_message<TMessage6, TCounter>,
-                                                  etl::reference_counted_message<TMessage7, TCounter>,
-                                                  etl::reference_counted_message<TMessage8, TCounter> >::size;
+                                                         etl::reference_counted_message<TMessage2, TCounter>,
+                                                         etl::reference_counted_message<TMessage3, TCounter>,
+                                                         etl::reference_counted_message<TMessage4, TCounter>,
+                                                         etl::reference_counted_message<TMessage5, TCounter>,
+                                                         etl::reference_counted_message<TMessage6, TCounter>,
+                                                         etl::reference_counted_message<TMessage7, TCounter>,
+                                                         etl::reference_counted_message<TMessage8, TCounter> >::size;
 
 
       static ETL_CONSTANT size_t max_alignment = etl::largest<etl::reference_counted_message<TMessage1, TCounter>,
-                                                       etl::reference_counted_message<TMessage2, TCounter>,
-                                                       etl::reference_counted_message<TMessage3, TCounter>,
-                                                       etl::reference_counted_message<TMessage4, TCounter>,
-                                                       etl::reference_counted_message<TMessage5, TCounter>,
-                                                       etl::reference_counted_message<TMessage6, TCounter>,
-                                                       etl::reference_counted_message<TMessage7, TCounter>,
-                                                       etl::reference_counted_message<TMessage8, TCounter> >::alignment;
+                                                              etl::reference_counted_message<TMessage2, TCounter>,
+                                                              etl::reference_counted_message<TMessage3, TCounter>,
+                                                              etl::reference_counted_message<TMessage4, TCounter>,
+                                                              etl::reference_counted_message<TMessage5, TCounter>,
+                                                              etl::reference_counted_message<TMessage6, TCounter>,
+                                                              etl::reference_counted_message<TMessage7, TCounter>,
+                                                              etl::reference_counted_message<TMessage8, TCounter> >::alignment;
     };
 
 #endif
@@ -290,4 +319,4 @@ namespace etl
 #endif
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/etl/reference_counted_object.h b/src/etl/reference_counted_object.h
index e345861..198da27 100644
--- a/src/etl/reference_counted_object.h
+++ b/src/etl/reference_counted_object.h
@@ -33,6 +33,7 @@
 #include "atomic.h"
 #include "exception.h"
 #include "error_handler.h"
+#include "utility.h"
 
 #include <stdint.h>
 
@@ -223,6 +224,17 @@ namespace etl
     {
     }
 
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Constructor.
+    //***************************************************************************
+    template <typename... TArgs>
+    reference_counted_object(TArgs&&... args)
+      : object(etl::forward<TArgs>(args)...)
+    {
+    }
+#endif
+
     //***************************************************************************
     /// Get a reference to the counted object.
     //***************************************************************************
@@ -276,4 +288,4 @@ namespace etl
 #endif
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/etl/set.h b/src/etl/set.h
index b3babaa..6dac5d5 100644
--- a/src/etl/set.h
+++ b/src/etl/set.h
@@ -1407,10 +1407,10 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(const_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(value);
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(value);
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 
 #if ETL_USING_CPP11
@@ -1419,20 +1419,20 @@ namespace etl
     //*************************************************************************
     Data_Node& allocate_data_node(rvalue_reference value)
     {
-      Data_Node& node = allocate_data_node();
-      ::new ((void*)&node.value) value_type(etl::move(value));
+      Data_Node* node = allocate_data_node();
+      ::new ((void*)&node->value) value_type(etl::move(value));
       ETL_INCREMENT_DEBUG_COUNT;
-      return node;
+      return *node;
     }
 #endif
 
     //*************************************************************************
     /// Create a Data_Node.
     //*************************************************************************
-    Data_Node& allocate_data_node()
+    Data_Node* allocate_data_node()
     {
       Data_Node* (etl::ipool::*func)() = &etl::ipool::allocate<Data_Node>;
-      return *(p_node_pool->*func)();
+      return (p_node_pool->*func)();
     }
 
     //*************************************************************************
diff --git a/src/etl/shared_message.h b/src/etl/shared_message.h
index 013ea88..43d8f78 100644
--- a/src/etl/shared_message.h
+++ b/src/etl/shared_message.h
@@ -49,6 +49,17 @@ namespace etl
   {
   public:
 
+#if ETL_USING_CPP11
+    //*************************************************************************
+    /// Creator for in-place instantiation
+    //*************************************************************************
+    template <typename TMessage, typename TPool, typename... TArgs>
+    static shared_message create(TPool& owner, TArgs&&... args)
+    {
+      return shared_message(owner, etl::in_place_type_t<TMessage>(), etl::forward<TArgs>(args)...);
+    }
+#endif
+
     //*************************************************************************
     /// Constructor
     //*************************************************************************
@@ -59,12 +70,31 @@ namespace etl
       ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage>::value), "TMessage not derived from etl::imessage");
 
       p_rcmessage = owner.allocate(message);
-      
+
+      if (p_rcmessage != ETL_NULLPTR)
+      {
+        p_rcmessage->get_reference_counter().set_reference_count(1U);
+      }
+    }
+
+#if ETL_USING_CPP11
+    //*************************************************************************
+    /// Constructor
+    //*************************************************************************
+    template <typename TPool, typename TMessage, typename... TArgs>
+    shared_message(TPool& owner, etl::in_place_type_t<TMessage>, TArgs&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_base_of<etl::ireference_counted_message_pool, TPool>::value), "TPool not derived from etl::ireference_counted_message_pool");
+      ETL_STATIC_ASSERT((etl::is_base_of<etl::imessage, TMessage>::value), "TMessage not derived from etl::imessage");
+
+      p_rcmessage = owner.template allocate<TMessage>(etl::forward<TArgs>(args)...);
+
       if (p_rcmessage != ETL_NULLPTR)
       {
         p_rcmessage->get_reference_counter().set_reference_count(1U);
       }
     }
+#endif
 
     //*************************************************************************
     /// Constructor
@@ -193,5 +223,4 @@ namespace etl
   };
 }
 
-#endif
-
+#endif
\ No newline at end of file
diff --git a/src/etl/span.h b/src/etl/span.h
index 797e35e..f1077ea 100644
--- a/src/etl/span.h
+++ b/src/etl/span.h
@@ -42,6 +42,7 @@ SOFTWARE.
 #include "memory.h"
 #include "array.h"
 #include "byte.h"
+#include "static_assert.h"
 
 #include "private/dynamic_extent.h"
 
@@ -78,14 +79,6 @@ namespace etl
 
     static ETL_CONSTANT size_t extent = Extent;
 
-    //*************************************************************************
-    /// Default constructor.
-    //*************************************************************************
-    ETL_CONSTEXPR span() ETL_NOEXCEPT
-      : pbegin(ETL_NULLPTR)
-    {
-    }
-
     //*************************************************************************
     /// Construct from iterators + size
     //*************************************************************************
@@ -295,6 +288,9 @@ namespace etl
     template <size_t COUNT>
     ETL_NODISCARD ETL_CONSTEXPR etl::span<element_type, COUNT> first() const ETL_NOEXCEPT
     {
+      // If Extent is static, check that original span contains at least COUNT elements
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? COUNT <= Extent : true, "Original span does not contain COUNT elements");
+
       return etl::span<element_type, COUNT>(pbegin, pbegin + COUNT);
     }
 
@@ -312,6 +308,9 @@ namespace etl
     template <size_t COUNT>
     ETL_NODISCARD ETL_CONSTEXPR etl::span<element_type, COUNT> last() const ETL_NOEXCEPT
     {
+      // If Extent is static, check that original span contains at least COUNT elements
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? COUNT <= Extent : true, "Original span does not contain COUNT elements");
+
       return etl::span<element_type, COUNT>(pbegin + Extent - COUNT, (pbegin + Extent));
     }
 
@@ -331,6 +330,12 @@ namespace etl
     ETL_NODISCARD ETL_CONSTEXPR
     etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET> subspan() const ETL_NOEXCEPT
     {
+      // If Extent is static, check that OFFSET is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? OFFSET <= Extent : true, "OFFSET is not within the original span");
+
+      // If count is also static, check that OFFSET + COUNT is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) && (COUNT != etl::dynamic_extent) ? COUNT <= (Extent - OFFSET) : true, "OFFSET + COUNT is not within the original span");
+      
       return (COUNT == etl::dynamic_extent) ? etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET>(pbegin + OFFSET, (pbegin + Extent))
                                             : etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET>(pbegin + OFFSET, pbegin + OFFSET + COUNT);
     }
@@ -341,6 +346,12 @@ namespace etl
     template <size_t OFFSET, size_t COUNT>
     etl::span<element_type, COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET> subspan() const
     {
+      // If Extent is static, check that OFFSET is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) ? OFFSET <= Extent : true, "OFFSET is not within the original span");
+
+      // If count is also static, check that OFFSET + COUNT is within the original span
+      ETL_STATIC_ASSERT((Extent != etl::dynamic_extent) && (COUNT != etl::dynamic_extent) ? COUNT <= (Extent - OFFSET) : true, "OFFSET + COUNT is not within the original span");
+      
       if (COUNT == etl::dynamic_extent)
       {
         return etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : Extent - OFFSET)>(pbegin + OFFSET, (pbegin + Extent));
@@ -720,7 +731,7 @@ namespace etl
 
   //*************************************************************************
   /// Equality function.
-  /// Performs a comparision of the range values.
+  /// Performs a comparison of the range values.
   /// Returns <b>true</b> if one of the following are <b>true</b>
   /// 1. Both spans are empty.
   /// 2. They both point to the same range of data.
diff --git a/src/etl/string.h b/src/etl/string.h
index 5f92533..1fbc19d 100644
--- a/src/etl/string.h
+++ b/src/etl/string.h
@@ -246,9 +246,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::istring::repair_buffer(buffer);
@@ -434,9 +435,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/src/etl/string_view.h b/src/etl/string_view.h
index a196b90..7ddce50 100644
--- a/src/etl/string_view.h
+++ b/src/etl/string_view.h
@@ -662,6 +662,7 @@ namespace etl
             if (mbegin[i] == view[j])
             {
               found = true;
+              break;
             }
           }
 
@@ -715,6 +716,7 @@ namespace etl
           if (mbegin[position] == view[j])
           {
             found = true;
+            break;
           }
         }
 
diff --git a/src/etl/timer.h b/src/etl/timer.h
index 856413b..ed96cde 100644
--- a/src/etl/timer.h
+++ b/src/etl/timer.h
@@ -104,6 +104,17 @@ namespace etl
         Inactive = 0xFFFFFFFFUL
       };
     };
+
+    // Timer time interval.
+    struct interval
+    {
+      enum
+      {
+        No_Active_Interval = 0xFFFFFFFFUL
+      };
+
+      typedef uint32_t type;
+    };
   };
 }
 
diff --git a/src/etl/to_arithmetic.h b/src/etl/to_arithmetic.h
index f2e6974..c7b2632 100644
--- a/src/etl/to_arithmetic.h
+++ b/src/etl/to_arithmetic.h
@@ -251,7 +251,7 @@ namespace etl
           break;
         }
 
-        case etl::radix::hex:
+        case etl::radix::hexadecimal:
         {
           return ((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f'));
           break;
@@ -281,7 +281,7 @@ namespace etl
           break;
         }
 
-        case etl::radix::hex:
+        case etl::radix::hexadecimal:
         {
           if ((c >= '0') && (c <= '9'))
           {
@@ -363,7 +363,7 @@ namespace etl
       return (radix == etl::radix::binary)  ||
              (radix == etl::radix::octal)   ||
              (radix == etl::radix::decimal) ||
-             (radix == etl::radix::hex);
+             (radix == etl::radix::hexadecimal);
     }
 
     //***************************************************************************
@@ -397,7 +397,7 @@ namespace etl
           TValue old_value = integral_value;
           integral_value *= radix;
 
-          // No multipication overflow?
+          // No multiplication overflow?
           is_not_overflow = ((integral_value / radix) == old_value);
 
           if (is_not_overflow)
diff --git a/src/etl/type_def.h b/src/etl/type_def.h
index d16e4cd..c124aa7 100644
--- a/src/etl/type_def.h
+++ b/src/etl/type_def.h
@@ -35,274 +35,262 @@ SOFTWARE.
 
 namespace etl
 {
-    #define ETL_TYPEDEF(T, name) class name##_tag; typedef etl::type_def<name##_tag, T> name
-
-    //*************************************************************************
-    /// A template type to define strong typedefs.
-    /// Usage:
-    ///\code
-    /// // Short form.
-    /// ETL_TYPEDEF(int, mytype);
-    ///
-    /// // Long form.
-    /// class mytype_t_tag;
-    /// typedef etl::type_def<mytype_t_tag, int> mytype_t_tag;
-    ///\endcode
-    //*************************************************************************
-    template <typename TIdType, typename TValue>
-    class type_def
-    {
-    public:
-
-        typedef TValue  value_type;
-        typedef TIdType id_type;
-
-        //*********************************************************************
-        type_def()
-            : value(TValue())
-        {
-        }
-
-        //*********************************************************************
-        type_def(TValue value_)
-            : value(value_)
-        {
-        }
-
-        //*********************************************************************
-        type_def(const type_def& other)
-            : value(other.value)
-        {
-        }
-
-        //*********************************************************************
-        operator TValue() const
-        {
-            return value;
-        }
-
-        //*********************************************************************
-        type_def& operator ++()
-        {
-            ++value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def operator ++(int)
-        {
-            type_def temp(*this);
-            type_def::operator ++();
-            return temp;
-        }
-
-        //*********************************************************************
-        type_def& operator --()
-        {
-            --value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def operator --(int)
-        {
-            type_def temp(*this);
-            type_def::operator --();
-            return temp;
-        }
-
-        //*********************************************************************
-        type_def& operator +=(TValue rhs)
-        {
-            value += rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator +=(const type_def& rhs)
-        {
-            value += rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator -=(TValue rhs)
-        {
-            value -= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator -=(const type_def& rhs)
-        {
-            value -= rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator *=(TValue rhs)
-        {
-            value *= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator *=(const type_def& rhs)
-        {
-            value *= rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator /=(TValue rhs)
-        {
-            value /= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator /=(const type_def& rhs)
-        {
-            value /= rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator %=(TValue rhs)
-        {
-            value %= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator %=(const type_def& rhs)
-        {
-            value %= rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator &=(TValue rhs)
-        {
-            value &= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator &=(const type_def& rhs)
-        {
-            value &= rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator |=(TValue rhs)
-        {
-            value |= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator |=(const type_def& rhs)
-        {
-            value |= rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator ^=(TValue rhs)
-        {
-            value ^= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator ^=(const type_def& rhs)
-        {
-            value ^= rhs.value;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator <<=(TValue rhs)
-        {
-            value <<= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator >>=(TValue rhs)
-        {
-            value >>= rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator =(TValue rhs)
-        {
-            value = rhs;
-            return *this;
-        }
-
-        //*********************************************************************
-        type_def& operator =(const type_def& rhs)
-        {
-          value = rhs.value;
-          return *this;
-        }
-
-        //*********************************************************************
-        TValue& get()
-        {
-            return value;
-        }
-
-        //*********************************************************************
-        const TValue& get() const
-        {
-            return value;
-        }
-
-        //*********************************************************************
-        friend bool operator <(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value < rhs.value;
-        }
-
-        //*********************************************************************
-        friend bool operator <=(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value <= rhs.value;
-        }
-
-        //*********************************************************************
-        friend bool operator >(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value > rhs.value;
-        }
-
-        //*********************************************************************
-        friend bool operator >=(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value >= rhs.value;
-        }
-
-        //*********************************************************************
-        friend bool operator ==(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value == rhs.value;
-        }
-
-        //*********************************************************************
-        friend bool operator !=(const type_def& lhs, const type_def& rhs)
-        {
-            return lhs.value != rhs.value;
-        }
-
-    private:
-
-        TValue value;
-    };
+  #define ETL_TYPEDEF(T, name) class name##_tag; typedef etl::type_def<name##_tag, T> name
+
+  //*************************************************************************
+  /// A template type to define strong typedefs.
+  /// Usage:
+  ///\code
+  /// // Short form.
+  /// ETL_TYPEDEF(int, mytype);
+  ///
+  /// // Long form.
+  /// class mytype_t_tag;
+  /// typedef etl::type_def<mytype_t_tag, int> mytype_t_tag;
+  ///\endcode
+  //*************************************************************************
+  template <typename TIdType, typename TValue>
+  class type_def
+  {
+  public:
+
+    typedef TValue  value_type;
+    typedef TIdType id_type;
+
+    //*********************************************************************
+    ETL_CONSTEXPR type_def()
+      : value(TValue())
+    {
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR type_def(TValue value_)
+      : value(value_)
+    {
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR type_def(const type_def& other)
+      : value(other.value)
+    {
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR operator TValue() const
+    {
+      return value;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator ++()
+    {
+      ++value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def operator ++(int)
+    {
+      type_def temp(*this);
+      type_def::operator ++();
+      return temp;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator --()
+    {
+      --value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def operator --(int)
+    {
+      type_def temp(*this);
+      type_def::operator --();
+      return temp;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator +=(TValue rhs)
+    {
+      value += rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator +=(const type_def& rhs)
+    {
+      value += rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator -=(TValue rhs)
+    {
+      value -= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator -=(const type_def& rhs)
+    {
+      value -= rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator *=(TValue rhs)
+    {
+      value *= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator *=(const type_def& rhs)
+    {
+      value *= rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator /=(TValue rhs)
+    {
+      value /= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator /=(const type_def& rhs)
+    {
+      value /= rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator %=(TValue rhs)
+    {
+      value %= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator %=(const type_def& rhs)
+    {
+      value %= rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator &=(TValue rhs)
+    {
+      value &= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator &=(const type_def& rhs)
+    {
+      value &= rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator |=(TValue rhs)
+    {
+      value |= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator |=(const type_def& rhs)
+    {
+      value |= rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator ^=(TValue rhs)
+    {
+      value ^= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator ^=(const type_def& rhs)
+    {
+      value ^= rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator <<=(TValue rhs)
+    {
+      value <<= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator >>=(TValue rhs)
+    {
+      value >>= rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator =(TValue rhs)
+    {
+      value = rhs;
+      return *this;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR14 type_def& operator =(const type_def& rhs)
+    {
+      value = rhs.value;
+      return *this;
+    }
+
+    //*********************************************************************
+    TValue& get()
+    {
+      return value;
+    }
+
+    //*********************************************************************
+    ETL_CONSTEXPR const TValue& get() const
+    {
+      return value;
+    }
+
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator >(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value > rhs.value;
+    }
+
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator >=(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value >= rhs.value;
+    }
+
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator ==(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value == rhs.value;
+    }
+
+    //*********************************************************************
+    friend ETL_CONSTEXPR bool operator !=(const type_def& lhs, const type_def& rhs)
+    {
+      return lhs.value != rhs.value;
+    }
+
+  private:
+
+      TValue value;
+  };
 }
 
 #endif
diff --git a/src/etl/type_traits.h b/src/etl/type_traits.h
index cb4fc72..93730e5 100644
--- a/src/etl/type_traits.h
+++ b/src/etl/type_traits.h
@@ -62,7 +62,7 @@ SOFTWARE.
 
 ///\defgroup type_traits type_traits
 /// A set of type traits definitions.
-/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined.
+/// Derived from either the standard or alternate definitions, dependent on whether or not ETL_NO_STL is defined.
 /// \ingroup utilities
 
 #if ETL_USING_STL && ETL_USING_CPP11
@@ -1399,6 +1399,52 @@ typedef integral_constant<bool, true>  true_type;
   inline constexpr bool is_one_of_v = etl::is_one_of<T, TRest...>::value;
 #endif
 
+#if ETL_USING_CPP11
+  //***************************************************************************
+  /// Template to determine if a type is a base of all types in a specified list.
+  ///\ingroup types
+  template <typename T, typename T1, typename... TRest>
+  struct is_base_of_all
+  {
+    static const bool value = etl::is_base_of<T, T1>::value &&
+                              etl::is_base_of_all<T, TRest...>::value;
+  };
+
+  template <typename T, typename T1>
+  struct is_base_of_all<T, T1>
+  {
+    static const bool value = etl::is_base_of<T, T1>::value;
+  };
+#endif
+
+#if ETL_USING_CPP17
+  template <typename T, typename... TRest>
+  inline constexpr bool is_base_of_all_v = etl::is_base_of_all<T, TRest...>::value;
+#endif
+
+#if ETL_USING_CPP11
+  //***************************************************************************
+  /// Template to determine if a type is a base of any type in a specified list.
+  ///\ingroup types
+  template <typename T, typename T1, typename... TRest>
+  struct is_base_of_any
+  {
+    static const bool value = etl::is_base_of<T, T1>::value ||
+                              etl::is_base_of_any<T, TRest...>::value;
+  };
+
+  template <typename T, typename T1>
+  struct is_base_of_any<T, T1>
+  {
+    static const bool value = etl::is_base_of<T, T1>::value;
+  };
+#endif
+
+#if ETL_USING_CPP17
+  template <typename T, typename... TRest>
+  inline constexpr bool is_base_of_any_v = etl::is_base_of_any<T, TRest...>::value;
+#endif
+
   //***************************************************************************
   /// A set of templates to allow related types to be derived.
   ///\ingroup types
@@ -2070,6 +2116,21 @@ typedef integral_constant<bool, true>  true_type;
   {
   };
 
+#if ETL_USING_CPP11
+  //*********************************************
+  // is_default_constructible
+  template<typename T, typename = void>
+  struct is_default_constructible : etl::false_type { };
+
+  template<typename T>
+  struct is_default_constructible<T, etl::void_t<decltype(T())>> : etl::true_type { };
+#else
+  template <typename T>
+  struct is_default_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
+  {
+  };
+#endif
+
 #if ETL_USING_CPP17
 
   template <typename T1, typename T2>
@@ -2081,6 +2142,9 @@ typedef integral_constant<bool, true>  true_type;
   template<typename T, typename... TArgs>
   inline constexpr bool is_constructible_v = etl::is_constructible<T, TArgs...>::value;
 
+  template<typename T, typename... TArgs>
+  inline constexpr bool is_default_constructible_v = etl::is_default_constructible<T, TArgs...>::value;
+
   template<typename T>
   inline constexpr bool is_copy_constructible_v = etl::is_copy_constructible<T>::value;
 
diff --git a/src/etl/u16string.h b/src/etl/u16string.h
index 2c100c8..c0fea3a 100644
--- a/src/etl/u16string.h
+++ b/src/etl/u16string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu16string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/src/etl/u32string.h b/src/etl/u32string.h
index 88d0ed4..766a0cb 100644
--- a/src/etl/u32string.h
+++ b/src/etl/u32string.h
@@ -230,9 +230,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu32string::repair_buffer(buffer);
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/src/etl/u8string.h b/src/etl/u8string.h
index 9d8b945..015ef3c 100644
--- a/src/etl/u8string.h
+++ b/src/etl/u8string.h
@@ -247,9 +247,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::iu8string::repair_buffer(buffer);
@@ -435,9 +436,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
diff --git a/src/etl/unordered_map.h b/src/etl/unordered_map.h
index 0e5b9e3..fab74e8 100644
--- a/src/etl/unordered_map.h
+++ b/src/etl/unordered_map.h
@@ -659,13 +659,13 @@ namespace etl
 
       // Doesn't exist, so add a new one.
       // Get a new node.
-      node_t& node = allocate_data_node();
-      node.clear();
-      ::new ((void*)etl::addressof(node.key_value_pair.first))  key_type(etl::move(key));
-      ::new ((void*)etl::addressof(node.key_value_pair.second)) mapped_type();
+      node_t* node = allocate_data_node();
+      node->clear();
+      ::new ((void*)etl::addressof(node->key_value_pair.first))  key_type(etl::move(key));
+      ::new ((void*)etl::addressof(node->key_value_pair.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
 
-      pbucket->insert_after(pbucket->before_begin(), node);
+      pbucket->insert_after(pbucket->before_begin(), *node);
 
       adjust_first_last_markers_after_insert(pbucket);
 
@@ -703,13 +703,13 @@ namespace etl
 
       // Doesn't exist, so add a new one.
       // Get a new node.
-      node_t& node = allocate_data_node();
-      node.clear();
-      ::new ((void*)etl::addressof(node.key_value_pair.first))  key_type(key);
-      ::new ((void*)etl::addressof(node.key_value_pair.second)) mapped_type();
+      node_t* node = allocate_data_node();
+      node->clear();
+      ::new ((void*)etl::addressof(node->key_value_pair.first))  key_type(key);
+      ::new ((void*)etl::addressof(node->key_value_pair.second)) mapped_type();
       ETL_INCREMENT_DEBUG_COUNT;
 
-        pbucket->insert_after(pbucket->before_begin(), node);
+        pbucket->insert_after(pbucket->before_begin(), *node);
 
       adjust_first_last_markers_after_insert(pbucket);
 
@@ -835,13 +835,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new ((void*)etl::addressof(node.key_value_pair)) value_type(key_value_pair);        
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new ((void*)etl::addressof(node->key_value_pair)) value_type(key_value_pair);        
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
 
         adjust_first_last_markers_after_insert(pbucket);
 
@@ -870,13 +870,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new ((void*)etl::addressof(node.key_value_pair)) value_type(key_value_pair);
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new ((void*)etl::addressof(node->key_value_pair)) value_type(key_value_pair);
           ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -913,13 +913,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new ((void*)etl::addressof(node.key_value_pair)) value_type(etl::move(key_value_pair));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new ((void*)etl::addressof(node->key_value_pair)) value_type(etl::move(key_value_pair));
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
 
         adjust_first_last_markers_after_insert(pbucket);
 
@@ -948,13 +948,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new ((void*)etl::addressof(node.key_value_pair)) value_type(etl::move(key_value_pair));
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new ((void*)etl::addressof(node->key_value_pair)) value_type(etl::move(key_value_pair));
           ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -1420,14 +1420,14 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1437,10 +1437,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1489,26 +1489,26 @@ namespace etl
         else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1569,20 +1569,41 @@ namespace etl
   ///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
   ///\ingroup unordered_map
   //***************************************************************************
-  template <typename TKey, typename T, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_map<TKey, T, TKeyCompare>& lhs, const etl::iunordered_map<TKey, T, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_map<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_map<TKey, T, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_map<TKey, T, THash, TKeyEqual>::const_iterator itr_t;
+    
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey key     = l_begin->first;
+        const T    l_value = l_begin->second;
+
+        // See if the lhs key exists in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> range = rhs.equal_range(key);
+
+        if (range.first != rhs.end())
+        {
+          // See if the values match
+          const T r_value = range.first->second;
+
+          elements_match = (r_value == l_value);
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1596,8 +1617,9 @@ namespace etl
   ///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
   ///\ingroup unordered_map
   //***************************************************************************
-  template <typename TKey, typename T, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_map<TKey, T, TKeyCompare>& lhs, const etl::iunordered_map<TKey, T, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_map<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_map<TKey, T, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/src/etl/unordered_multimap.h b/src/etl/unordered_multimap.h
index 174b597..53d9f43 100644
--- a/src/etl/unordered_multimap.h
+++ b/src/etl/unordered_multimap.h
@@ -675,13 +675,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(key_value_pair);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(key_value_pair);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(pbucket);
 
         result = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -705,13 +705,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(key_value_pair);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(key_value_pair);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Add the node to the end of the bucket;
-        bucket.insert_after(inode_previous, node);
+        bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -746,13 +746,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(etl::move(key_value_pair));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(etl::move(key_value_pair));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Just add the pointer to the bucket;
-          bucket.insert_after(bucket.before_begin(), node);
+          bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(pbucket);
 
         result = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -776,13 +776,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key_value_pair) value_type(etl::move(key_value_pair));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key_value_pair) value_type(etl::move(key_value_pair));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -1274,14 +1274,14 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1291,10 +1291,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1323,7 +1323,7 @@ namespace etl
     //*********************************************************************
     /// Adjust the first and last markers according to the erased entry.
     //*********************************************************************
-    void adjust_first_last_markers_after_erase(bucket_t* pcurrent)
+    void adjust_first_last_markers_after_erase(bucket_t* pbucket)
     {
       if (empty())
       {
@@ -1332,7 +1332,7 @@ namespace etl
       }
       else
       {
-        if (pcurrent == first)
+        if (pbucket == first)
         {
           // We erased the first so, we need to search again from where we erased.
           while (first->empty())
@@ -1340,29 +1340,29 @@ namespace etl
             ++first;
           }
         }
-        else if (pcurrent == last)
+        else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1423,20 +1423,48 @@ namespace etl
   ///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
   ///\ingroup unordered_multimap
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_multimap<TKey, T, THash, TKeyEqual>::const_iterator itr_t;
+
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey key     = l_begin->first;
+        const T    l_value = l_begin->second;
+
+        // See if the lhs keys exist in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> l_range = lhs.equal_range(key);
+        ETL_OR_STD::pair<itr_t, itr_t> r_range = rhs.equal_range(key);
+
+        if (r_range.first != rhs.end())
+        {
+          bool distance_match = (etl::distance(l_range.first, l_range.second) == etl::distance(r_range.first, r_range.second));
+
+          if (distance_match)
+          {
+            elements_match = etl::is_permutation(l_range.first, l_range.second, r_range.first, r_range.second);
+          }
+          else
+          {
+            elements_match = false;
+          }
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1450,8 +1478,9 @@ namespace etl
   ///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
   ///\ingroup unordered_multimap
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multimap<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename T, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multimap<TKey, T, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/src/etl/unordered_multiset.h b/src/etl/unordered_multiset.h
index be1acee..a24eb3f 100644
--- a/src/etl/unordered_multiset.h
+++ b/src/etl/unordered_multiset.h
@@ -664,13 +664,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(key);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(key);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -695,13 +695,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(key);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(key);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Add the node to the end of the bucket;
-        bucket.insert_after(inode_previous, node);
+        bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -735,13 +735,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(etl::move(key));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(etl::move(key));
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator((pbuckets + number_of_buckets), pbucket, pbucket->begin());
@@ -766,13 +766,13 @@ namespace etl
         }
 
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(etl::move(key));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(etl::move(key));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
         adjust_first_last_markers_after_insert(&bucket);
         ++inode_previous;
 
@@ -1252,14 +1252,14 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1269,10 +1269,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1301,7 +1301,7 @@ namespace etl
     //*********************************************************************
     /// Adjust the first and last markers according to the erased entry.
     //*********************************************************************
-    void adjust_first_last_markers_after_erase(bucket_t* pcurrent)
+    void adjust_first_last_markers_after_erase(bucket_t* pbucket)
     {
       if (empty())
       {
@@ -1310,7 +1310,7 @@ namespace etl
       }
       else
       {
-        if (pcurrent == first)
+        if (pbucket == first)
         {
           // We erased the first so, we need to search again from where we erased.
           while (first->empty())
@@ -1318,29 +1318,29 @@ namespace etl
             ++first;
           }
         }
-        else if (pcurrent == last)
+        else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1401,20 +1401,47 @@ namespace etl
   ///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
   ///\ingroup unordered_multiset
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_multiset<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multiset<TKey, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_multiset<TKey, THash, TKeyEqual>::const_iterator itr_t;
+
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey l_value = *l_begin;
+
+        // See if the lhs keys exist in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> l_range = lhs.equal_range(l_value);
+        ETL_OR_STD::pair<itr_t, itr_t> r_range = rhs.equal_range(l_value);
+
+        if (r_range.first != rhs.end())
+        {
+          bool distance_match = (etl::distance(l_range.first, l_range.second) == etl::distance(r_range.first, r_range.second));
+
+          if (distance_match)
+          {
+            elements_match = etl::is_permutation(l_range.first, l_range.second, r_range.first, r_range.second);
+          }
+          else
+          {
+            elements_match = false;
+          }
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1428,8 +1455,9 @@ namespace etl
   ///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
   ///\ingroup unordered_multiset
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_multiset<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_multiset<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_multiset<TKey, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/src/etl/unordered_set.h b/src/etl/unordered_set.h
index 35dce09..28e6360 100644
--- a/src/etl/unordered_set.h
+++ b/src/etl/unordered_set.h
@@ -678,13 +678,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(key);
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(key);
         ETL_INCREMENT_DEBUG_COUNT;
 
         // Just add the pointer to the bucket;
-        bucket.insert_after(bucket.before_begin(), node);
+        bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator(pbuckets + number_of_buckets, pbucket, pbucket->begin());
@@ -712,13 +712,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new (&node.key) value_type(key);
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new (&node->key) value_type(key);
           ETL_INCREMENT_DEBUG_COUNT;
 
           // Add the node to the end of the bucket;
-          bucket.insert_after(inode_previous, node);
+          bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -766,13 +766,13 @@ namespace etl
       if (bucket.empty())
       {
         // Get a new node.
-        node_t& node = allocate_data_node();
-        node.clear();
-        ::new (&node.key) value_type(etl::move(key));
+        node_t* node = allocate_data_node();
+        node->clear();
+        ::new (&node->key) value_type(etl::move(key));
         ETL_INCREMENT_DEBUG_COUNT;
 
           // Just add the pointer to the bucket;
-          bucket.insert_after(bucket.before_begin(), node);
+          bucket.insert_after(bucket.before_begin(), *node);
         adjust_first_last_markers_after_insert(&bucket);
 
         result.first = iterator(pbuckets + number_of_buckets, pbucket, pbucket->begin());
@@ -800,13 +800,13 @@ namespace etl
         if (inode == bucket.end())
         {
           // Get a new node.
-          node_t& node = allocate_data_node();
-          node.clear();
-          ::new (&node.key) value_type(etl::move(key));
+          node_t* node = allocate_data_node();
+          node->clear();
+          ::new (&node->key) value_type(etl::move(key));
           ETL_INCREMENT_DEBUG_COUNT;
 
             // Add the node to the end of the bucket;
-            bucket.insert_after(inode_previous, node);
+            bucket.insert_after(inode_previous, *node);
           adjust_first_last_markers_after_insert(&bucket);
           ++inode_previous;
 
@@ -1272,20 +1272,20 @@ namespace etl
     //*************************************************************************
     /// Move from a range
     //*************************************************************************
-    void move(iterator first, iterator last)
+    void move(iterator b, iterator e)
     {
 #if ETL_IS_DEBUG_BUILD
-      difference_type d = etl::distance(first, last);
+      difference_type d = etl::distance(b, e);
       ETL_ASSERT(d >= 0, ETL_ERROR(unordered_set_iterator));
       ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_set_full));
 #endif
 
-      while (first != last)
+      while (b != e)
       {
-        iterator temp = first;
+        iterator temp = b;
         ++temp;
-        insert(etl::move(*first));
-        first = temp;
+        insert(etl::move(*b));
+        b = temp;
       }
     }
 #endif
@@ -1295,10 +1295,10 @@ namespace etl
     //*************************************************************************
     /// Create a node.
     //*************************************************************************
-    node_t& allocate_data_node()
+    node_t* allocate_data_node()
     {
       node_t* (etl::ipool::*func)() = &etl::ipool::allocate<node_t>;
-      return *(pnodepool->*func)();
+      return (pnodepool->*func)();
     }
 
     //*********************************************************************
@@ -1309,7 +1309,7 @@ namespace etl
       if (size() == 1)
       {
         first = pbucket;
-        last = pbucket;
+        last  = pbucket;
       }
       else
       {
@@ -1327,7 +1327,7 @@ namespace etl
     //*********************************************************************
     /// Adjust the first and last markers according to the erased entry.
     //*********************************************************************
-    void adjust_first_last_markers_after_erase(bucket_t* pcurrent)
+    void adjust_first_last_markers_after_erase(bucket_t* pbucket)
     {
       if (empty())
       {
@@ -1336,7 +1336,7 @@ namespace etl
       }
       else
       {
-        if (pcurrent == first)
+        if (pbucket == first)
         {
           // We erased the first so, we need to search again from where we erased.
           while (first->empty())
@@ -1344,29 +1344,29 @@ namespace etl
             ++first;
           }
         }
-        else if (pcurrent == last)
+        else if (pbucket == last)
         {
           // We erased the last, so we need to search again. Start from the first, go no further than the current last.
-          bucket_t* pcurrent = first;
+          pbucket = first;
           bucket_t* pend = last;
 
           last = first;
 
-          while (pcurrent != pend)
+          while (pbucket != pend)
           {
-            if (!pcurrent->empty())
+            if (!pbucket->empty())
             {
-              last = pcurrent;
+              last = pbucket;
             }
 
-            ++pcurrent;
+            ++pbucket;
           }
         }
       }
     }
 
     //*********************************************************************
-    /// Delete a data noe at the specified location.
+    /// Delete a data node at the specified location.
     //*********************************************************************
     local_iterator delete_data_node(local_iterator iprevious, local_iterator icurrent, bucket_t& bucket)
     {
@@ -1427,20 +1427,40 @@ namespace etl
   ///\return <b>true</b> if the sets are equal, otherwise <b>false</b>
   ///\ingroup unordered_set
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator ==(const etl::iunordered_set<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_set<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator ==(const etl::iunordered_set<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_set<TKey, THash, TKeyEqual>& rhs)
   {
     const bool sizes_match = (lhs.size() == rhs.size());
     bool elements_match = true;
 
+    typedef typename etl::iunordered_set<TKey, THash, TKeyEqual>::const_iterator itr_t;
+
     if (sizes_match)
     {
-      for (size_t i = 0; (i < lhs.bucket_count()) && elements_match; ++i)
+      itr_t l_begin = lhs.begin();
+      itr_t l_end   = lhs.end();
+
+      while ((l_begin != l_end) && elements_match)
       {
-        if (!etl::is_permutation(lhs.begin(i), lhs.end(i), rhs.begin(i)))
+        const TKey l_value = *l_begin;
+
+        // See if the lhs key exists in the rhs.
+        ETL_OR_STD::pair<itr_t, itr_t> range = rhs.equal_range(l_value);
+
+        if (range.first != rhs.end())
+        {
+          // See if the values match
+          const TKey r_value = *(range.first);
+
+          elements_match = (r_value == l_value);
+        }
+        else
         {
           elements_match = false;
         }
+
+        ++l_begin;
       }
     }
 
@@ -1454,8 +1474,9 @@ namespace etl
   ///\return <b>true</b> if the sets are not equal, otherwise <b>false</b>
   ///\ingroup unordered_set
   //***************************************************************************
-  template <typename TKey, typename TMapped, typename TKeyCompare>
-  bool operator !=(const etl::iunordered_set<TKey, TMapped, TKeyCompare>& lhs, const etl::iunordered_set<TKey, TMapped, TKeyCompare>& rhs)
+  template <typename TKey, typename THash, typename TKeyEqual>
+  bool operator !=(const etl::iunordered_set<TKey, THash, TKeyEqual>& lhs, 
+                   const etl::iunordered_set<TKey, THash, TKeyEqual>& rhs)
   {
     return !(lhs == rhs);
   }
diff --git a/src/etl/variant_pool.h b/src/etl/variant_pool.h
index cb5ae7f..d97b735 100644
--- a/src/etl/variant_pool.h
+++ b/src/etl/variant_pool.h
@@ -61,6 +61,120 @@ SOFTWARE.
 
 namespace etl
 {
+#if ETL_USING_CPP11 && !defined(ETL_VARIANT_POOL_FORCE_CPP03_IMPLEMENTATION)
+  //***************************************************************************
+  template <size_t MAX_SIZE_, typename ... Ts>
+  class variant_pool
+    : public etl::generic_pool<etl::largest<Ts...>::size,
+                               etl::largest<Ts...>::alignment,
+                               MAX_SIZE_>
+  {
+  public:
+
+    typedef etl::generic_pool<etl::largest<Ts...>::size,
+                              etl::largest<Ts...>::alignment,
+                              MAX_SIZE_> base_t;
+
+    static const size_t MAX_SIZE = MAX_SIZE_;
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    variant_pool()
+    {
+    }
+
+    //*************************************************************************
+    /// Creates the object from a type. Variadic parameter constructor.
+    //*************************************************************************
+    template <typename T, typename... Args>
+    T* create(Args&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value), "Unsupported type");
+
+      return base_t::template create<T>(etl::forward<Args>(args)...);
+    }
+
+    //*************************************************************************
+    /// Destroys the object.
+    //*************************************************************************
+    template <typename T>
+    void destroy(const T* const p)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value || etl::is_base_of_any<T, Ts...>::value), "Invalid type");
+
+      base_t::destroy(p);
+    }
+
+    //*************************************************************************
+    /// Returns the maximum number of items in the variant_pool.
+    //*************************************************************************
+    size_t max_size() const
+    {
+      return MAX_SIZE;
+    }
+
+  private:
+
+    variant_pool(const variant_pool&) ETL_DELETE;
+    variant_pool& operator =(const variant_pool&) ETL_DELETE;
+  };
+
+  //***************************************************************************
+  template <typename ... Ts>
+  class variant_pool_ext
+    : public etl::generic_pool_ext<etl::largest<Ts...>::size,
+                                   etl::largest<Ts...>::alignment>
+  {
+  public:
+
+    typedef etl::generic_pool_ext<etl::largest<Ts...>::size,
+                                  etl::largest<Ts...>::alignment> base_t;
+
+    //*************************************************************************
+    /// Default constructor.
+    //*************************************************************************
+    variant_pool_ext(typename base_t::element* buffer, size_t size)
+      : base_t(buffer, size)
+    {
+    }
+
+    //*************************************************************************
+    /// Creates the object from a type. Variadic parameter constructor.
+    //*************************************************************************
+    template <typename T, typename... Args>
+    T* create(Args&&... args)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value), "Unsupported type");
+
+      return base_t::template create<T>(etl::forward<Args>(args)...);
+    }
+
+    //*************************************************************************
+    /// Destroys the object.
+    //*************************************************************************
+    template <typename T>
+    void destroy(const T* const p)
+    {
+      ETL_STATIC_ASSERT((etl::is_one_of<T, Ts...>::value || etl::is_base_of_any<T, Ts...>::value), "Invalid type");
+
+      base_t::destroy(p);
+    }
+
+    //*************************************************************************
+    /// Returns the maximum number of items in the variant_pool.
+    //*************************************************************************
+    size_t max_size() const
+    {
+      return base_t::max_size();
+    }
+
+  private:
+
+    variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
+    variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
+  };
+#else
   //***************************************************************************
   template <size_t MAX_SIZE_,
             typename T1,
@@ -350,6 +464,7 @@ namespace etl
     variant_pool_ext(const variant_pool_ext&) ETL_DELETE;
     variant_pool_ext& operator =(const variant_pool_ext&) ETL_DELETE;
   };
+#endif
 }
 
 #endif
diff --git a/src/etl/vector.h b/src/etl/vector.h
index af236dc..4150c44 100644
--- a/src/etl/vector.h
+++ b/src/etl/vector.h
@@ -1346,11 +1346,9 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
-#ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
 #endif
     {
       ETL_ASSERT_OR_RETURN(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::vector_incompatible_type));
@@ -1527,9 +1525,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }
@@ -1649,9 +1648,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(buffer);
@@ -1806,9 +1806,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #ifdef ETL_IVECTOR_REPAIR_ENABLE
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
       etl::ivector<T*>::repair_buffer(this->p_buffer);
diff --git a/src/etl/version.h b/src/etl/version.h
index eb1b2fb..03eeaa2 100644
--- a/src/etl/version.h
+++ b/src/etl/version.h
@@ -40,7 +40,7 @@ SOFTWARE.
 
 #define ETL_VERSION_MAJOR 20
 #define ETL_VERSION_MINOR 38
-#define ETL_VERSION_PATCH 11
+#define ETL_VERSION_PATCH 17
 
 #define ETL_VERSION       ETL_STRING(ETL_VERSION_MAJOR) "." ETL_STRING(ETL_VERSION_MINOR) "." ETL_STRING(ETL_VERSION_PATCH)
 #define ETL_VERSION_W     ETL_WIDE_STRING(ETL_VERSION_MAJOR) L"." ETL_WIDE_STRING(ETL_VERSION_MINOR) L"." ETL_WIDE_STRING(ETL_VERSION_PATCH)
diff --git a/src/etl/wstring.h b/src/etl/wstring.h
index 20ce4ac..683359d 100644
--- a/src/etl/wstring.h
+++ b/src/etl/wstring.h
@@ -231,9 +231,10 @@ namespace etl
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
 #if ETL_HAS_ISTRING_REPAIR
-    virtual
-#endif
+    virtual void repair() ETL_OVERRIDE
+#else
     void repair()
+#endif
     {
       etl::iwstring::repair_buffer(buffer);
     }
@@ -414,9 +415,10 @@ namespace etl
     //*************************************************************************
     /// Fix the internal pointers after a low level memory copy.
     //*************************************************************************
-    void repair()
 #if ETL_HAS_ISTRING_REPAIR
-      ETL_OVERRIDE
+    virtual void repair() ETL_OVERRIDE
+#else
+    void repair()
 #endif
     {
     }