Added and fixed noexcept attributes

Added ETL_NOEXCEPT_FROM to set noexcept attributes based on an object or function.

# Conflicts:
#	include/etl/platform.h

Author: John Wellbelove

include/etl/array.h

@@ -397,7 +397,7 @@ namespace etl
     /// Swaps the contents of this array and another.
     ///\param other A reference to the other array.
     //*************************************************************************
-    ETL_CONSTEXPR14 void swap(array& other) ETL_NOEXCEPT
+    ETL_CONSTEXPR14 void swap(array& other) ETL_NOEXCEPT_FROM(ETL_OR_STD::swap(etl::declval<T&>(), etl::declval<T&>()))
     {
       using ETL_OR_STD::swap; // Allow ADL
 

include/etl/array_view.h

@@ -123,7 +123,7 @@ namespace etl
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
-    ETL_CONSTEXPR array_view()
+    ETL_CONSTEXPR array_view() ETL_NOEXCEPT
       : mbegin(ETL_NULLPTR),
         mend(ETL_NULLPTR)
     {
@@ -238,7 +238,7 @@ namespace etl
     /// Construct from iterators
     //*************************************************************************
     template <typename TIterator>
-    ETL_CONSTEXPR array_view(const TIterator begin_, const TIterator end_)
+    ETL_CONSTEXPR array_view(const TIterator begin_, const TIterator end_) ETL_NOEXCEPT
       : mbegin(etl::to_address(begin_)),
         mend(etl::to_address(begin_) + etl::distance(begin_, end_))
     {
@@ -249,7 +249,7 @@ namespace etl
     //*************************************************************************
     template <typename TIterator,
               typename TSize>
-    ETL_CONSTEXPR array_view(const TIterator begin_, const TSize size_)
+    ETL_CONSTEXPR array_view(const TIterator begin_, const TSize size_) ETL_NOEXCEPT
       : mbegin(etl::to_address(begin_)),
         mend(etl::to_address(begin_) + size_)
     {
@@ -259,7 +259,7 @@ namespace etl
     /// Construct from C array
     //*************************************************************************
     template<size_t Array_Size>
-    ETL_CONSTEXPR array_view(T(&begin_)[Array_Size])
+    ETL_CONSTEXPR array_view(T(&begin_)[Array_Size]) ETL_NOEXCEPT
       : mbegin(begin_),
         mend(begin_ + Array_Size)
     {
@@ -268,7 +268,7 @@ namespace etl
     //*************************************************************************
     /// Copy constructor
     //*************************************************************************
-    ETL_CONSTEXPR array_view(const array_view& other)
+    ETL_CONSTEXPR array_view(const array_view& other) ETL_NOEXCEPT
       : mbegin(other.mbegin),
         mend(other.mend)
     {
@@ -309,143 +309,143 @@ namespace etl
     //*************************************************************************
     /// Returns a pointer to the first element of the internal storage.
     //*************************************************************************
-    pointer data()
+    pointer data() ETL_NOEXCEPT
     {
       return mbegin;
     }
 
     //*************************************************************************
     /// Returns a const pointer to the first element of the internal storage.
     //*************************************************************************
-    const_pointer data() const
+    const_pointer data() const ETL_NOEXCEPT
     {
       return mbegin;
     }
 
     //*************************************************************************
     /// Returns an iterator to the beginning of the array.
     //*************************************************************************
-    iterator begin()
+    iterator begin() ETL_NOEXCEPT
     {
       return mbegin;
     }
 
     //*************************************************************************
     /// Returns a const iterator to the beginning of the array.
     //*************************************************************************
-    const_iterator begin() const
+    const_iterator begin() const ETL_NOEXCEPT
     {
       return mbegin;
     }
 
     //*************************************************************************
     /// Returns a const iterator to the beginning of the array.
     //*************************************************************************
-    const_iterator cbegin() const
+    const_iterator cbegin() const ETL_NOEXCEPT
     {
       return mbegin;
     }
 
     //*************************************************************************
     /// Returns an iterator to the end of the array.
     //*************************************************************************
-    iterator end()
+    iterator end() ETL_NOEXCEPT
     {
       return mend;
     }
 
     //*************************************************************************
     /// Returns a const iterator to the end of the array.
     //*************************************************************************
-    const_iterator end() const
+    const_iterator end() const ETL_NOEXCEPT
     {
       return mend;
     }
 
     //*************************************************************************
     // Returns a const iterator to the end of the array.
     //*************************************************************************
-    const_iterator cend() const
+    const_iterator cend() const ETL_NOEXCEPT
     {
       return mend;
     }
 
     //*************************************************************************
     // Returns an reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    reverse_iterator rbegin()
+    reverse_iterator rbegin() ETL_NOEXCEPT
     {
       return reverse_iterator(mend);
     }
 
     //*************************************************************************
     /// Returns a const reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    const_reverse_iterator rbegin() const
+    const_reverse_iterator rbegin() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mend);
     }
 
     //*************************************************************************
     /// Returns a const reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    const_reverse_iterator crbegin() const
+    const_reverse_iterator crbegin() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mend);
     }
 
     //*************************************************************************
     /// Returns a reverse iterator to the end of the array.
     //*************************************************************************
-    reverse_iterator rend()
+    reverse_iterator rend() ETL_NOEXCEPT
     {
       return reverse_iterator(mbegin);
     }
 
     //*************************************************************************
     /// Returns a const reverse iterator to the end of the array.
     //*************************************************************************
-    const_reverse_iterator rend() const
+    const_reverse_iterator rend() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mbegin);
     }
 
     //*************************************************************************
     /// Returns a const reverse iterator to the end of the array.
     //*************************************************************************
-    const_reverse_iterator crend() const
+    const_reverse_iterator crend() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mbegin);
     }
 
     //*************************************************************************
     /// Returns <b>true</b> if the array size is zero.
     //*************************************************************************
-    ETL_CONSTEXPR bool empty() const
+    ETL_CONSTEXPR bool empty() const ETL_NOEXCEPT
     {
       return (mbegin == mend);
     }
 
     //*************************************************************************
     /// Returns the size of the array.
     //*************************************************************************
-    ETL_CONSTEXPR size_t size() const
+    ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
     {
       return static_cast<size_t>(mend - mbegin);
     }
 
     //*************************************************************************
     /// Returns the maximum possible size of the array.
     //*************************************************************************
-    ETL_CONSTEXPR size_t max_size() const
+    ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
     {
       return size();
     }
 
     //*************************************************************************
     /// Assign from a view.
     //*************************************************************************
-    array_view& operator=(const array_view& other)
+    array_view& operator=(const array_view& other) ETL_NOEXCEPT
     {
       mbegin = other.mbegin;
       mend   = other.mend;
@@ -477,7 +477,7 @@ namespace etl
     //*************************************************************************
     /// Returns a reference to the indexed value.
     //*************************************************************************
-    reference operator[](const size_t i)
+    reference operator[](const size_t i) ETL_NOEXCEPT
     {
       return mbegin[i];
     }
@@ -486,7 +486,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reference to the indexed value.
     //*************************************************************************
-    const_reference operator[](const size_t i) const
+    const_reference operator[](const size_t i) const ETL_NOEXCEPT
     {
       return mbegin[i];
     }
@@ -516,7 +516,7 @@ namespace etl
     //*************************************************************************
     /// Swaps with another array_view.
     //*************************************************************************
-    void swap(array_view& other)
+    void swap(array_view& other) ETL_NOEXCEPT
     {
       using ETL_OR_STD::swap; // Allow ADL
 
@@ -527,7 +527,7 @@ namespace etl
     //*************************************************************************
     /// Shrinks the view by moving its start forward.
     //*************************************************************************
-    void remove_prefix(const size_type n)
+    void remove_prefix(const size_type n) ETL_NOEXCEPT
     {
 		if (n < size())
 			mbegin += n;
@@ -538,7 +538,7 @@ namespace etl
     //*************************************************************************
     /// Shrinks the view by moving its end backward.
     //*************************************************************************
-    void remove_suffix(const size_type n)
+    void remove_suffix(const size_type n) ETL_NOEXCEPT
     {
 		if (n < size())
 			mend -= n;
@@ -647,7 +647,7 @@ namespace etl
 /// Swaps the values.
 //*************************************************************************
 template <typename T>
-void swap(etl::array_view<T>& lhs, etl::array_view<T>& rhs)
+void swap(etl::array_view<T>& lhs, etl::array_view<T>& rhs) ETL_NOEXCEPT
 {
   lhs.swap(rhs);
 }