coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-07-30 16:26:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Made all 'noexcept' statements use ETL_NOEXCEPT macro (#1179)

Browse Source 
* Added coderabbitai configuration

* Made all 'noexcept' statements use ETL_NOEXCEPT macro

---------

Co-authored-by: John Wellbelove <john.wellbelove@asterconsulting.co.uk>
Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>
This commit is contained in:
David Ockey 2025-09-06 03:32:03 -05:00 committed by GitHub
parent e760e62dcd
commit b85b071a3e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 62 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.coderabbit.yaml
View File

@ -197,4 +197,3 @@ reviews:
chat: chat:
art: false art: false
auto_reply: true auto_reply: true

24
include/etl/byte.h
View File

@ -41,7 +41,7 @@ namespace etl
template <typename TInteger> template <typename TInteger>
constexpr constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type typename etl::enable_if<etl::is_integral<TInteger>::value, TInteger>::type
to_integer(etl::byte b) noexcept to_integer(etl::byte b) ETL_NOEXCEPT
{ {
return TInteger(b); return TInteger(b);
} }
@ -52,7 +52,7 @@ namespace etl
template <typename TInteger> template <typename TInteger>
constexpr constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator <<(etl::byte b, TInteger shift) noexcept operator <<(etl::byte b, TInteger shift) ETL_NOEXCEPT
{ {
return etl::byte(static_cast<unsigned int>(b) << shift); return etl::byte(static_cast<unsigned int>(b) << shift);
} }
@ -63,7 +63,7 @@ namespace etl
template <typename TInteger> template <typename TInteger>
constexpr constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte>::type
operator >>(etl::byte b, TInteger shift) noexcept operator >>(etl::byte b, TInteger shift) ETL_NOEXCEPT
{ {
return etl::byte(static_cast<unsigned int>(b) >> shift); return etl::byte(static_cast<unsigned int>(b) >> shift);
} }
@ -74,7 +74,7 @@ namespace etl
template <typename TInteger> template <typename TInteger>
constexpr constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator <<=(etl::byte& b, TInteger shift) noexcept operator <<=(etl::byte& b, TInteger shift) ETL_NOEXCEPT
{ {
return b = b << shift;; return b = b << shift;;
} }
@ -85,7 +85,7 @@ namespace etl
template <typename TInteger> template <typename TInteger>
constexpr constexpr
typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type typename etl::enable_if<etl::is_integral<TInteger>::value, etl::byte&>::type
operator >>=(etl::byte& b, TInteger shift) noexcept operator >>=(etl::byte& b, TInteger shift) ETL_NOEXCEPT
{ {
return b = b >> shift; return b = b >> shift;
} }
@ -93,7 +93,7 @@ namespace etl
//************************************************************************* //*************************************************************************
/// Or. /// Or.
//************************************************************************* //*************************************************************************
inline constexpr etl::byte operator |(etl::byte lhs, etl::byte rhs) noexcept inline constexpr etl::byte operator |(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
{ {
return etl::byte(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs)); return etl::byte(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
} }
@ -101,7 +101,7 @@ namespace etl
//************************************************************************* //*************************************************************************
/// And. /// And.
//************************************************************************* //*************************************************************************
inline constexpr etl::byte operator &(etl::byte lhs, etl::byte rhs) noexcept inline constexpr etl::byte operator &(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
{ {
return etl::byte(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs)); return etl::byte(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
} }
@ -109,7 +109,7 @@ namespace etl
//************************************************************************* //*************************************************************************
/// Exclusive Or. /// Exclusive Or.
//************************************************************************* //*************************************************************************
inline constexpr etl::byte operator ^(etl::byte lhs, etl::byte rhs) noexcept inline constexpr etl::byte operator ^(etl::byte lhs, etl::byte rhs) ETL_NOEXCEPT
{ {
return etl::byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs)); return etl::byte(static_cast<unsigned int>(lhs) ^ static_cast<unsigned int>(rhs));
} }
@ -117,7 +117,7 @@ namespace etl
//************************************************************************* //*************************************************************************
/// Or equals. /// Or equals.
//************************************************************************* //*************************************************************************
inline ETL_CONSTEXPR14 etl::byte& operator |=(etl::byte& lhs, etl::byte rhs) noexcept inline ETL_CONSTEXPR14 etl::byte& operator |=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
{ {
return lhs = lhs | rhs; return lhs = lhs | rhs;
} }
@ -125,7 +125,7 @@ namespace etl
//************************************************************************* //*************************************************************************
/// And equals /// And equals
//************************************************************************* //*************************************************************************
inline ETL_CONSTEXPR14 etl::byte& operator &=(etl::byte& lhs, etl::byte rhs) noexcept inline ETL_CONSTEXPR14 etl::byte& operator &=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
{ {
return lhs = lhs & rhs; return lhs = lhs & rhs;
} }
@ -133,7 +133,7 @@ namespace etl
//************************************************************************* //*************************************************************************
/// Exclusive or equals. /// Exclusive or equals.
//************************************************************************* //*************************************************************************
inline ETL_CONSTEXPR14 etl::byte& operator ^=(etl::byte& lhs, etl::byte rhs) noexcept inline ETL_CONSTEXPR14 etl::byte& operator ^=(etl::byte& lhs, etl::byte rhs) ETL_NOEXCEPT
{ {
return lhs = lhs ^ rhs; return lhs = lhs ^ rhs;
} }
@ -141,7 +141,7 @@ namespace etl
//************************************************************************* //*************************************************************************
/// Not. /// Not.
//************************************************************************* //*************************************************************************
inline constexpr etl::byte operator ~(etl::byte b) noexcept inline constexpr etl::byte operator ~(etl::byte b) ETL_NOEXCEPT
{ {
return etl::byte(~static_cast<unsigned int>(b)); return etl::byte(~static_cast<unsigned int>(b));
} }

28
include/etl/initializer_list.h
View File

@ -71,7 +71,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Default constructor /// Default constructor
//************************************************************************* //*************************************************************************
constexpr initializer_list() noexcept constexpr initializer_list() ETL_NOEXCEPT
: pfirst(nullptr), plast(nullptr) : pfirst(nullptr), plast(nullptr)
{ {
} }
@ -79,7 +79,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Constructor /// Constructor
//************************************************************************* //*************************************************************************
constexpr initializer_list(const T* pfirst_, const T* plast_) noexcept constexpr initializer_list(const T* pfirst_, const T* plast_) ETL_NOEXCEPT
: pfirst(pfirst_), plast(plast_) : pfirst(pfirst_), plast(plast_)
{ {
} }
@ -87,7 +87,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Get the beginning of the list. /// Get the beginning of the list.
//************************************************************************* //*************************************************************************
constexpr const T* begin() const noexcept constexpr const T* begin() const ETL_NOEXCEPT
{ {
return pfirst; return pfirst;
} }
@ -95,7 +95,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Get the end of the list. /// Get the end of the list.
//************************************************************************* //*************************************************************************
constexpr const T* end() const noexcept constexpr const T* end() const ETL_NOEXCEPT
{ {
return plast; return plast;
} }
@ -103,7 +103,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Get the size of the list. /// Get the size of the list.
//************************************************************************* //*************************************************************************
constexpr size_t size() const noexcept constexpr size_t size() const ETL_NOEXCEPT
{ {
return static_cast<size_t>(plast - pfirst); return static_cast<size_t>(plast - pfirst);
} }
@ -118,7 +118,7 @@ namespace std
/// Get the beginning of the list. /// Get the beginning of the list.
//************************************************************************* //*************************************************************************
template<typename T> template<typename T>
constexpr const T* begin(initializer_list<T> init) noexcept constexpr const T* begin(initializer_list<T> init) ETL_NOEXCEPT
{ {
return init.begin(); return init.begin();
} }
@ -127,7 +127,7 @@ namespace std
/// Get the end of the list. /// Get the end of the list.
//************************************************************************* //*************************************************************************
template <typename T> template <typename T>
constexpr const T* end(initializer_list<T> init) noexcept constexpr const T* end(initializer_list<T> init) ETL_NOEXCEPT
{ {
return init.end(); return init.end();
} }
@ -154,7 +154,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Default constructor /// Default constructor
//************************************************************************* //*************************************************************************
constexpr initializer_list() noexcept constexpr initializer_list() ETL_NOEXCEPT
: pfirst(nullptr), length(0) : pfirst(nullptr), length(0)
{ {
} }
@ -162,7 +162,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Get the beginning of the list. /// Get the beginning of the list.
//************************************************************************* //*************************************************************************
constexpr const T* begin() const noexcept constexpr const T* begin() const ETL_NOEXCEPT
{ {
return pfirst; return pfirst;
} }
@ -170,7 +170,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Get the end of the list. /// Get the end of the list.
//************************************************************************* //*************************************************************************
constexpr const T* end() const noexcept constexpr const T* end() const ETL_NOEXCEPT
{ {
return pfirst + length; return pfirst + length;
} }
@ -178,7 +178,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Get the size of the list. /// Get the size of the list.
//************************************************************************* //*************************************************************************
constexpr size_t size() const noexcept constexpr size_t size() const ETL_NOEXCEPT
{ {
return length; return length;
} }
@ -188,7 +188,7 @@ namespace std
//************************************************************************* //*************************************************************************
/// Constructor /// Constructor
//************************************************************************* //*************************************************************************
constexpr initializer_list(const T* pfirst_, size_t length_) noexcept constexpr initializer_list(const T* pfirst_, size_t length_) ETL_NOEXCEPT
: pfirst(pfirst_) : pfirst(pfirst_)
, length(length_) , length(length_)
{ {
@ -202,7 +202,7 @@ namespace std
/// Get the beginning of the list. /// Get the beginning of the list.
//************************************************************************* //*************************************************************************
template<class T> template<class T>
constexpr const T* begin(initializer_list<T> init) noexcept constexpr const T* begin(initializer_list<T> init) ETL_NOEXCEPT
{ {
return init.begin(); return init.begin();
} }
@ -211,7 +211,7 @@ namespace std
/// Get the end of the list. /// Get the end of the list.
//************************************************************************* //*************************************************************************
template<class T> template<class T>
constexpr const T* end(initializer_list<T> init) noexcept constexpr const T* end(initializer_list<T> init) ETL_NOEXCEPT
{ {
return init.end(); return init.end();
} }

6
include/etl/private/chrono/day.h
View File

@ -259,7 +259,7 @@ namespace etl
/// Spaceship operator /// Spaceship operator
//*********************************************************************** //***********************************************************************
#if ETL_USING_CPP20 #if ETL_USING_CPP20
[[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::day& d1, const etl::chrono::day& d2) noexcept [[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::day& d1, const etl::chrono::day& d2) ETL_NOEXCEPT
{ {
return (static_cast<unsigned>(d1) <=> static_cast<unsigned>(d2)); return (static_cast<unsigned>(d1) <=> static_cast<unsigned>(d2));
} }
@ -341,9 +341,9 @@ namespace etl
inline namespace chrono_literals inline namespace chrono_literals
{ {
#if ETL_USING_VERBOSE_CHRONO_LITERALS #if ETL_USING_VERBOSE_CHRONO_LITERALS
inline ETL_CONSTEXPR14 etl::chrono::day operator ""_day(unsigned long long d) noexcept inline ETL_CONSTEXPR14 etl::chrono::day operator ""_day(unsigned long long d) ETL_NOEXCEPT
#else #else
inline ETL_CONSTEXPR14 etl::chrono::day operator ""_d(unsigned long long d) noexcept inline ETL_CONSTEXPR14 etl::chrono::day operator ""_d(unsigned long long d) ETL_NOEXCEPT
#endif #endif
{ {
return etl::chrono::day(static_cast<unsigned>(d)); return etl::chrono::day(static_cast<unsigned>(d));

2
include/etl/private/chrono/month.h
View File

@ -261,7 +261,7 @@ namespace etl
/// Spaceship operator /// Spaceship operator
//*********************************************************************** //***********************************************************************
#if ETL_USING_CPP20 #if ETL_USING_CPP20
[[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::month& d1, const etl::chrono::month& d2) noexcept [[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::month& d1, const etl::chrono::month& d2) ETL_NOEXCEPT
{ {
return (static_cast<unsigned>(d1) <=> static_cast<unsigned>(d2)); return (static_cast<unsigned>(d1) <=> static_cast<unsigned>(d2));
} }

4
include/etl/private/chrono/month_day.h
View File

@ -193,7 +193,7 @@ namespace etl
//*********************************************************************** //***********************************************************************
#if ETL_USING_CPP20 #if ETL_USING_CPP20
[[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::month_day& lhs, [[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::month_day& lhs,
const etl::chrono::month_day& rhs) noexcept const etl::chrono::month_day& rhs) ETL_NOEXCEPT
{ {
auto cmp = lhs.month() <=> rhs.month(); auto cmp = lhs.month() <=> rhs.month();
@ -321,7 +321,7 @@ namespace etl
/// Spaceship operator /// Spaceship operator
//*********************************************************************** //***********************************************************************
#if ETL_USING_CPP20 #if ETL_USING_CPP20
[[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::month_day_last& mdl1, const etl::chrono::month_day_last& mdl2) noexcept [[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::month_day_last& mdl1, const etl::chrono::month_day_last& mdl2) ETL_NOEXCEPT
{ {
return (static_cast<unsigned>(mdl1.month()) <=> static_cast<unsigned>(mdl2.month())); return (static_cast<unsigned>(mdl1.month()) <=> static_cast<unsigned>(mdl2.month()));
} }

2
include/etl/private/chrono/time_point.h
View File

@ -268,7 +268,7 @@ namespace etl
//*********************************************************************** //***********************************************************************
#if ETL_USING_CPP20 #if ETL_USING_CPP20
template <typename TClock, typename TDuration1, typename TDuration2> template <typename TClock, typename TDuration1, typename TDuration2>
[[nodiscard]] constexpr auto operator <=>(const etl::chrono::time_point<TClock, TDuration1>& lhs, const etl::chrono::time_point<TClock, TDuration2>& rhs) noexcept [[nodiscard]] constexpr auto operator <=>(const etl::chrono::time_point<TClock, TDuration1>& lhs, const etl::chrono::time_point<TClock, TDuration2>& rhs) ETL_NOEXCEPT
{ {
return (lhs.time_since_epoch() <=> rhs.time_since_epoch()); return (lhs.time_since_epoch() <=> rhs.time_since_epoch());
} }

6
include/etl/private/chrono/year.h
View File

@ -259,7 +259,7 @@ namespace etl
/// Spaceship operator /// Spaceship operator
//*********************************************************************** //***********************************************************************
#if ETL_USING_CPP20 #if ETL_USING_CPP20
[[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::year& y1, const etl::chrono::year& y2) noexcept [[nodiscard]] inline constexpr auto operator <=>(const etl::chrono::year& y1, const etl::chrono::year& y2) ETL_NOEXCEPT
{ {
return (static_cast<unsigned>(y1) <=> static_cast<unsigned>(y2)); return (static_cast<unsigned>(y1) <=> static_cast<unsigned>(y2));
} }
@ -357,9 +357,9 @@ namespace etl
/// Literal for years /// Literal for years
//*********************************************************************** //***********************************************************************
#if ETL_USING_VERBOSE_CHRONO_LITERALS #if ETL_USING_VERBOSE_CHRONO_LITERALS
inline ETL_CONSTEXPR14 etl::chrono::year operator ""_year(unsigned long long y) noexcept inline ETL_CONSTEXPR14 etl::chrono::year operator ""_year(unsigned long long y) ETL_NOEXCEPT
#else #else
inline ETL_CONSTEXPR14 etl::chrono::year operator ""_y(unsigned long long y) noexcept inline ETL_CONSTEXPR14 etl::chrono::year operator ""_y(unsigned long long y) ETL_NOEXCEPT
#endif #endif
{ {
return etl::chrono::year(static_cast<int16_t>(y)); return etl::chrono::year(static_cast<int16_t>(y));

42
include/etl/private/variant_variadic.h
View File

@ -268,7 +268,7 @@ namespace etl
//*********************************** //***********************************
// holds_alternative. Forward declaration // holds_alternative. Forward declaration
template <typename T, typename... TTypes> template <typename T, typename... TTypes>
ETL_CONSTEXPR14 bool holds_alternative(const etl::variant<TTypes...>& v) noexcept; ETL_CONSTEXPR14 bool holds_alternative(const etl::variant<TTypes...>& v) ETL_NOEXCEPT;
//*********************************** //***********************************
// get. Forward declarations // get. Forward declarations
@ -305,14 +305,14 @@ namespace etl
#include "variant_select_do_operator.h" #include "variant_select_do_operator.h"
#endif #endif
constexpr bool operator >(etl::monostate, etl::monostate) noexcept { return false; } constexpr bool operator >(etl::monostate, etl::monostate) ETL_NOEXCEPT { return false; }
constexpr bool operator <(etl::monostate, etl::monostate) noexcept { return false; } constexpr bool operator <(etl::monostate, etl::monostate) ETL_NOEXCEPT { return false; }
constexpr bool operator !=(etl::monostate, etl::monostate) noexcept { return false; } constexpr bool operator !=(etl::monostate, etl::monostate) ETL_NOEXCEPT { return false; }
constexpr bool operator <=(etl::monostate, etl::monostate) noexcept { return true; } constexpr bool operator <=(etl::monostate, etl::monostate) ETL_NOEXCEPT { return true; }
constexpr bool operator >=(etl::monostate, etl::monostate) noexcept { return true; } constexpr bool operator >=(etl::monostate, etl::monostate) ETL_NOEXCEPT { return true; }
constexpr bool operator ==(etl::monostate, etl::monostate) noexcept { return true; } constexpr bool operator ==(etl::monostate, etl::monostate) ETL_NOEXCEPT { return true; }
#if ETL_USING_CPP20 && ETL_USING_STL && !(defined(ETL_DEVELOPMENT_OS_APPLE) && defined(ETL_COMPILER_CLANG)) #if ETL_USING_CPP20 && ETL_USING_STL && !(defined(ETL_DEVELOPMENT_OS_APPLE) && defined(ETL_COMPILER_CLANG))
constexpr std::strong_ordering operator<=>(monostate, monostate) noexcept constexpr std::strong_ordering operator<=>(monostate, monostate) ETL_NOEXCEPT
{ {
return std::strong_ordering::equal; return std::strong_ordering::equal;
} }
@ -782,7 +782,7 @@ namespace etl
/// Checks whether a valid value is currently stored. /// Checks whether a valid value is currently stored.
///\return <b>true</b> if the value is valid, otherwise <b>false</b>. ///\return <b>true</b> if the value is valid, otherwise <b>false</b>.
//*************************************************************************** //***************************************************************************
constexpr bool valueless_by_exception() const noexcept constexpr bool valueless_by_exception() const ETL_NOEXCEPT
{ {
return type_id == variant_npos; return type_id == variant_npos;
} }
@ -790,7 +790,7 @@ namespace etl
//*************************************************************************** //***************************************************************************
/// Gets the index of the type currently stored or variant_npos /// Gets the index of the type currently stored or variant_npos
//*************************************************************************** //***************************************************************************
constexpr size_t index() const noexcept constexpr size_t index() const ETL_NOEXCEPT
{ {
return type_id; return type_id;
} }
@ -812,14 +812,14 @@ namespace etl
///\return <b>true</b> if it is the specified type, otherwise <b>false</b>. ///\return <b>true</b> if it is the specified type, otherwise <b>false</b>.
//*************************************************************************** //***************************************************************************
template <typename T, etl::enable_if_t<is_supported_type<T>(), int> = 0> template <typename T, etl::enable_if_t<is_supported_type<T>(), int> = 0>
constexpr bool is_type() const noexcept constexpr bool is_type() const ETL_NOEXCEPT
{ {
return (type_id == index_of_type<T>::value); return (type_id == index_of_type<T>::value);
} }
//*************************************************************************** //***************************************************************************
template <typename T, etl::enable_if_t<!is_supported_type<T>(), int> = 0> template <typename T, etl::enable_if_t<!is_supported_type<T>(), int> = 0>
constexpr bool is_type() const noexcept constexpr bool is_type() const ETL_NOEXCEPT
{ {
return false; return false;
} }
@ -838,7 +838,7 @@ namespace etl
//*************************************************************************** //***************************************************************************
/// Swaps this variant with another. /// Swaps this variant with another.
//*************************************************************************** //***************************************************************************
void swap(variant& rhs) noexcept void swap(variant& rhs) ETL_NOEXCEPT
{ {
variant temp(etl::move(*this)); variant temp(etl::move(*this));
*this = etl::move(rhs); *this = etl::move(rhs);
@ -1221,7 +1221,7 @@ namespace etl
/// Checks if the variant v holds the alternative T. /// Checks if the variant v holds the alternative T.
//*************************************************************************** //***************************************************************************
template <typename T, typename... TTypes> template <typename T, typename... TTypes>
ETL_CONSTEXPR14 bool holds_alternative(const etl::variant<TTypes...>& v) noexcept ETL_CONSTEXPR14 bool holds_alternative(const etl::variant<TTypes...>& v) ETL_NOEXCEPT
{ {
constexpr size_t Index = etl::type_list_index_of_type<etl::type_list<TTypes...>, T>::value; constexpr size_t Index = etl::type_list_index_of_type<etl::type_list<TTypes...>, T>::value;
@ -1232,7 +1232,7 @@ namespace etl
/// Checks if the variant v holds the alternative Index. /// Checks if the variant v holds the alternative Index.
//*************************************************************************** //***************************************************************************
template <size_t Index, typename... TTypes> template <size_t Index, typename... TTypes>
ETL_CONSTEXPR14 bool holds_alternative(const etl::variant<TTypes...>& v) noexcept ETL_CONSTEXPR14 bool holds_alternative(const etl::variant<TTypes...>& v) ETL_NOEXCEPT
{ {
return (Index == v.index()); return (Index == v.index());
} }
@ -1241,7 +1241,7 @@ namespace etl
/// Checks if the variant v holds the alternative Index. (Runtime) /// Checks if the variant v holds the alternative Index. (Runtime)
//*************************************************************************** //***************************************************************************
template <typename... TTypes> template <typename... TTypes>
ETL_CONSTEXPR14 bool holds_alternative(size_t index, const etl::variant<TTypes...>& v) noexcept ETL_CONSTEXPR14 bool holds_alternative(size_t index, const etl::variant<TTypes...>& v) ETL_NOEXCEPT
{ {
return (index == v.index()); return (index == v.index());
} }
@ -1351,7 +1351,7 @@ namespace etl
//*************************************************************************** //***************************************************************************
template< size_t Index, typename... TTypes > template< size_t Index, typename... TTypes >
ETL_CONSTEXPR14 etl::add_pointer_t<etl::variant_alternative_t<Index, etl::variant<TTypes...>>> ETL_CONSTEXPR14 etl::add_pointer_t<etl::variant_alternative_t<Index, etl::variant<TTypes...>>>
get_if(etl::variant<TTypes...>* pv) noexcept get_if(etl::variant<TTypes...>* pv) ETL_NOEXCEPT
{ {
if ((pv != nullptr) && (pv->index() == Index)) if ((pv != nullptr) && (pv->index() == Index))
{ {
@ -1366,7 +1366,7 @@ namespace etl
//*********************************** //***********************************
template< size_t Index, typename... TTypes > template< size_t Index, typename... TTypes >
ETL_CONSTEXPR14 etl::add_pointer_t<const etl::variant_alternative_t<Index, etl::variant<TTypes...>>> ETL_CONSTEXPR14 etl::add_pointer_t<const etl::variant_alternative_t<Index, etl::variant<TTypes...>>>
get_if(const etl::variant<TTypes...>* pv) noexcept get_if(const etl::variant<TTypes...>* pv) ETL_NOEXCEPT
{ {
if ((pv != nullptr) && (pv->index() == Index)) if ((pv != nullptr) && (pv->index() == Index))
{ {
@ -1380,7 +1380,7 @@ namespace etl
//*********************************** //***********************************
template< class T, typename... TTypes > template< class T, typename... TTypes >
ETL_CONSTEXPR14 etl::add_pointer_t<T> get_if(etl::variant<TTypes...>* pv) noexcept ETL_CONSTEXPR14 etl::add_pointer_t<T> get_if(etl::variant<TTypes...>* pv) ETL_NOEXCEPT
{ {
constexpr size_t Index = etl::type_list_index_of_type<etl::type_list<TTypes...>, T>::value; constexpr size_t Index = etl::type_list_index_of_type<etl::type_list<TTypes...>, T>::value;
@ -1396,7 +1396,7 @@ namespace etl
//*********************************** //***********************************
template< typename T, typename... TTypes > template< typename T, typename... TTypes >
ETL_CONSTEXPR14 etl::add_pointer_t<const T> get_if(const etl::variant<TTypes...>* pv) noexcept ETL_CONSTEXPR14 etl::add_pointer_t<const T> get_if(const etl::variant<TTypes...>* pv) ETL_NOEXCEPT
{ {
constexpr size_t Index = etl::type_list_index_of_type<etl::type_list<TTypes...>, T>::value; constexpr size_t Index = etl::type_list_index_of_type<etl::type_list<TTypes...>, T>::value;
@ -1561,7 +1561,7 @@ namespace etl
using function_pointer = add_pointer_t<TRet(TCallable&&, TCurVariant&&, TVarRest&&...)>; using function_pointer = add_pointer_t<TRet(TCallable&&, TCurVariant&&, TVarRest&&...)>;
template <size_t tIndex> template <size_t tIndex>
static constexpr function_pointer fptr() noexcept static constexpr function_pointer fptr() ETL_NOEXCEPT
{ {
return &do_visit_single<TRet, TCallable, TCurVariant, tIndex, TVarRest...>; return &do_visit_single<TRet, TCallable, TCurVariant, tIndex, TVarRest...>;
} }

2
include/etl/string.h
View File

@ -48,7 +48,7 @@ namespace etl
{ {
inline namespace string_literals inline namespace string_literals
{ {
inline constexpr etl::string_view operator ""_sv(const char* str, size_t length) noexcept inline constexpr etl::string_view operator ""_sv(const char* str, size_t length) ETL_NOEXCEPT
{ {
return etl::string_view{ str, length }; return etl::string_view{ str, length };
} }

2
include/etl/u16string.h
View File

@ -46,7 +46,7 @@ namespace etl
{ {
inline namespace string_literals inline namespace string_literals
{ {
inline constexpr etl::u16string_view operator ""_sv(const char16_t* str, size_t length) noexcept inline constexpr etl::u16string_view operator ""_sv(const char16_t* str, size_t length) ETL_NOEXCEPT
{ {
return etl::u16string_view{ str, length }; return etl::u16string_view{ str, length };
} }

2
include/etl/u32string.h
View File

@ -46,7 +46,7 @@ namespace etl
{ {
inline namespace string_literals inline namespace string_literals
{ {
inline constexpr etl::u32string_view operator ""_sv(const char32_t* str, size_t length) noexcept inline constexpr etl::u32string_view operator ""_sv(const char32_t* str, size_t length) ETL_NOEXCEPT
{ {
return etl::u32string_view{ str, length }; return etl::u32string_view{ str, length };
} }

2
include/etl/u8string.h
View File

@ -49,7 +49,7 @@ namespace etl
{ {
inline namespace string_literals inline namespace string_literals
{ {
inline constexpr etl::u8string_view operator ""_sv(const char8_t* str, size_t length) noexcept inline constexpr etl::u8string_view operator ""_sv(const char8_t* str, size_t length) ETL_NOEXCEPT
{ {
return etl::u8string_view{ str, length }; return etl::u8string_view{ str, length };
} }

2
include/etl/wstring.h
View File

@ -46,7 +46,7 @@ namespace etl
{ {
inline namespace string_literals inline namespace string_literals
{ {
inline constexpr etl::wstring_view operator ""_sv(const wchar_t* str, size_t length) noexcept inline constexpr etl::wstring_view operator ""_sv(const wchar_t* str, size_t length) ETL_NOEXCEPT
{ {
return etl::wstring_view{ str, length }; return etl::wstring_view{ str, length };
} }