diff --git a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx index f89a79e0..7b7077f4 100644 --- a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx +++ b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx @@ -11,7 +11,7 @@ 0x4 ARM-ADS 6130001::V6.13.1::.\ARMCLANG - 1 + 0 STM32F401RETx @@ -312,7 +312,7 @@ 1 - 7 + 1 0 0 1 @@ -321,7 +321,7 @@ 1 0 0 - 3 + 2 0 0 1 diff --git a/include/etl/absolute.h b/include/etl/absolute.h index ba7f69ea..165dba9c 100644 --- a/include/etl/absolute.h +++ b/include/etl/absolute.h @@ -39,7 +39,7 @@ namespace etl // For signed types. //*************************************************************************** template - typename etlstd::enable_if::value, T>::type + typename etl::enable_if::value, T>::type absolute(T value) { return (value < T(0)) ? -value : value; @@ -49,7 +49,7 @@ namespace etl // For unsigned types. //*************************************************************************** template - typename etlstd::enable_if::value, T>::type + typename etl::enable_if::value, T>::type absolute(T value) { return value; diff --git a/include/etl/algorithm.h b/include/etl/algorithm.h index 788223ec..7d6797ab 100644 --- a/include/etl/algorithm.h +++ b/include/etl/algorithm.h @@ -37,6 +37,7 @@ SOFTWARE. ///\ingroup utilities #include +#include #include "platform.h" #include "type_traits.h" @@ -55,20 +56,20 @@ SOFTWARE. //***************************************************************************** // Algorithms defined by the ETL //***************************************************************************** -#undef ETL_ALGORITHM - -namespace etlstd +namespace etl { -#if defined(ETL_NO_STL) +// We can't have std::swap and etl::swap templates coexisting in the unit tests +// as the compiler will be unable to decide of which one to use, due to ADL. +#if defined(ETL_NO_STL) && !defined(ETL_IN_UNIT_TEST) //*************************************************************************** // swap #if ETL_CPP11_SUPPORTED template void swap(T& a, T& b) { - T temp(etlstd::move(a)); - a = etlstd::move(b); - b = etlstd::move(temp); + T temp(etl::move(a)); + a = etl::move(b); + b = etl::move(temp); } #else template @@ -79,15 +80,6 @@ namespace etlstd b = temp; } #endif -#else - //*************************************************************************** - // swap - template - void swap(T& a, T& b) - { - using std::swap; - swap(a, b); - } #endif #if defined(ETL_NO_STL) @@ -96,7 +88,7 @@ namespace etlstd template void iter_swap(TIterator1 a, TIterator2 b) { - typename etlstd::iterator_traits::value_type c = *a; + typename etl::iterator_traits::value_type c = *a; *a = *b; *b = c; } @@ -142,13 +134,13 @@ namespace etlstd // copy // Pointer template - typename etlstd::enable_if::value && - etlstd::is_pointer::value && - etlstd::is_pod::value_type>::value, TIterator2>::type + typename etl::enable_if::value && + etl::is_pointer::value && + etl::is_pod::value_type>::value, TIterator2>::type copy(TIterator1 sb, TIterator1 se, TIterator2 db) { - typedef typename etlstd::iterator_traits::value_type value_t; - typedef typename etlstd::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::difference_type difference_t; difference_t count = (se - sb); @@ -157,9 +149,9 @@ namespace etlstd // Other iterator template - typename etlstd::enable_if::value || - !etlstd::is_pointer::value || - !etlstd::is_pod::value_type>::value, TIterator2>::type + typename etl::enable_if::value || + !etl::is_pointer::value || + !etl::is_pod::value_type>::value, TIterator2>::type copy(TIterator1 sb, TIterator1 se, TIterator2 db) { while (sb != se) @@ -207,21 +199,21 @@ namespace etlstd // copy_n // Pointer template - typename etlstd::enable_if::value && - etlstd::is_pointer::value && - etlstd::is_pod::value_type>::value, TIterator2>::type + typename etl::enable_if::value && + etl::is_pointer::value && + etl::is_pod::value_type>::value, TIterator2>::type copy_n(TIterator1 sb, TSize count, TIterator2 db) { - typedef typename etlstd::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::value_type value_t; return TIterator2(memmove(db, sb, sizeof(value_t) * count)) + count; } // Other iterator template - typename etlstd::enable_if::value || - !etlstd::is_pointer::value || - !etlstd::is_pod::value_type>::value, TIterator2>::type + typename etl::enable_if::value || + !etl::is_pointer::value || + !etl::is_pod::value_type>::value, TIterator2>::type copy_n(TIterator1 sb, TSize count, TIterator2 db) { while (count != 0) @@ -252,12 +244,12 @@ namespace etlstd // copy_backward // Pointer template - typename etlstd::enable_if::value && - etlstd::is_pointer::value && - etlstd::is_pod::value_type>::value, TIterator2>::type + typename etl::enable_if::value && + etl::is_pointer::value && + etl::is_pod::value_type>::value, TIterator2>::type copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de) { - typedef typename etlstd::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::value_type value_t; const size_t length = (se - sb); @@ -266,9 +258,9 @@ namespace etlstd // Other iterator template - typename etlstd::enable_if::value || - !etlstd::is_pointer::value || - !etlstd::is_pod::value_type>::value, TIterator2>::type + typename etl::enable_if::value || + !etl::is_pointer::value || + !etl::is_pod::value_type>::value, TIterator2>::type copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de) { while (se != sb) @@ -296,7 +288,7 @@ namespace etlstd { while (sb != se) { - *db++ = etlstd::move(*sb++); + *db++ = etl::move(*sb++); } return db; @@ -319,7 +311,7 @@ namespace etlstd { while (sb != se) { - *(--de) = etlstd::move(*(--se)); + *(--de) = etl::move(*(--se)); } return de; @@ -339,14 +331,14 @@ namespace etlstd // reverse // Pointers template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type reverse(TIterator b, TIterator e) { if (b != e) { while (b < --e) { - etlstd::iter_swap(b, e); + etl::iter_swap(b, e); ++b; } } @@ -354,12 +346,12 @@ namespace etlstd // Other template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type reverse(TIterator b, TIterator e) { while ((b != e) && (b != --e)) { - etlstd::iter_swap(b++, e); + etl::iter_swap(b++, e); } } #else @@ -376,18 +368,19 @@ namespace etlstd //*************************************************************************** // lower_bound template + ETL_NODISCARD TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) { - typedef typename etlstd::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::difference_type difference_t; - difference_t count = etlstd::distance(first, last); + difference_t count = etl::distance(first, last); while (count > 0) { TIterator itr = first; difference_t step = count / 2; - etlstd::advance(itr, step); + etl::advance(itr, step); if (compare(*itr, value)) { @@ -404,22 +397,25 @@ namespace etlstd } template + ETL_NODISCARD TIterator lower_bound(TIterator first, TIterator last, const TValue& value) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; - return etlstd::lower_bound(first, last, value, compare()); + return etl::lower_bound(first, last, value, compare()); } #else //*************************************************************************** // lower_bound template + ETL_NODISCARD TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) { return std::lower_bound(first, last, value, compare); } template + ETL_NODISCARD TIterator lower_bound(TIterator first, TIterator last, const TValue& value) { return std::lower_bound(first, last, value); @@ -430,18 +426,19 @@ namespace etlstd //*************************************************************************** // upper_bound template + ETL_NODISCARD TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) { - typedef typename etlstd::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::difference_type difference_t; - difference_t count = etlstd::distance(first, last); + difference_t count = etl::distance(first, last); while (count > 0) { TIterator itr = first; difference_t step = count / 2; - etlstd::advance(itr, step); + etl::advance(itr, step); if (!compare(value, *itr)) { @@ -458,22 +455,25 @@ namespace etlstd } template + ETL_NODISCARD TIterator upper_bound(TIterator first, TIterator last, const TValue& value) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; - return etlstd::upper_bound(first, last, value, compare()); + return etl::upper_bound(first, last, value, compare()); } #else //*************************************************************************** // upper_bound template + ETL_NODISCARD TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) { return std::upper_bound(first, last, value, compare); } template + ETL_NODISCARD TIterator upper_bound(TIterator first, TIterator last, const TValue& value) { return std::upper_bound(first, last, value); @@ -484,30 +484,34 @@ namespace etlstd //*************************************************************************** // equal_range template + ETL_NODISCARD ETL_OR_STD::pair equal_range(TIterator first, TIterator last, const TValue& value, TCompare compare) { - return ETL_OR_STD::make_pair(etlstd::lower_bound(first, last, value, compare), - etlstd::upper_bound(first, last, value, compare)); + return ETL_OR_STD::make_pair(etl::lower_bound(first, last, value, compare), + etl::upper_bound(first, last, value, compare)); } template + ETL_NODISCARD ETL_OR_STD::pair equal_range(TIterator first, TIterator last, const TValue& value) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; - return ETL_OR_STD::make_pair(etlstd::lower_bound(first, last, value, compare()), - etlstd::upper_bound(first, last, value, compare())); + return ETL_OR_STD::make_pair(etl::lower_bound(first, last, value, compare()), + etl::upper_bound(first, last, value, compare())); } #else //*************************************************************************** // equal_range template + ETL_NODISCARD std::pair equal_range(TIterator first, TIterator last, const TValue& value, TCompare compare) { return std::equal_range(first, last, value, compare); } template + ETL_NODISCARD std::pair equal_range(TIterator first, TIterator last, const TValue& value) { return std::equal_range(first, last, value); @@ -518,6 +522,7 @@ namespace etlstd //*************************************************************************** // find_if template + ETL_NODISCARD TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate) { while (first != last) @@ -536,6 +541,7 @@ namespace etlstd //*************************************************************************** // find_if template + ETL_NODISCARD TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate) { return std::find_if(first, last, predicate); @@ -546,6 +552,7 @@ namespace etlstd //*************************************************************************** // find template + ETL_NODISCARD TIterator find(TIterator first, TIterator last, const T& value) { while (first != last) @@ -564,6 +571,7 @@ namespace etlstd //*************************************************************************** // find template + ETL_NODISCARD TIterator find(TIterator first, TIterator last, const T& value) { return std::find(first, last, value); @@ -574,7 +582,7 @@ namespace etlstd //*************************************************************************** // fill template - typename etlstd::enable_if::value || etlstd::is_same::value) || !etlstd::is_pointer::value, void>::type + typename etl::enable_if::value || etl::is_same::value) || !etl::is_pointer::value, void>::type fill(TIterator first, TIterator last, const TValue& value) { while (first != last) @@ -584,7 +592,7 @@ namespace etlstd } template - typename etlstd::enable_if<(etlstd::is_same::value || etlstd::is_same::value) && etlstd::is_pointer::value, void>::type + typename etl::enable_if<(etl::is_same::value || etl::is_same::value) && etl::is_pointer::value, void>::type fill(TIterator first, TIterator last, const TValue& value) { memset(first, value, last - first); @@ -603,7 +611,7 @@ namespace etlstd //*************************************************************************** // fill_n template - typename etlstd::enable_if::value || etlstd::is_same::value) || !etlstd::is_pointer::value, TIterator>::type + typename etl::enable_if::value || etl::is_same::value) || !etl::is_pointer::value, TIterator>::type fill_n(TIterator first, TSize count, const TValue& value) { for (TSize i = 0; i < count; ++i) @@ -615,7 +623,7 @@ namespace etlstd } template - typename etlstd::enable_if<(etlstd::is_same::value || etlstd::is_same::value) && etlstd::is_pointer::value, void>::type + typename etl::enable_if<(etl::is_same::value || etl::is_same::value) && etl::is_pointer::value, void>::type fill_n(TIterator first, TSize count, const TValue& value) { memset(first, value, count); @@ -634,7 +642,8 @@ namespace etlstd //*************************************************************************** // count template - typename etlstd::iterator_traits::difference_type count(TIterator first, TIterator last, const T& value) + ETL_NODISCARD + typename etl::iterator_traits::difference_type count(TIterator first, TIterator last, const T& value) { typename iterator_traits::difference_type n = 0; @@ -654,6 +663,7 @@ namespace etlstd //*************************************************************************** // count template + ETL_NODISCARD typename std::iterator_traits::difference_type count(TIterator first, TIterator last, const T& value) { return std::count(first, last, value); @@ -664,7 +674,8 @@ namespace etlstd //*************************************************************************** // count_if template - typename etlstd::iterator_traits::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate) + ETL_NODISCARD + typename etl::iterator_traits::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate) { typename iterator_traits::difference_type n = 0; @@ -684,6 +695,7 @@ namespace etlstd //*************************************************************************** // count_if template + ETL_NODISCARD typename std::iterator_traits::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate) { return std::count_if(first, last, predicate); @@ -694,7 +706,8 @@ namespace etlstd //*************************************************************************** // equal template - typename etlstd::enable_if::value || !etlstd::is_pointer::value || !etlstd::is_pod::value_type>::value, bool>::type + ETL_NODISCARD + typename etl::enable_if::value || !etl::is_pointer::value || !etl::is_pod::value_type>::value, bool>::type equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) { while (first1 != last1) @@ -709,10 +722,11 @@ namespace etlstd } template - typename etlstd::enable_if::value && etlstd::is_pointer::value && etlstd::is_pod::value_type>::value, bool>::type + ETL_NODISCARD + typename etl::enable_if::value && etl::is_pointer::value && etl::is_pod::value_type>::value, bool>::type equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) { - typedef typename etlstd::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::value_type value_t; return (memcmp(first1, first2, sizeof(value_t) * (last1 - first1)) == 0); } @@ -720,6 +734,7 @@ namespace etlstd //*************************************************************************** // equal template + ETL_NODISCARD bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) { return std::equal(first1, last1, first2); @@ -730,6 +745,7 @@ namespace etlstd //*************************************************************************** // lexicographical_compare template + ETL_NODISCARD bool lexicographical_compare(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TCompare compare) @@ -756,17 +772,19 @@ namespace etlstd //*************************************************************************** // lexicographical_compare template + ETL_NODISCARD bool lexicographical_compare(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; - return etlstd::lexicographical_compare(first1, last1, first2, last2, compare()); + return etl::lexicographical_compare(first1, last1, first2, last2, compare()); } #else //*************************************************************************** // lexicographical_compare template + ETL_NODISCARD bool lexicographical_compare(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TCompare compare) @@ -777,6 +795,7 @@ namespace etlstd //*************************************************************************** // lexicographical_compare template + ETL_NODISCARD bool lexicographical_compare(TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2) { @@ -788,28 +807,32 @@ namespace etlstd //*************************************************************************** // min template + ETL_NODISCARD ETL_CONSTEXPR const T& min(const T& a, const T& b, TCompare compare) { return (compare(a, b)) ? a : b; } template + ETL_NODISCARD ETL_CONSTEXPR const T& min(const T& a, const T& b) { - typedef etlstd::less compare; + typedef etl::less compare; - return etlstd::min(a, b, compare()); + return etl::min(a, b, compare()); } #else //*************************************************************************** // min template + ETL_NODISCARD ETL_CONSTEXPR const T& min(const T& a, const T& b, TCompare compare) { return std::min(a, b, compare); } template + ETL_NODISCARD ETL_CONSTEXPR const T& min(const T& a, const T& b) { return std::min(a, b); @@ -820,28 +843,32 @@ namespace etlstd //*************************************************************************** // max template + ETL_NODISCARD ETL_CONSTEXPR const T& max(const T& a, const T& b, TCompare compare) { return (compare(a, b)) ? b : a; } template + ETL_NODISCARD ETL_CONSTEXPR const T& max(const T& a, const T& b) { - typedef etlstd::less compare; + typedef etl::less compare; - return etlstd::max(a, b, compare()); + return etl::max(a, b, compare()); } #else //*************************************************************************** // max template + ETL_NODISCARD ETL_CONSTEXPR const T& max(const T& a, const T& b, TCompare compare) { return std::max(a, b, compare); } template + ETL_NODISCARD ETL_CONSTEXPR const T& max(const T& a, const T& b) { return std::max(a, b); @@ -964,8 +991,8 @@ namespace etlstd template void pop_heap(TIterator first, TIterator last, TCompare compare) { - typedef typename etlstd::iterator_traits::value_type value_t; - typedef typename etlstd::iterator_traits::difference_type distance_t; + typedef typename etl::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::difference_type distance_t; value_t value = last[-1]; last[-1] = first[0]; @@ -977,17 +1004,17 @@ namespace etlstd template void pop_heap(TIterator first, TIterator last) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; - etlstd::pop_heap(first, last, compare()); + etl::pop_heap(first, last, compare()); } // Push Heap template void push_heap(TIterator first, TIterator last, TCompare compare) { - typedef typename etlstd::iterator_traits::difference_type difference_t; - typedef typename etlstd::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::value_type value_t; private_heap::push_heap(first, difference_t(last - first - 1), difference_t(0), value_t(*(last - 1)), compare); } @@ -996,16 +1023,16 @@ namespace etlstd template void push_heap(TIterator first, TIterator last) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; - etlstd::push_heap(first, last, compare()); + etl::push_heap(first, last, compare()); } // Make Heap template void make_heap(TIterator first, TIterator last, TCompare compare) { - typedef typename etlstd::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::difference_type difference_t; if ((last - first) < 2) { @@ -1032,22 +1059,24 @@ namespace etlstd template void make_heap(TIterator first, TIterator last) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; - etlstd::make_heap(first, last, compare()); + etl::make_heap(first, last, compare()); } // Is Heap template + ETL_NODISCARD bool is_heap(TIterator first, TIterator last) { - typedef etlstd::less::value_type> compare; + typedef etl::less::value_type> compare; return private_heap::is_heap(first, last - first, compare()); } // Is Heap template + ETL_NODISCARD bool is_heap(TIterator first, TIterator last, TCompare compare) { return private_heap::is_heap(first, last - first, compare); @@ -1099,6 +1128,7 @@ namespace etlstd // Is Heap template + ETL_NODISCARD bool is_heap(TIterator first, TIterator last) { return std::is_heap(first, last); @@ -1106,6 +1136,7 @@ namespace etlstd // Is Heap template + ETL_NODISCARD bool is_heap(TIterator first, TIterator last, TCompare compare) { return std::is_heap(first, last, compare); @@ -1116,6 +1147,7 @@ namespace etlstd //*************************************************************************** // Search template + ETL_NODISCARD TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare) { while (true) @@ -1150,16 +1182,18 @@ namespace etlstd // Search template + ETL_NODISCARD TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last) { - typedef etlstd::equal_to::value_type> compare; + typedef etl::equal_to::value_type> compare; - return etlstd::search(first, last, search_first, search_last, compare()); + return etl::search(first, last, search_first, search_last, compare()); } #else //*************************************************************************** // Search template + ETL_NODISCARD TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare) { return std::search(first, last, search_first, search_last, compare); @@ -1167,6 +1201,7 @@ namespace etlstd // Search template + ETL_NODISCARD TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last) { return std::search(first, last, search_first, search_last); @@ -1179,16 +1214,14 @@ namespace etlstd template TIterator rotate(TIterator first, TIterator middle, TIterator last) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL TIterator next = middle; while (first != next) { + using ETL_OR_STD::swap; + swap(*first++, *next++); if (next == last) @@ -1218,6 +1251,7 @@ namespace etlstd // find_end // Predicate template + ETL_NODISCARD TIterator1 find_end(TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se, TPredicate predicate) @@ -1231,7 +1265,7 @@ namespace etlstd while (true) { - TIterator1 new_result = etlstd::search(b, e, sb, se, predicate); + TIterator1 new_result = etl::search(b, e, sb, se, predicate); if (new_result == e) { @@ -1249,10 +1283,11 @@ namespace etlstd // Default template + ETL_NODISCARD TIterator1 find_end(TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se) { - typedef etlstd::equal_to::value_type> predicate; + typedef etl::equal_to::value_type> predicate; return find_end(b, e, sb, se, predicate()); } @@ -1261,6 +1296,7 @@ namespace etlstd // find_end // Predicate template + ETL_NODISCARD TIterator1 find_end(TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se, TPredicate predicate) @@ -1270,6 +1306,7 @@ namespace etlstd // Default template + ETL_NODISCARD TIterator1 find_end(TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se) { @@ -1284,6 +1321,7 @@ namespace etlstd ///\ingroup algorithm //*************************************************************************** template + ETL_NODISCARD ETL_OR_STD::pair minmax_element(TIterator begin, TIterator end, TCompare compare) @@ -1315,12 +1353,13 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD ETL_OR_STD::pair minmax_element(TIterator begin, - TIterator end) + TIterator end) { - typedef typename etlstd::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::value_type value_t; - return etlstd::minmax_element(begin, end, etlstd::less()); + return etl::minmax_element(begin, end, etl::less()); } #else //*************************************************************************** @@ -1329,6 +1368,7 @@ namespace etlstd ///\ingroup algorithm //*************************************************************************** template + ETL_NODISCARD std::pair minmax_element(TIterator begin, TIterator end, TCompare compare) @@ -1343,6 +1383,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD std::pair minmax_element(TIterator begin, TIterator end) { @@ -1357,6 +1398,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD ETL_OR_STD::pair minmax(const T& a, const T& b) { @@ -1368,11 +1410,11 @@ namespace etlstd ///\ingroup algorithm /// //*************************************************************************** - template - ETL_OR_STD::pair minmax(const T& a, - const T& b, - TCompare compare) + template + ETL_NODISCARD + ETL_OR_STD::pair minmax(const T& a, + const T& b, + TCompare compare) { return compare(b, a) ? ETL_OR_STD::pair(b, a) : ETL_OR_STD::pair(a, b); } @@ -1383,6 +1425,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD std::pair minmax(const T& a, const T& b) { @@ -1395,6 +1438,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD std::pair minmax(const T& a, const T& b, TCompare compare) @@ -1410,6 +1454,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD TIterator is_sorted_until(TIterator begin, TIterator end) { @@ -1436,11 +1481,11 @@ namespace etlstd ///\ingroup algorithm /// //*************************************************************************** - template - TIterator is_sorted_until(TIterator begin, - TIterator end, - TCompare compare) + template + ETL_NODISCARD + TIterator is_sorted_until(TIterator begin, + TIterator end, + TCompare compare) { if (begin != end) { @@ -1466,6 +1511,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD TIterator is_sorted_until(TIterator begin, TIterator end) { @@ -1478,6 +1524,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD TIterator is_sorted_until(TIterator begin, TIterator end, TCompare compare) @@ -1493,10 +1540,11 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_sorted(TIterator begin, TIterator end) { - return etlstd::is_sorted_until(begin, end) == end; + return etl::is_sorted_until(begin, end) == end; } //*************************************************************************** @@ -1504,13 +1552,13 @@ namespace etlstd ///\ingroup algorithm /// //*************************************************************************** - template - bool is_sorted(TIterator begin, - TIterator end, - TCompare compare) + template + ETL_NODISCARD + bool is_sorted(TIterator begin, + TIterator end, + TCompare compare) { - return etlstd::is_sorted_until(begin, end, compare) == end; + return etl::is_sorted_until(begin, end, compare) == end; } #else //*************************************************************************** @@ -1519,6 +1567,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_sorted(TIterator begin, TIterator end) { @@ -1531,6 +1580,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_sorted(TIterator begin, TIterator end, TCompare compare) @@ -1546,6 +1596,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD TIterator find_if_not(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1569,6 +1620,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD TIterator find_if_not(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1584,6 +1636,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2) @@ -1592,15 +1645,15 @@ namespace etlstd { TIterator2 end2 = begin2; - etlstd::advance(end2, etlstd::distance(begin1, end1)); + etl::advance(end2, etl::distance(begin1, end1)); for (TIterator1 i = begin1; i != end1; ++i) { - if (i == etlstd::find(begin1, i, *i)) + if (i == etl::find(begin1, i, *i)) { - size_t n = etlstd::count(begin2, end2, *i); + size_t n = etl::count(begin2, end2, *i); - if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) { return false; } @@ -1617,6 +1670,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2, @@ -1626,15 +1680,15 @@ namespace etlstd { TIterator2 end2 = begin2; - etlstd::advance(end2, etlstd::distance(begin1, end1)); + etl::advance(end2, etl::distance(begin1, end1)); for (TIterator1 i = begin1; i != end1; ++i) { - if (i == etlstd::find_if(begin1, i, etlstd::bind1st(predicate, *i))) + if (i == etl::find_if(begin1, i, etl::bind1st(predicate, *i))) { - size_t n = etlstd::count(begin2, end2, *i); + size_t n = etl::count(begin2, end2, *i); - if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) { return false; } @@ -1651,6 +1705,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2, @@ -1660,11 +1715,11 @@ namespace etlstd { for (TIterator1 i = begin1; i != end1; ++i) { - if (i == etlstd::find(begin1, i, *i)) + if (i == etl::find(begin1, i, *i)) { - size_t n = etlstd::count(begin2, end2, *i); + size_t n = etl::count(begin2, end2, *i); - if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) { return false; } @@ -1681,6 +1736,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2, @@ -1691,11 +1747,11 @@ namespace etlstd { for (TIterator1 i = begin1; i != end1; ++i) { - if (i == etlstd::find_if(begin1, i, etlstd::bind1st(predicate, *i))) + if (i == etl::find_if(begin1, i, etl::bind1st(predicate, *i))) { - size_t n = etlstd::count(begin2, end2, *i); + size_t n = etl::count(begin2, end2, *i); - if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) { return false; } @@ -1712,6 +1768,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2) @@ -1725,6 +1782,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2, @@ -1739,6 +1797,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2, @@ -1753,6 +1812,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_permutation(TIterator1 begin1, TIterator1 end1, TIterator2 begin2, @@ -1770,6 +1830,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_partitioned(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1799,6 +1860,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool is_partitioned(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1814,6 +1876,7 @@ namespace etlstd ///\ingroup algorithm //*************************************************************************** template + ETL_NODISCARD TIterator partition_point(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1837,6 +1900,7 @@ namespace etlstd ///\ingroup algorithm //*************************************************************************** template + ETL_NODISCARD TIterator partition_point(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1938,11 +2002,12 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool all_of(TIterator begin, TIterator end, TUnaryPredicate predicate) { - return etlstd::find_if_not(begin, end, predicate) == end; + return etl::find_if_not(begin, end, predicate) == end; } #else //*************************************************************************** @@ -1951,6 +2016,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool all_of(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1966,11 +2032,12 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool any_of(TIterator begin, TIterator end, TUnaryPredicate predicate) { - return etlstd::find_if(begin, end, predicate) != end; + return etl::find_if(begin, end, predicate) != end; } #else //*************************************************************************** @@ -1979,6 +2046,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool any_of(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -1994,11 +2062,12 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool none_of(TIterator begin, TIterator end, TUnaryPredicate predicate) { - return etlstd::find_if(begin, end, predicate) == end; + return etl::find_if(begin, end, predicate) == end; } #else //*************************************************************************** @@ -2007,6 +2076,7 @@ namespace etlstd /// //*************************************************************************** template + ETL_NODISCARD bool none_of(TIterator begin, TIterator end, TUnaryPredicate predicate) @@ -2034,18 +2104,18 @@ namespace etl //*************************************************************************** template - typename etlstd::enable_if::value && + typename etl::enable_if::value && etl::is_random_iterator::value, TOutputIterator>::type - copy(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end) + copy_s(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end) { - size_t s_size = etlstd::distance(i_begin, i_end); - size_t d_size = etlstd::distance(o_begin, o_end); + size_t s_size = etl::distance(i_begin, i_end); + size_t d_size = etl::distance(o_begin, o_end); size_t size = (s_size < d_size) ? s_size : d_size; - return etlstd::copy(i_begin, i_begin + size, o_begin); + return etl::copy(i_begin, i_begin + size, o_begin); } //*************************************************************************** @@ -2061,12 +2131,12 @@ namespace etl //*************************************************************************** template - typename etlstd::enable_if::value || + typename etl::enable_if::value || !etl::is_random_iterator::value, TOutputIterator>::type - copy(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end) + copy_s(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end) { while ((i_begin != i_end) && (o_begin != o_end)) { @@ -2084,10 +2154,10 @@ namespace etl template - TOutputIterator copy_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin, - TOutputIterator o_end) + TOutputIterator copy_n_s(TInputIterator i_begin, + TSize n, + TOutputIterator o_begin, + TOutputIterator o_end) { while ((n-- > 0) && (o_begin != o_end)) { @@ -2106,10 +2176,10 @@ namespace etl typename TSize1, typename TOutputIterator, typename TSize2> - TOutputIterator copy_n(TInputIterator i_begin, - TSize1 n1, - TOutputIterator o_begin, - TSize2 n2) + TOutputIterator copy_n_s(TInputIterator i_begin, + TSize1 n1, + TOutputIterator o_begin, + TSize2 n2) { while ((n1-- > 0) && (n2-- > 0)) { @@ -2128,7 +2198,7 @@ namespace etl template - TOutputIterator copy_if(TInputIterator i_begin, + TOutputIterator copy_if_s(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end, @@ -2179,13 +2249,13 @@ namespace etl ///\ingroup algorithm /// Does a binary search and returns an iterator to the value or end if not found. //*************************************************************************** - template + template + ETL_NODISCARD TIterator binary_find(TIterator begin, TIterator end, const TValue& value) { - TIterator it = etlstd::lower_bound(begin, end, value); + TIterator it = etl::lower_bound(begin, end, value); if ((it == end) || (*it != value)) { @@ -2204,13 +2274,14 @@ namespace etl typename TValue, typename TBinaryPredicate, typename TBinaryEquality> + ETL_NODISCARD TIterator binary_find(TIterator begin, TIterator end, const TValue& value, TBinaryPredicate predicate, TBinaryEquality equality) { - TIterator it = etlstd::lower_bound(begin, end, value, predicate); + TIterator it = etl::lower_bound(begin, end, value, predicate); if ((it == end) || !equality(*it, value)) { @@ -2296,14 +2367,12 @@ namespace etl /// There is currently no STL equivalent. ///\ingroup algorithm //*************************************************************************** - template - TOutputIterator transform(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end, - TUnaryFunction function) + template + TOutputIterator transform_s(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end, + TUnaryFunction function) { while ((i_begin != i_end) && (o_begin != o_end)) { @@ -2329,9 +2398,9 @@ namespace etl TUnaryFunction function) { TInputIterator i_end(i_begin); - etlstd::advance(i_end, n); + etl::advance(i_end, n); - etlstd::transform(i_begin, i_end, o_begin, function); + etl::transform(i_begin, i_end, o_begin, function); } //*************************************************************************** @@ -2351,10 +2420,10 @@ namespace etl TOutputIterator o_begin, TBinaryFunction function) { - TInputIterator i_end1(i_begin1); - etlstd::advance(i_end1, n); + TInputIterator1 i_end1(i_begin1); + etl::advance(i_end1, n); - etlstd::transform(i_begin1, i_end1, i_begin2, o_begin, function); + etl::transform(i_begin1, i_end1, i_begin2, o_begin, function); } //*************************************************************************** @@ -2553,9 +2622,9 @@ namespace etl return; } - typedef typename etlstd::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::difference_type difference_t; - difference_t n = etlstd::distance(first, last); + difference_t n = etl::distance(first, last); for (difference_t i = n / 2; i > 0; i /= 2) { @@ -2566,12 +2635,12 @@ namespace etl TIterator itr1 = first; TIterator itr2 = first; - etlstd::advance(itr1, k); - etlstd::advance(itr2, k + i); + etl::advance(itr1, k); + etl::advance(itr2, k + i); if (compare(*itr2, *itr1)) { - etlstd::iter_swap(itr1, itr2); + etl::iter_swap(itr1, itr2); } } } @@ -2585,7 +2654,7 @@ namespace etl template void shell_sort(TIterator first, TIterator last) { - etl::shell_sort(first, last, etlstd::less::value_type>()); + etl::shell_sort(first, last, etl::less::value_type>()); } //*************************************************************************** @@ -2598,7 +2667,7 @@ namespace etl { for (TIterator itr = first; itr != last; ++itr) { - etlstd::rotate(etlstd::upper_bound(first, itr, *itr, compare), itr, etlstd::next(itr)); + etl::rotate(etl::upper_bound(first, itr, *itr, compare), itr, etl::next(itr)); } } @@ -2609,7 +2678,7 @@ namespace etl template void insertion_sort(TIterator first, TIterator last) { - etl::insertion_sort(first, last, etlstd::less::value_type>()); + etl::insertion_sort(first, last, etl::less::value_type>()); } //*************************************************************************** @@ -2630,7 +2699,7 @@ namespace etl template void sort(TIterator first, TIterator last) { - etl::shell_sort(first, last, etlstd::less::value_type>()); + etl::shell_sort(first, last, etl::less::value_type>()); } //*************************************************************************** @@ -2653,132 +2722,164 @@ namespace etl template void stable_sort(TIterator first, TIterator last) { - etl::insertion_sort(first, last, etlstd::less::value_type>()); + etl::insertion_sort(first, last, etl::less::value_type>()); } //*************************************************************************** /// Returns the maximum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimax(const T& a, const T& b) { return a < b ? b : a; } template + ETL_NODISCARD constexpr const T& multimax(const T& t, const Tx&... tx) { return multimax(t, multimax(tx...)); } +#endif //*************************************************************************** /// Returns the maximum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimax_compare(TCompare compare, const T& a, const T& b) { return compare(a, b) ? b : a; } template + ETL_NODISCARD constexpr const T& multimax_compare(TCompare compare, const T& t, const Tx&... tx) { return multimax_compare(compare, t, multimax_compare(compare, tx...)); } +#endif //*************************************************************************** /// Returns the maximum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimin(const T& a, const T& b) { return a < b ? a : b; } template + ETL_NODISCARD constexpr const T& multimin(const T& t, const Tx&... tx) { return multimin(t, multimin(tx...)); } +#endif //*************************************************************************** /// Returns the minimum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimin_compare(TCompare compare, const T& a, const T& b) { return compare(a, b) ? a : b; } template + ETL_NODISCARD constexpr const T& multimin_compare(TCompare compare, const T& t, const Tx&... tx) { return multimin_compare(compare, t, multimin_compare(compare, tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the maximum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimax_iter(const TIterator& a, const TIterator& b) { return *a < *b ? b : a; } template + ETL_NODISCARD constexpr const TIterator& multimax_iter(const TIterator& t, const TIteratorx&... tx) { return multimax_iter(t, multimax_iter(tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the maximum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimax_iter_compare(TCompare compare, const TIterator& a, const TIterator& b) { return compare(*a, *b) ? b : a; } template + ETL_NODISCARD constexpr const TIterator& multimax_iter_compare(TCompare compare, const TIterator& t, const TIteratorx&... tx) { return multimax_iter_compare(compare, t, multimax_iter_compare(compare, tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the minimum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimin_iter(const TIterator& a, const TIterator& b) { return *a < *b ? a : b; } template + ETL_NODISCARD constexpr const TIterator& multimin_iter(const TIterator& t, const Tx&... tx) { return multimin_iter(t, multimin_iter(tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the minimum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimin_iter_compare(TCompare compare, const TIterator& a, const TIterator& b) { return compare(*a, *b) ? a : b; } template + ETL_NODISCARD constexpr const TIterator& multimin_iter_compare(TCompare compare, const TIterator& t, const Tx&... tx) { return multimin_iter_compare(compare, t, multimin_iter_compare(compare, tx...)); } +#endif } #endif diff --git a/include/etl/alignment.h b/include/etl/alignment.h index 0a0f2d91..b2e53866 100644 --- a/include/etl/alignment.h +++ b/include/etl/alignment.h @@ -66,7 +66,7 @@ namespace etl { public: - typedef typename type_with_alignment_matcher::value, ALIGNMENT, T2, T3, T4, T5, T6, T7, T8, void>::type type; + typedef typename type_with_alignment_matcher::value, ALIGNMENT, T2, T3, T4, T5, T6, T7, T8, void>::type type; }; // Non-matching alignment, none left. @@ -86,7 +86,7 @@ namespace etl { public: - typedef typename type_with_alignment_matcher::value, ALIGNMENT, T1, T2, T3, T4, T5, T6, T7, T8>::type type; + typedef typename type_with_alignment_matcher::value, ALIGNMENT, T1, T2, T3, T4, T5, T6, T7, T8>::type type; }; } @@ -116,7 +116,7 @@ namespace etl template operator T& () { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); T* t = *this; return *t; } @@ -125,7 +125,7 @@ namespace etl template operator const T& () const { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); const T* t = *this; return *t; } @@ -134,7 +134,7 @@ namespace etl template operator T* () { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); return reinterpret_cast(data); } @@ -142,7 +142,7 @@ namespace etl template operator const T* () const { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); return reinterpret_cast(data); } @@ -150,7 +150,7 @@ namespace etl template T& get_reference() { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); T* t = *this; return *t; } @@ -159,7 +159,7 @@ namespace etl template const T& get_reference() const { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); const T* t = *this; return *t; } @@ -168,7 +168,7 @@ namespace etl template T* get_address() { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); return reinterpret_cast(data); } @@ -176,7 +176,7 @@ namespace etl template const T* get_address() const { - ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); return reinterpret_cast(data); } @@ -197,7 +197,7 @@ namespace etl ///\ingroup alignment //*************************************************************************** template - struct aligned_storage_as : public etl::aligned_storage::value> + struct aligned_storage_as : public etl::aligned_storage::value> { }; } diff --git a/include/etl/array.h b/include/etl/array.h index a9205464..e0167dd7 100644 --- a/include/etl/array.h +++ b/include/etl/array.h @@ -342,7 +342,7 @@ namespace etl //************************************************************************* void fill(parameter_t value) { - etlstd::fill(begin(), end(), value); + etl::fill(begin(), end(), value); } //************************************************************************* @@ -351,11 +351,7 @@ namespace etl //************************************************************************* void swap(array& other) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL for (size_t i = 0; i < SIZE; ++i) { @@ -373,7 +369,7 @@ namespace etl template void assign(TIterator first, const TIterator last) { - etlstd::copy(first, last, begin(), end()); + etl::copy_s(first, last, begin(), end()); } //************************************************************************* @@ -387,10 +383,10 @@ namespace etl void assign(TIterator first, const TIterator last, parameter_t value) { // Copy from the range. - iterator p = etlstd::copy(first, last, begin(), end()); + iterator p = etl::copy_s(first, last, begin(), end()); // Default initialise any that are left. - etlstd::fill(p, end(), value); + etl::fill(p, end(), value); } //************************************************************************* @@ -412,7 +408,7 @@ namespace etl { iterator p = const_cast(position); - etlstd::copy_backward(p, end() - 1, end()); + etl::copy_backward(p, end() - 1, end()); *p = value; return p; @@ -442,18 +438,18 @@ namespace etl iterator p = const_cast(position); iterator result(p); - size_t source_size = etlstd::distance(first, last); - size_t destination_space = etlstd::distance(position, cend()); + size_t source_size = etl::distance(first, last); + size_t destination_space = etl::distance(position, cend()); // Do we need to move anything? if (source_size < destination_space) { - size_t length = SIZE - (etlstd::distance(begin(), p) + source_size); - etlstd::copy_backward(p, p + length, end()); + size_t length = SIZE - (etl::distance(begin(), p) + source_size); + etl::copy_backward(p, p + length, end()); } // Copy from the range. - etlstd::copy(first, last, p, end()); + etl::copy_s(first, last, p, end()); return result; } @@ -476,7 +472,7 @@ namespace etl iterator erase(const_iterator position) { iterator p = const_cast(position); - etlstd::copy(p + 1, end(), p); + etl::copy(p + 1, end(), p); return p; } @@ -501,7 +497,7 @@ namespace etl iterator erase(const_iterator first, const_iterator last) { iterator p = const_cast(first); - etlstd::copy(last, cend(), p); + etl::copy(last, cend(), p); return p; } @@ -524,7 +520,7 @@ namespace etl { iterator p = const_cast(position); - etlstd::copy(p + 1, end(), p); + etl::copy(p + 1, end(), p); back() = value; return p; @@ -550,8 +546,8 @@ namespace etl { iterator p = const_cast(first); - p = etlstd::copy(last, cend(), p); - etlstd::fill(p, end(), value); + p = etl::copy(last, cend(), p); + etl::fill(p, end(), value); return const_cast(first); } @@ -580,7 +576,7 @@ namespace etl template bool operator ==(const etl::array& lhs, const etl::array& rhs) { - return etlstd::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()); + return etl::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()); } //************************************************************************* @@ -604,7 +600,7 @@ namespace etl template bool operator <(const etl::array& lhs, const etl::array& rhs) { - return etlstd::lexicographical_compare(lhs.cbegin(), + return etl::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend()); diff --git a/include/etl/array_view.h b/include/etl/array_view.h index 48242b41..a682b665 100644 --- a/include/etl/array_view.h +++ b/include/etl/array_view.h @@ -137,7 +137,7 @@ namespace etl template ETL_CONSTEXPR array_view(const TIterator begin_, const TIterator end_) : mbegin(etl::addressof(*begin_)), - mend(etl::addressof(*begin_) + etlstd::distance(begin_, end_)) + mend(etl::addressof(*begin_) + etl::distance(begin_, end_)) { } @@ -356,7 +356,7 @@ namespace etl void assign(const TIterator begin_, const TIterator end_) { mbegin = etl::addressof(*begin_); - mend = etl::addressof(*begin_) + etlstd::distance(begin_, end_); + mend = etl::addressof(*begin_) + etl::distance(begin_, end_); } //************************************************************************* @@ -411,11 +411,7 @@ namespace etl //************************************************************************* void swap(array_view& other) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL swap(mbegin, other.mbegin); swap(mend, other.mend); @@ -443,7 +439,7 @@ namespace etl friend bool operator == (const array_view& lhs, const array_view& rhs) { return (lhs.size() == rhs.size()) && - etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -459,7 +455,7 @@ namespace etl //************************************************************************* friend bool operator < (const array_view& lhs, const array_view& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/array_wrapper.h b/include/etl/array_wrapper.h index 2f784563..cf72edb2 100644 --- a/include/etl/array_wrapper.h +++ b/include/etl/array_wrapper.h @@ -310,21 +310,17 @@ namespace etl //************************************************************************* void fill(parameter_t value) { - etlstd::fill(begin(), end(), value); + etl::fill(begin(), end(), value); } //************************************************************************* /// Swaps the contents of arrays. //************************************************************************* template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type swap(etl::array_wrapper& other) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL for (size_t i = 0; i < SIZE; ++i) { @@ -340,7 +336,7 @@ namespace etl bool operator == (const etl::array_wrapper& lhs, const etl::array_wrapper& rhs) { - return (SIZEL == SIZER) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (SIZEL == SIZER) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -360,7 +356,7 @@ namespace etl bool operator < (const etl::array_wrapper& lhs, const etl::array_wrapper& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/atomic/atomic_gcc_sync.h b/include/etl/atomic/atomic_gcc_sync.h index 70ba31e7..e2d51cd9 100644 --- a/include/etl/atomic/atomic_gcc_sync.h +++ b/include/etl/atomic/atomic_gcc_sync.h @@ -66,7 +66,7 @@ namespace etl { public: - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Only integral types are supported"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); atomic() : value(0) diff --git a/include/etl/atomic/atomic_llvm_sync.h b/include/etl/atomic/atomic_llvm_sync.h index bf32ba5c..50e0be01 100644 --- a/include/etl/atomic/atomic_llvm_sync.h +++ b/include/etl/atomic/atomic_llvm_sync.h @@ -59,7 +59,7 @@ SOFTWARE. // { // public: // -// ETL_STATIC_ASSERT(etlstd::is_integral::value, "Only integral types are supported"); +// ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); // // atomic() // : value(0) diff --git a/include/etl/basic_string.h b/include/etl/basic_string.h index 04a7fc0c..0e5c56e8 100644 --- a/include/etl/basic_string.h +++ b/include/etl/basic_string.h @@ -40,7 +40,6 @@ SOFTWARE. #include "algorithm.h" #include "iterator.h" #include "functional.h" - #include "char_traits.h" #include "container.h" #include "alignment.h" @@ -286,7 +285,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the string. @@ -418,12 +417,12 @@ namespace etl is_truncated = true; } - new_size = etlstd::min(new_size, CAPACITY); + new_size = etl::min(new_size, CAPACITY); // Size up? if (new_size > current_size) { - etlstd::fill(p_buffer + current_size, p_buffer + new_size, value); + etl::fill(p_buffer + current_size, p_buffer + new_size, value); } current_size = new_size; @@ -596,7 +595,7 @@ namespace etl is_truncated = (length_ > CAPACITY); - length_ = etlstd::min(length_, CAPACITY); + length_ = etl::min(length_, CAPACITY); etl::copy_n(other, length_, begin()); @@ -615,7 +614,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(string_iterator)); #endif @@ -643,9 +642,9 @@ namespace etl is_truncated = (n > CAPACITY); - n = etlstd::min(n, CAPACITY); + n = etl::min(n, CAPACITY); - etlstd::fill_n(begin(), n, value); + etl::fill_n(begin(), n, value); current_size = n; p_buffer[current_size] = 0; } @@ -780,7 +779,7 @@ namespace etl { // Insert in the middle. ++current_size; - etlstd::copy_backward(insert_position, end() - 1, end()); + etl::copy_backward(insert_position, end() - 1, end()); *insert_position = value; } else @@ -796,7 +795,7 @@ namespace etl if (position != end()) { // Insert in the middle. - etlstd::copy_backward(insert_position, end() - 1, end()); + etl::copy_backward(insert_position, end() - 1, end()); *insert_position = value; } @@ -823,7 +822,7 @@ namespace etl // Quick hack, as iterators are pointers. iterator insert_position = const_cast(position); - const size_t start = etlstd::distance(cbegin(), position); + const size_t start = etl::distance(cbegin(), position); // No effect. if (start >= CAPACITY) @@ -841,7 +840,7 @@ namespace etl } current_size = CAPACITY; - etlstd::fill(insert_position, end(), value); + etl::fill(insert_position, end(), value); } else { @@ -850,7 +849,7 @@ namespace etl const size_t to_position = start + shift_amount; const size_t remaining_characters = current_size - start; const size_t max_shift_characters = CAPACITY - start - shift_amount; - const size_t characters_to_shift = etlstd::min(max_shift_characters, remaining_characters); + const size_t characters_to_shift = etl::min(max_shift_characters, remaining_characters); // Will the string truncate? if ((start + shift_amount + remaining_characters) > CAPACITY) @@ -863,8 +862,8 @@ namespace etl current_size += shift_amount; } - etlstd::copy_backward(insert_position, insert_position + characters_to_shift, begin() + to_position + characters_to_shift); - etlstd::fill(insert_position, insert_position + shift_amount, value); + etl::copy_backward(insert_position, insert_position + characters_to_shift, begin() + to_position + characters_to_shift); + etl::fill(insert_position, insert_position + shift_amount, value); } p_buffer[current_size] = 0; @@ -885,8 +884,8 @@ namespace etl return; } - const size_t start = etlstd::distance(begin(), position); - const size_t n = etlstd::distance(first, last); + const size_t start = etl::distance(begin(), position); + const size_t n = etl::distance(first, last); // No effect. if (start >= CAPACITY) @@ -917,7 +916,7 @@ namespace etl const size_t to_position = start + shift_amount; const size_t remaining_characters = current_size - start; const size_t max_shift_characters = CAPACITY - start - shift_amount; - const size_t characters_to_shift = etlstd::min(max_shift_characters, remaining_characters); + const size_t characters_to_shift = etl::min(max_shift_characters, remaining_characters); // Will the string truncate? if ((start + shift_amount + remaining_characters) > CAPACITY) @@ -930,7 +929,7 @@ namespace etl current_size += shift_amount; } - etlstd::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift); + etl::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift); while (first != last) { @@ -1037,7 +1036,7 @@ namespace etl etl::ibasic_string& erase(size_t position, size_t length_ = npos) { // Limit the length. - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); erase(begin() + position, begin() + position + length_); @@ -1051,7 +1050,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - etlstd::copy(i_element + 1, end(), i_element); + etl::copy(i_element + 1, end(), i_element); p_buffer[--current_size] = 0; return i_element; @@ -1067,8 +1066,8 @@ namespace etl //********************************************************************* iterator erase(iterator first, iterator last) { - etlstd::copy(last, end(), first); - size_t n_delete = etlstd::distance(first, last); + etl::copy(last, end(), first); + size_t n_delete = etl::distance(first, last); current_size -= n_delete; p_buffer[current_size] = 0; @@ -1098,7 +1097,7 @@ namespace etl is_truncated = true; } - size_t endpos = etlstd::min(pos + len, size()); + size_t endpos = etl::min(pos + len, size()); for (size_t i = pos; i < endpos; ++i) { @@ -1120,7 +1119,7 @@ namespace etl return npos; } - const_iterator iposition = etlstd::search(begin() + pos, end(), str.begin(), str.end()); + const_iterator iposition = etl::search(begin() + pos, end(), str.begin(), str.end()); if (iposition == end()) { @@ -1128,7 +1127,7 @@ namespace etl } else { - return etlstd::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -1146,7 +1145,7 @@ namespace etl } #endif - const_iterator iposition = etlstd::search(begin() + pos, end(), s, s + etl::strlen(s)); + const_iterator iposition = etl::search(begin() + pos, end(), s, s + etl::strlen(s)); if (iposition == end()) { @@ -1154,7 +1153,7 @@ namespace etl } else { - return etlstd::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -1173,7 +1172,7 @@ namespace etl } #endif - const_iterator iposition = etlstd::search(begin() + pos, end(), s, s + n); + const_iterator iposition = etl::search(begin() + pos, end(), s, s + n); if (iposition == end()) { @@ -1181,7 +1180,7 @@ namespace etl } else { - return etlstd::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -1192,11 +1191,11 @@ namespace etl //********************************************************************* size_t find(T c, size_t position = 0) const { - const_iterator i = etlstd::find(begin() + position, end(), c); + const_iterator i = etl::find(begin() + position, end(), c); if (i != end()) { - return etlstd::distance(begin(), i); + return etl::distance(begin(), i); } else { @@ -1223,7 +1222,7 @@ namespace etl position = size() - position; - const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), str.rbegin(), str.rend()); + const_reverse_iterator iposition = etl::search(rbegin() + position, rend(), str.rbegin(), str.rend()); if (iposition == rend()) { @@ -1231,7 +1230,7 @@ namespace etl } else { - return size() - str.size() - etlstd::distance(rbegin(), iposition); + return size() - str.size() - etl::distance(rbegin(), iposition); } } @@ -1259,7 +1258,7 @@ namespace etl const_reverse_iterator srbegin(s + len); const_reverse_iterator srend(s); - const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), srbegin, srend); + const_reverse_iterator iposition = etl::search(rbegin() + position, rend(), srbegin, srend); if (iposition == rend()) { @@ -1267,7 +1266,7 @@ namespace etl } else { - return size() - len - etlstd::distance(rbegin(), iposition); + return size() - len - etl::distance(rbegin(), iposition); } } @@ -1293,7 +1292,7 @@ namespace etl const_reverse_iterator srbegin(s + length_); const_reverse_iterator srend(s); - const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), srbegin, srend); + const_reverse_iterator iposition = etl::search(rbegin() + position, rend(), srbegin, srend); if (iposition == rend()) { @@ -1301,7 +1300,7 @@ namespace etl } else { - return size() - length_ - etlstd::distance(rbegin(), iposition); + return size() - length_ - etl::distance(rbegin(), iposition); } } @@ -1319,11 +1318,11 @@ namespace etl position = size() - position; - const_reverse_iterator i = etlstd::find(rbegin() + position, rend(), c); + const_reverse_iterator i = etl::find(rbegin() + position, rend(), c); if (i != rend()) { - return size() - etlstd::distance(rbegin(), i) - 1; + return size() - etl::distance(rbegin(), i) - 1; } else { @@ -1342,7 +1341,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1388,8 +1387,8 @@ namespace etl ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds)); // Limit the lengths. - length_ = etlstd::min(length_, size() - position); - sublength = etlstd::min(sublength, str.size() - subposition); + length_ = etl::min(length_, size() - position); + sublength = etl::min(sublength, str.size() - subposition); // Erase the bit we want to replace. erase(position, length_); @@ -1413,7 +1412,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1450,7 +1449,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1487,7 +1486,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1554,7 +1553,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); return compare(p_buffer + position, p_buffer + position + length_, @@ -1571,8 +1570,8 @@ namespace etl ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds)); // Limit the lengths. - length_ = etlstd::min(length_, size() - position); - sublength = etlstd::min(sublength, str.size() - subposition); + length_ = etl::min(length_, size() - position); + sublength = etl::min(sublength, str.size() - subposition); return compare(p_buffer + position, p_buffer + position + length_, @@ -1712,7 +1711,7 @@ namespace etl return npos; } - position = etlstd::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1745,7 +1744,7 @@ namespace etl return npos; } - position = etlstd::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1869,7 +1868,7 @@ namespace etl return npos; } - position = etlstd::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1907,7 +1906,7 @@ namespace etl return npos; } - position = etlstd::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -2106,7 +2105,7 @@ namespace etl template bool operator ==(const etl::ibasic_string& lhs, const etl::ibasic_string& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2119,7 +2118,7 @@ namespace etl template bool operator ==(const etl::ibasic_string& lhs, const T* rhs) { - return (lhs.size() == etl::strlen(rhs)) && etlstd::equal(lhs.begin(), lhs.end(), rhs); + return (lhs.size() == etl::strlen(rhs)) && etl::equal(lhs.begin(), lhs.end(), rhs); } //*************************************************************************** @@ -2132,7 +2131,7 @@ namespace etl template bool operator ==(const T* lhs, const etl::ibasic_string& rhs) { - return (rhs.size() == etl::strlen(lhs)) && etlstd::equal(rhs.begin(), rhs.end(), lhs); + return (rhs.size() == etl::strlen(lhs)) && etl::equal(rhs.begin(), rhs.end(), lhs); } @@ -2185,7 +2184,7 @@ namespace etl template bool operator <(const etl::ibasic_string& lhs, const etl::ibasic_string& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** @@ -2198,7 +2197,7 @@ namespace etl template bool operator <(const etl::ibasic_string& lhs, const T* rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs)); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs)); } //*************************************************************************** @@ -2211,7 +2210,7 @@ namespace etl template bool operator <(const T* lhs, const etl::ibasic_string& rhs) { - return etlstd::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end()); } diff --git a/include/etl/binary.h b/include/etl/binary.h index ff12ef7e..f81f3d05 100644 --- a/include/etl/binary.h +++ b/include/etl/binary.h @@ -110,7 +110,7 @@ namespace etl template T rotate_left(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); const size_t SHIFT = etl::integral_limits::type>::bits - 1; @@ -124,7 +124,7 @@ namespace etl template T rotate_left(T value, size_t distance) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); const size_t BITS = etl::integral_limits::type>::bits; distance %= BITS; @@ -140,7 +140,7 @@ namespace etl template T rotate_right(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); const size_t SHIFT = etl::integral_limits::type>::bits - 1; @@ -154,7 +154,7 @@ namespace etl template T rotate_right(T value, size_t distance) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); const size_t BITS = etl::integral_limits::type>::bits; distance %= BITS; @@ -171,7 +171,7 @@ namespace etl template T rotate(T value, typename etl::make_signed::type distance) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); T result; @@ -194,7 +194,7 @@ namespace etl template T binary_to_gray(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); return (value >> 1) ^ value; } @@ -235,10 +235,10 @@ namespace etl template TReturn sign_extend(TValue value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TValue not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TReturn not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_signed::value, "TReturn not a signed type"); - ETL_STATIC_ASSERT(NBITS <= etlstd::numeric_limits::digits, "NBITS too large for return type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TValue not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TReturn not an integral type"); + ETL_STATIC_ASSERT(etl::is_signed::value, "TReturn not a signed type"); + ETL_STATIC_ASSERT(NBITS <= etl::numeric_limits::digits, "NBITS too large for return type"); struct S { @@ -257,11 +257,11 @@ namespace etl template TReturn sign_extend(TValue value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TValue not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TReturn not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_signed::value, "TReturn not a signed type"); - ETL_STATIC_ASSERT(NBITS <= etlstd::numeric_limits::digits, "NBITS too large for return type"); - ETL_STATIC_ASSERT(SHIFT <= etlstd::numeric_limits::digits, "SHIFT too large"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TValue not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TReturn not an integral type"); + ETL_STATIC_ASSERT(etl::is_signed::value, "TReturn not a signed type"); + ETL_STATIC_ASSERT(NBITS <= etl::numeric_limits::digits, "NBITS too large for return type"); + ETL_STATIC_ASSERT(SHIFT <= etl::numeric_limits::digits, "SHIFT too large"); struct S { @@ -279,11 +279,11 @@ namespace etl template TReturn sign_extend(TValue value, const size_t NBITS) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TValue not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TReturn not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_signed::value, "TReturn not a signed type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TValue not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TReturn not an integral type"); + ETL_STATIC_ASSERT(etl::is_signed::value, "TReturn not a signed type"); - ETL_ASSERT((NBITS <= etlstd::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); + ETL_ASSERT((NBITS <= etl::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); TReturn mask = TReturn(1) << (NBITS - 1); value = value & static_cast((TReturn(1) << NBITS) - 1); @@ -300,11 +300,11 @@ namespace etl template TReturn sign_extend(TValue value, const size_t NBITS, const size_t SHIFT) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TValue not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_integral::value, "TReturn not an integral type"); - ETL_STATIC_ASSERT(etlstd::is_signed::value, "TReturn not a signed type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TValue not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "TReturn not an integral type"); + ETL_STATIC_ASSERT(etl::is_signed::value, "TReturn not a signed type"); - ETL_ASSERT((NBITS <= etlstd::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); + ETL_ASSERT((NBITS <= etl::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); TReturn mask = TReturn(1) << (NBITS - 1); value = (value >> SHIFT) & static_cast((TReturn(1) << NBITS) - 1); @@ -1207,7 +1207,7 @@ namespace etl ///\ingroup binary //*************************************************************************** template - typename etlstd::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type is_odd(const T value) { return ((static_cast::type>(value) & 1U) != 0U); @@ -1218,7 +1218,7 @@ namespace etl ///\ingroup binary //*************************************************************************** template - typename etlstd::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type is_even(const T value) { return ((static_cast::type>(value) & 1U) == 0U); diff --git a/include/etl/bit_stream.h b/include/etl/bit_stream.h index 44acb860..c662edd0 100644 --- a/include/etl/bit_stream.h +++ b/include/etl/bit_stream.h @@ -67,7 +67,7 @@ namespace etl //*************************************************************************** bit_stream(char* begin_, char* end_) : pdata(reinterpret_cast(begin_)), - length(etlstd::distance(begin_, end_)) + length(etl::distance(begin_, end_)) { restart(); } @@ -77,7 +77,7 @@ namespace etl //*************************************************************************** bit_stream(unsigned char* begin_, unsigned char* end_) : pdata(begin_), - length(etlstd::distance(begin_, end_)) + length(etl::distance(begin_, end_)) { restart(); } @@ -127,7 +127,7 @@ namespace etl //*************************************************************************** void set_stream(char* begin_, char* end_) { - set_stream(begin_, etlstd::distance(begin_, end_)); + set_stream(begin_, etl::distance(begin_, end_)); } //*************************************************************************** @@ -135,7 +135,7 @@ namespace etl //*************************************************************************** void set_stream(unsigned char* begin_, unsigned char* end_) { - set_stream(begin_, etlstd::distance(begin_, end_)); + set_stream(begin_, etl::distance(begin_, end_)); } //*************************************************************************** @@ -180,7 +180,7 @@ namespace etl /// For integral types //*************************************************************************** template - typename etlstd::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type put(T value, uint_least8_t width = CHAR_BIT * sizeof(T)) { return put_integral(static_cast(value), width); @@ -206,7 +206,7 @@ namespace etl /// For floating point types //*************************************************************************** template - typename etlstd::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type put(T value) { bool success = true; @@ -249,7 +249,7 @@ namespace etl /// For integral types //*************************************************************************** template - typename etlstd::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type get(T& value, uint_least8_t width = CHAR_BIT * sizeof(T)) { bool success = false; @@ -265,7 +265,7 @@ namespace etl // Get the bits from the stream. while (width != 0) { - unsigned char mask_width = static_cast(etlstd::min(width, bits_in_byte)); + unsigned char mask_width = static_cast(etl::min(width, bits_in_byte)); unsigned char chunk = get_chunk(mask_width); width -= mask_width; @@ -277,7 +277,7 @@ namespace etl } // Sign extend if signed type and not already full bit width. - if (etlstd::is_signed::value && (bits != (CHAR_BIT * sizeof(T)))) + if (etl::is_signed::value && (bits != (CHAR_BIT * sizeof(T)))) { typedef typename etl::make_signed::type ST; value = etl::sign_extend(value, bits); @@ -290,7 +290,7 @@ namespace etl /// For floating point types //*************************************************************************** template - typename etlstd::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type get(T& value) { bool success = false; @@ -378,7 +378,7 @@ namespace etl // Send the bits to the stream. while (width != 0) { - unsigned char mask_width = static_cast(etlstd::min(width, bits_in_byte)); + unsigned char mask_width = static_cast(etl::min(width, bits_in_byte)); width -= mask_width; uint32_t mask = ((uint32_t(1U) << mask_width) - 1U) << width; @@ -411,7 +411,7 @@ namespace etl // Send the bits to the stream. while (width != 0) { - unsigned char mask_width = static_cast(etlstd::min(width, bits_in_byte)); + unsigned char mask_width = static_cast(etl::min(width, bits_in_byte)); width -= mask_width; uint64_t mask = ((uint64_t(1U) << mask_width) - 1U) << width; @@ -494,11 +494,11 @@ namespace etl // Network to host. if (etl::endianness::value() == etl::endian::little) { - etlstd::reverse_copy(data, data + sizeof(T), temp); + etl::reverse_copy(data, data + sizeof(T), temp); } else { - etlstd::copy(data, data + sizeof(T), temp); + etl::copy(data, data + sizeof(T), temp); } value = *reinterpret_cast(temp); @@ -515,11 +515,11 @@ namespace etl // Host to network. if (etl::endianness::value() == etl::endian::little) { - etlstd::reverse_copy(pf, pf + sizeof(T), data); + etl::reverse_copy(pf, pf + sizeof(T), data); } else { - etlstd::copy(pf, pf + sizeof(T), data); + etl::copy(pf, pf + sizeof(T), data); } } diff --git a/include/etl/bitset.h b/include/etl/bitset.h index f68a16e4..9d71f50d 100644 --- a/include/etl/bitset.h +++ b/include/etl/bitset.h @@ -312,7 +312,7 @@ namespace etl { reset(); - size_t i = etlstd::min(NBITS, etl::strlen(text)); + size_t i = etl::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -329,7 +329,7 @@ namespace etl { reset(); - size_t i = etlstd::min(NBITS, etl::strlen(text)); + size_t i = etl::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -346,7 +346,7 @@ namespace etl { reset(); - size_t i = etlstd::min(NBITS, etl::strlen(text)); + size_t i = etl::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -363,7 +363,7 @@ namespace etl { reset(); - size_t i = etlstd::min(NBITS, etl::strlen(text)); + size_t i = etl::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -380,7 +380,7 @@ namespace etl { reset(); - size_t i = etlstd::min(NBITS, etl::strlen(text)); + size_t i = etl::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -394,7 +394,7 @@ namespace etl /// Put to a value. //************************************************************************* template - typename etlstd::enable_if::value, T>::type + typename etl::enable_if::value, T>::type value() const { T v = T(0); @@ -818,7 +818,7 @@ namespace etl //************************************************************************* static bool is_equal(const ibitset& lhs, const ibitset&rhs) { - return etlstd::equal(lhs.pdata, lhs.pdata + lhs.SIZE, rhs.pdata); + return etl::equal(lhs.pdata, lhs.pdata + lhs.SIZE, rhs.pdata); } element_t TOP_MASK; @@ -976,7 +976,7 @@ namespace etl /// Put to a value. //************************************************************************* template - typename etlstd::enable_if::value, T>::type + typename etl::enable_if::value, T>::type value() const { ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (ARRAY_SIZE * BITS_PER_ELEMENT), "Type too small"); diff --git a/include/etl/bloom_filter.h b/include/etl/bloom_filter.h index dc498d15..0ec97c38 100644 --- a/include/etl/bloom_filter.h +++ b/include/etl/bloom_filter.h @@ -104,12 +104,12 @@ namespace etl { flags.set(get_hash(key)); - if (!etlstd::is_same::value) + if (!etl::is_same::value) { flags.set(get_hash(key)); } - if (!etlstd::is_same::value) + if (!etl::is_same::value) { flags.set(get_hash(key)); } @@ -127,13 +127,13 @@ namespace etl bool exists3 = true; // Do we have a second hash? - if (!etlstd::is_same::value) + if (!etl::is_same::value) { exists2 = flags[get_hash(key)]; } // Do we have a third hash? - if (!etlstd::is_same::value) + if (!etl::is_same::value) { exists3 = flags[get_hash(key)]; } diff --git a/include/etl/char_traits.h b/include/etl/char_traits.h index cdbfe298..36cffb37 100644 --- a/include/etl/char_traits.h +++ b/include/etl/char_traits.h @@ -140,7 +140,7 @@ namespace etl { if (p != 0) { - etlstd::fill_n(p, n, c); + etl::fill_n(p, n, c); } return p; diff --git a/include/etl/compare.h b/include/etl/compare.h index fc23c418..90ceae28 100644 --- a/include/etl/compare.h +++ b/include/etl/compare.h @@ -47,7 +47,7 @@ namespace etl /// Defines <=, >, >= interms of < /// Default //*************************************************************************** - template > + template > struct compare { typedef typename etl::parameter_type::type first_argument_type; diff --git a/include/etl/container.h b/include/etl/container.h index 572a6286..efdea919 100644 --- a/include/etl/container.h +++ b/include/etl/container.h @@ -273,7 +273,7 @@ namespace etl char(&array_size(T(&array)[ARRAY_SIZE]))[ARRAY_SIZE]; } -#if ETL_CPP11_SUPPORTED +#if ETL_CPP11_SUPPORTED && !defined(ETL_FORCE_NO_ADVANCED_CPP) #define ETL_ARRAY_SIZE(a) (etl::size(a)) #else #define ETL_ARRAY_SIZE(a) sizeof(etl::array_size(a)) diff --git a/include/etl/cstring.h b/include/etl/cstring.h index 9479f394..9dee9685 100644 --- a/include/etl/cstring.h +++ b/include/etl/cstring.h @@ -191,7 +191,7 @@ namespace etl { ETL_ASSERT(position < this->size(), ETL_ERROR(string_out_of_bounds)); - length_ = etlstd::min(length_, this->size() - position); + length_ = etl::min(length_, this->size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/include/etl/cumulative_moving_average.h b/include/etl/cumulative_moving_average.h index eedb774e..1480152d 100644 --- a/include/etl/cumulative_moving_average.h +++ b/include/etl/cumulative_moving_average.h @@ -44,8 +44,8 @@ namespace etl template ::value, - const bool IsFloat = etlstd::is_floating_point::value> + const bool IsIntegral = etl::is_integral::value, + const bool IsFloat = etl::is_floating_point::value> class cumulative_moving_average; //*************************************************************************** @@ -58,8 +58,8 @@ namespace etl template class cumulative_moving_average { - typedef typename etlstd::conditional::value, int32_t, uint32_t>::type scale_t; - typedef typename etlstd::conditional::value, int32_t, uint32_t>::type sample_t; + typedef typename etl::conditional::value, int32_t, uint32_t>::type scale_t; + typedef typename etl::conditional::value, int32_t, uint32_t>::type sample_t; static const sample_t SAMPLES = static_cast(SAMPLE_SIZE_); static const scale_t SCALE = static_cast(SCALING_); @@ -121,8 +121,8 @@ namespace etl template class cumulative_moving_average { - typedef typename etlstd::conditional::value, int32_t, uint32_t>::type scale_t; - typedef typename etlstd::conditional::value, int32_t, uint32_t>::type sample_t; + typedef typename etl::conditional::value, int32_t, uint32_t>::type scale_t; + typedef typename etl::conditional::value, int32_t, uint32_t>::type sample_t; static const scale_t SCALE = static_cast(SCALING_); diff --git a/include/etl/cyclic_value.h b/include/etl/cyclic_value.h index b4173bc6..78277bfb 100644 --- a/include/etl/cyclic_value.h +++ b/include/etl/cyclic_value.h @@ -257,11 +257,7 @@ namespace etl //************************************************************************* void swap(cyclic_value& other) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL swap(value, other.value); } @@ -304,7 +300,7 @@ namespace etl ///\ingroup cyclic_value //*************************************************************************** template - class cyclic_value::type> + class cyclic_value::type> { public: @@ -537,11 +533,7 @@ namespace etl //************************************************************************* void swap(cyclic_value& other) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL swap(first_value, other.first_value); swap(last_value, other.last_value); diff --git a/include/etl/deque.h b/include/etl/deque.h index 94bddb7e..522953e0 100644 --- a/include/etl/deque.h +++ b/include/etl/deque.h @@ -239,7 +239,7 @@ namespace etl #endif typedef T* pointer; typedef const T* const_pointer; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -247,7 +247,7 @@ namespace etl /// Test for an iterator. //************************************************************************* template - struct is_iterator : public etl::integral_constant::value && !etlstd::is_floating_point::value> + struct is_iterator : public etl::integral_constant::value && !etl::is_floating_point::value> { }; @@ -421,11 +421,7 @@ namespace etl //*************************************************** void swap(iterator& other) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL swap(index, other.index); } @@ -647,7 +643,7 @@ namespace etl /// Assigns a range to the deque. //************************************************************************* template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type assign(TIterator range_begin, TIterator range_end) { initialise(); @@ -899,13 +895,13 @@ namespace etl else { // Are we closer to the front? - if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - etlstd::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. *--position = value; @@ -916,7 +912,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - etlstd::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. *position = value; @@ -941,38 +937,38 @@ namespace etl if (insert_position == begin()) { - create_element_front(etlstd::move(value)); + create_element_front(etl::move(value)); position = _begin; } else if (insert_position == end()) { - create_element_back(etlstd::move(value)); + create_element_back(etl::move(value)); position = _end - 1; } else { // Are we closer to the front? - if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. - create_element_front(etlstd::move(*_begin)); + create_element_front(etl::move(*_begin)); // Move the values. - etlstd::move(_begin + 1, position, _begin); + etl::move(_begin + 1, position, _begin); // Write the new value. - *--position = etlstd::move(value); + *--position = etl::move(value); } else { // Construct the _end. - create_element_back(etlstd::move(*(_end - 1))); + create_element_back(etl::move(*(_end - 1))); // Move the values. - etlstd::move_backward(position, _end - 2, _end - 1); + etl::move_backward(position, _end - 2, _end - 1); // Write the new value. - *position = etlstd::move(value); + *position = etl::move(value); } } @@ -1014,13 +1010,13 @@ namespace etl else { // Are we closer to the front? - if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - etlstd::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1033,7 +1029,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - etlstd::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1041,7 +1037,7 @@ namespace etl } } - ::new (p) T(etlstd::forward(args)...); + ::new (p) T(etl::forward(args)...); return position; } @@ -1081,13 +1077,13 @@ namespace etl else { // Are we closer to the front? - if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - etlstd::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1100,7 +1096,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - etlstd::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1146,13 +1142,13 @@ namespace etl else { // Are we closer to the front? - if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - etlstd::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1165,7 +1161,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - etlstd::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1211,13 +1207,13 @@ namespace etl else { // Are we closer to the front? - if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - etlstd::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1230,7 +1226,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - etlstd::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1276,13 +1272,13 @@ namespace etl else { // Are we closer to the front? - if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - etlstd::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1295,7 +1291,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - etlstd::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1349,8 +1345,8 @@ namespace etl if (distance(_begin, insert_position) <= difference_type(current_size / 2)) { size_t n_insert = n; - size_t n_move = etlstd::distance(begin(), position); - size_t n_create_copy = etlstd::min(n_insert, n_move); + size_t n_move = etl::distance(begin(), position); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1378,15 +1374,15 @@ namespace etl // Copy new. to = position - n_create_copy; - etlstd::fill_n(to, n_copy_new, value); + etl::fill_n(to, n_copy_new, value); position = _begin + n_move; } else { size_t n_insert = n; - size_t n_move = etlstd::distance(position, end()); - size_t n_create_copy = etlstd::min(n_insert, n_move); + size_t n_move = etl::distance(position, end()); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1406,10 +1402,10 @@ namespace etl } // Copy old. - etlstd::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); + etl::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); // Copy new. - etlstd::fill_n(position, n_copy_new, value); + etl::fill_n(position, n_copy_new, value); } } @@ -1429,7 +1425,7 @@ namespace etl { iterator position; - difference_type n = etlstd::distance(range_begin, range_end); + difference_type n = etl::distance(range_begin, range_end); ETL_ASSERT((current_size + n) <= CAPACITY, ETL_ERROR(deque_full)); @@ -1457,8 +1453,8 @@ namespace etl if (distance(_begin, insert_position) < difference_type(current_size / 2)) { size_t n_insert = n; - size_t n_move = etlstd::distance(begin(), position); - size_t n_create_copy = etlstd::min(n_insert, n_move); + size_t n_move = etl::distance(begin(), position); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1488,8 +1484,8 @@ namespace etl else { size_t n_insert = n; - size_t n_move = etlstd::distance(position, end()); - size_t n_create_copy = etlstd::min(n_insert, n_move); + size_t n_move = etl::distance(position, end()); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1510,7 +1506,7 @@ namespace etl } // Copy old. - etlstd::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); + etl::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); // Copy new. item = range_begin; @@ -1547,13 +1543,13 @@ namespace etl // Are we closer to the front? if (distance(_begin, position) < difference_type(current_size / 2)) { - etlstd::copy_backward(_begin, position, position + 1); + etl::copy_backward(_begin, position, position + 1); destroy_element_front(); ++position; } else { - etlstd::copy(position + 1, _end, position); + etl::copy(position + 1, _end, position); destroy_element_back(); } } @@ -1574,7 +1570,7 @@ namespace etl ETL_ASSERT((distance(range_begin) <= difference_type(current_size)) && (distance(range_end) <= difference_type(current_size)), ETL_ERROR(deque_out_of_bounds)); // How many to erase? - size_t length = etlstd::distance(range_begin, range_end); + size_t length = etl::distance(range_begin, range_end); // At the beginning? if (position == _begin) @@ -1603,7 +1599,7 @@ namespace etl if (distance(_begin, position) < difference_type(current_size / 2)) { // Move the items. - etlstd::copy_backward(_begin, position, position + length); + etl::copy_backward(_begin, position, position + length); for (size_t i = 0; i < length; ++i) { @@ -1616,7 +1612,7 @@ namespace etl // Must be closer to the back. { // Move the items. - etlstd::copy(position + length, _end, position); + etl::copy(position + length, _end, position); for (size_t i = 0; i < length; ++i) { @@ -1652,7 +1648,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(deque_full)); #endif - create_element_back(etlstd::move(item)); + create_element_back(etl::move(item)); } #endif @@ -1668,7 +1664,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(deque_full)); #endif - ::new (&(*_end)) T(etlstd::forward(args)...); + ::new (&(*_end)) T(etl::forward(args)...); ++_end; ++current_size; ETL_INCREMENT_DEBUG_COUNT @@ -1780,7 +1776,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(deque_full)); #endif - create_element_front(etlstd::move(item)); + create_element_front(etl::move(item)); } #endif @@ -1797,7 +1793,7 @@ namespace etl #endif --_begin; - ::new (&(*_begin)) T(etlstd::forward(args)...); + ::new (&(*_begin)) T(etl::forward(args)...); ++current_size; ETL_INCREMENT_DEBUG_COUNT } @@ -1971,7 +1967,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(etlstd::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -2123,7 +2119,7 @@ namespace etl void create_element_front(rvalue_reference value) { --_begin; - ::new (&(*_begin)) T(etlstd::move(value)); + ::new (&(*_begin)) T(etl::move(value)); ++current_size; ETL_INCREMENT_DEBUG_COUNT } @@ -2133,7 +2129,7 @@ namespace etl //********************************************************************* void create_element_back(rvalue_reference value) { - ::new (&(*_end)) T(etlstd::move(value)); + ::new (&(*_end)) T(etl::move(value)); ++_end; ++current_size; ETL_INCREMENT_DEBUG_COUNT @@ -2239,7 +2235,7 @@ namespace etl typedef T& reference; typedef const T& const_reference; typedef size_t size_type; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //************************************************************************* /// Default constructor. @@ -2284,7 +2280,7 @@ namespace etl typename etl::ideque::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2348,7 +2344,7 @@ namespace etl typename etl::ideque::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2377,7 +2373,7 @@ namespace etl private: /// The uninitialised buffer of T used in the deque. - typename etl::aligned_storage::value>::type buffer[BUFFER_SIZE]; + typename etl::aligned_storage::value>::type buffer[BUFFER_SIZE]; }; //*************************************************************************** @@ -2390,7 +2386,7 @@ namespace etl template bool operator ==(const etl::ideque& lhs, const etl::ideque& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2416,7 +2412,7 @@ namespace etl template bool operator <(const etl::ideque& lhs, const etl::ideque& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); diff --git a/include/etl/fixed_iterator.h b/include/etl/fixed_iterator.h index 8fdaf77e..ebe39467 100644 --- a/include/etl/fixed_iterator.h +++ b/include/etl/fixed_iterator.h @@ -45,7 +45,7 @@ namespace etl /// This can be useful when using STL algorithms to interact with fixed memory locations such as registers. ///\ingroup iterator template - class fixed_iterator : etl::iterator::iterator_category, typename etlstd::iterator_traits::value_type> + class fixed_iterator : etl::iterator::iterator_category, typename etl::iterator_traits::value_type> { public: @@ -100,7 +100,7 @@ namespace etl //*************************************************************************** /// Dereference operator. //*************************************************************************** - typename etlstd::iterator_traits::value_type operator *() + typename etl::iterator_traits::value_type operator *() { return *it; } @@ -108,7 +108,7 @@ namespace etl //*************************************************************************** /// Dereference operator. //*************************************************************************** - const typename etlstd::iterator_traits::value_type operator *() const + const typename etl::iterator_traits::value_type operator *() const { return *it; } @@ -140,7 +140,7 @@ namespace etl //*************************************************************************** /// += operator. //*************************************************************************** - fixed_iterator& operator +=(typename etlstd::iterator_traits::difference_type /*offset*/) + fixed_iterator& operator +=(typename etl::iterator_traits::difference_type /*offset*/) { return *this; } @@ -148,7 +148,7 @@ namespace etl //*************************************************************************** /// -= operator. //*************************************************************************** - fixed_iterator& operator -=(typename etlstd::iterator_traits::difference_type /*offset*/) + fixed_iterator& operator -=(typename etl::iterator_traits::difference_type /*offset*/) { return *this; } @@ -181,7 +181,7 @@ namespace etl //***************************************************************************** template etl::fixed_iterator& operator +(etl::fixed_iterator& lhs, - typename etlstd::iterator_traits::difference_type /*rhs*/) + typename etl::iterator_traits::difference_type /*rhs*/) { return lhs; } @@ -191,7 +191,7 @@ namespace etl //***************************************************************************** template etl::fixed_iterator& operator -(etl::fixed_iterator& lhs, - typename etlstd::iterator_traits::difference_type /*rhs*/) + typename etl::iterator_traits::difference_type /*rhs*/) { return lhs; } @@ -200,7 +200,7 @@ namespace etl /// - fixed_iterator operator. //***************************************************************************** template - typename etlstd::iterator_traits::difference_type operator -(etl::fixed_iterator& lhs, + typename etl::iterator_traits::difference_type operator -(etl::fixed_iterator& lhs, etl::fixed_iterator& rhs) { return TIterator(lhs) - TIterator(rhs); diff --git a/include/etl/flat_map.h b/include/etl/flat_map.h index 1e0e0200..66494873 100644 --- a/include/etl/flat_map.h +++ b/include/etl/flat_map.h @@ -60,7 +60,7 @@ namespace etl /// Can be used as a reference type for all flat_maps containing a specific type. ///\ingroup flat_map //*************************************************************************** - template > + template > class iflat_map : private etl::ireference_flat_map { private: @@ -87,7 +87,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -232,7 +232,7 @@ namespace etl //********************************************************************* mapped_type& operator [](key_parameter_t key) { - return insert(ETL_MAKE_PAIR(key, mapped_type())).first->second; + return insert(ETL_OR_STD::make_pair(key, mapped_type())).first->second; } //********************************************************************* @@ -268,7 +268,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_map_full)); #endif @@ -352,7 +352,7 @@ namespace etl // Create it. value_type* pvalue = storage.allocate(); ::new ((void*)etl::addressof(pvalue->first)) key_type(key); - ::new ((void*)etl::addressof(pvalue->second)) mapped_type(etlstd::forward(args)...); + ::new ((void*)etl::addressof(pvalue->second)) mapped_type(etl::forward(args)...); iterator i_element = lower_bound(key); @@ -793,7 +793,7 @@ namespace etl template bool operator ==(const etl::iflat_map& lhs, const etl::iflat_map& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -813,11 +813,11 @@ namespace etl /// A flat_map implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = etlstd::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_map //*************************************************************************** - template > + template > class flat_map : public etl::iflat_map { public: diff --git a/include/etl/flat_multimap.h b/include/etl/flat_multimap.h index 67a739ad..d4066458 100644 --- a/include/etl/flat_multimap.h +++ b/include/etl/flat_multimap.h @@ -59,7 +59,7 @@ namespace etl /// Can be used as a reference type for all flat_multimaps containing a specific type. ///\ingroup flat_multimap //*************************************************************************** - template > + template > class iflat_multimap : public etl::ireference_flat_multimap { public: @@ -88,7 +88,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -237,7 +237,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multimap_full)); #endif @@ -334,7 +334,7 @@ namespace etl // Create it. value_type* pvalue = storage.allocate(); ::new ((void*)etl::addressof(pvalue->first)) key_type(key); - ::new ((void*)etl::addressof(pvalue->second)) mapped_type(etlstd::forward(args)...); + ::new ((void*)etl::addressof(pvalue->second)) mapped_type(etl::forward(args)...); iterator i_element = lower_bound(key); ETL_INCREMENT_DEBUG_COUNT @@ -431,7 +431,7 @@ namespace etl } else { - size_t d = etlstd::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -700,7 +700,7 @@ namespace etl template bool operator ==(const etl::iflat_multimap& lhs, const etl::iflat_multimap& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -720,11 +720,11 @@ namespace etl /// A flat_multimap implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = etlstd::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_multimap //*************************************************************************** - template > + template > class flat_multimap : public etl::iflat_multimap { public: diff --git a/include/etl/flat_multiset.h b/include/etl/flat_multiset.h index 4bd21bf9..23a793c7 100644 --- a/include/etl/flat_multiset.h +++ b/include/etl/flat_multiset.h @@ -57,7 +57,7 @@ namespace etl /// Can be used as a reference type for all flat_multisets containing a specific type. ///\ingroup flat_multiset //*************************************************************************** - template > + template > class iflat_multiset : private etl::ireference_flat_multiset { private: @@ -82,7 +82,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -209,7 +209,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multiset_full)); #endif @@ -232,7 +232,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full)); - iterator i_element = etlstd::lower_bound(begin(), end(), value, compare); + iterator i_element = etl::lower_bound(begin(), end(), value, compare); value_type* pvalue = storage.allocate(); ::new (pvalue) value_type(value); @@ -289,7 +289,7 @@ namespace etl // Create it. value_type* pvalue = storage.allocate(); - ::new (pvalue) value_type(etlstd::forward(args)...); + ::new (pvalue) value_type(etl::forward(args)...); iterator i_element = lower_bound(*pvalue); @@ -385,7 +385,7 @@ namespace etl } else { - size_t d = etlstd::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -656,7 +656,7 @@ namespace etl template bool operator ==(const etl::iflat_multiset& lhs, const etl::iflat_multiset& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -675,11 +675,11 @@ namespace etl //*************************************************************************** /// A flat_multiset implementation that uses a fixed size buffer. ///\tparam T The value type. - ///\tparam TCompare The type to compare keys. Default = etlstd::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_multiset //*************************************************************************** - template > + template > class flat_multiset : public etl::iflat_multiset { public: diff --git a/include/etl/flat_set.h b/include/etl/flat_set.h index 0b997420..ff2aac95 100644 --- a/include/etl/flat_set.h +++ b/include/etl/flat_set.h @@ -59,7 +59,7 @@ namespace etl /// Can be used as a reference type for all flat_sets containing a specific type. ///\ingroup flat_set //*************************************************************************** - template > + template > class iflat_set : private etl::ireference_flat_set { private: @@ -84,7 +84,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -211,7 +211,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full)); #endif @@ -296,7 +296,7 @@ namespace etl // Create it. value_type* pvalue = storage.allocate(); - ::new (pvalue) value_type(etlstd::forward(args)...); + ::new (pvalue) value_type(etl::forward(args)...); iterator i_element = lower_bound(*pvalue); @@ -739,7 +739,7 @@ namespace etl template bool operator ==(const etl::iflat_set& lhs, const etl::iflat_set& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -758,11 +758,11 @@ namespace etl //*************************************************************************** /// A flat_set implementation that uses a fixed size buffer. ///\tparam T The value type. - ///\tparam TCompare The type to compare keys. Default = etlstd::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_set //*************************************************************************** - template > + template > class flat_set : public etl::iflat_set { public: diff --git a/include/etl/forward_list.h b/include/etl/forward_list.h index 7cabec02..5a551d77 100644 --- a/include/etl/forward_list.h +++ b/include/etl/forward_list.h @@ -572,7 +572,7 @@ namespace etl const node_t* p_node; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //************************************************************************* /// Gets the beginning of the forward_list. @@ -671,7 +671,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(forward_list_iterator)); #endif @@ -735,7 +735,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); #endif - data_node_t& data_node = allocate_data_node(etlstd::move(value)); + data_node_t& data_node = allocate_data_node(etl::move(value)); insert_node_after(start_node, data_node); } #endif @@ -751,7 +751,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); #endif data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(etlstd::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node_after(start_node, *p_data_node); } @@ -907,7 +907,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(etlstd::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node_after(*position.p_node, *p_data_node); @@ -1001,7 +1001,7 @@ namespace etl void insert_after(iterator position, TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT((d + size()) <= MAX_SIZE, ETL_ERROR(forward_list_full)); #endif @@ -1141,7 +1141,7 @@ namespace etl //************************************************************************* void unique() { - unique(etlstd::equal_to()); + unique(etl::equal_to()); } //************************************************************************* @@ -1182,7 +1182,7 @@ namespace etl //************************************************************************* void sort() { - sort(etlstd::less()); + sort(etl::less()); } //************************************************************************* @@ -1386,7 +1386,7 @@ namespace etl //************************************************************************* iforward_list& operator = (iforward_list&& rhs) { - move_container(etlstd::move(rhs)); + move_container(etl::move(rhs)); return *this; } @@ -1460,7 +1460,7 @@ namespace etl data_node_t& allocate_data_node(rvalue_reference value) { data_node_t* p_node = p_node_pool->allocate(); - ::new (&(p_node->value)) T(etlstd::move(value)); + ::new (&(p_node->value)) T(etl::move(value)); ETL_INCREMENT_DEBUG_COUNT return *p_node; @@ -1487,7 +1487,7 @@ namespace etl { ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); - data_node_t& data_node = this->allocate_data_node(etlstd::move(*first++)); + data_node_t& data_node = this->allocate_data_node(etl::move(*first++)); join(p_last_node, &data_node); data_node.next = nullptr; p_last_node = &data_node; @@ -1633,7 +1633,7 @@ namespace etl forward_list(forward_list&& other) : etl::iforward_list(node_pool, MAX_SIZE, false) { - this->move_container(etlstd::move(other)); + this->move_container(etl::move(other)); } #endif @@ -1686,7 +1686,7 @@ namespace etl forward_list& operator = (forward_list&& rhs) { - this->move_container(etlstd::move(rhs)); + this->move_container(etl::move(rhs)); return *this; } @@ -1774,7 +1774,7 @@ namespace etl typename etl::iforward_list::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -1831,7 +1831,7 @@ namespace etl //************************************************************************* forward_list& operator = (forward_list&& rhs) { - this->move_container(etlstd::move(rhs)); + this->move_container(etl::move(rhs)); return *this; } @@ -1862,7 +1862,7 @@ namespace etl bool operator ==(const etl::iforward_list& lhs, const etl::iforward_list& rhs) { return (lhs.size() == rhs.size()) && - etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -1887,7 +1887,7 @@ namespace etl template bool operator <(const etl::iforward_list& lhs, const etl::iforward_list& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/frame_check_sequence.h b/include/etl/frame_check_sequence.h index 7873d4e2..31168c59 100644 --- a/include/etl/frame_check_sequence.h +++ b/include/etl/frame_check_sequence.h @@ -56,7 +56,7 @@ namespace etl typedef TPolicy policy_type; typedef typename policy_type::value_type value_type; - ETL_STATIC_ASSERT(etlstd::is_unsigned::value, "Signed frame check type not supported"); + ETL_STATIC_ASSERT(etl::is_unsigned::value, "Signed frame check type not supported"); //************************************************************************* /// Default constructor. @@ -74,7 +74,7 @@ namespace etl template frame_check_sequence(TIterator begin, const TIterator end) { - ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Type not supported"); reset(); add(begin, end); @@ -96,7 +96,7 @@ namespace etl template void add(TIterator begin, const TIterator end) { - ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Type not supported"); while (begin != end) { diff --git a/include/etl/functional.h b/include/etl/functional.h index 46f1f5ac..a540f3a7 100644 --- a/include/etl/functional.h +++ b/include/etl/functional.h @@ -39,7 +39,7 @@ SOFTWARE. ///\defgroup reference_wrapper reference_wrapper ///\ingroup functional -namespace etlstd +namespace etl { //*************************************************************************** /// A definition of reference_wrapper for those that don't have C++ 0x11 support. @@ -110,6 +110,8 @@ namespace etlstd template struct less { + typedef T value_type; + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const { return lhs < rhs; @@ -120,6 +122,8 @@ namespace etlstd template struct greater { + typedef T value_type; + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const { return lhs > rhs; @@ -130,6 +134,8 @@ namespace etlstd template struct equal_to { + typedef T value_type; + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const { return lhs == rhs; @@ -140,6 +146,8 @@ namespace etlstd template struct not_equal_to { + typedef T value_type; + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const { return lhs != rhs; @@ -168,7 +176,7 @@ namespace etlstd //*************************************************************************** template - class binder1st : public etlstd::unary_function + class binder1st : public etl::unary_function { protected: @@ -202,7 +210,7 @@ namespace etlstd //*************************************************************************** template - class binder2nd : public etlstd::unary_function + class binder2nd : public etl::unary_function { protected: TFunction operation; diff --git a/include/etl/generate_type_traits.bat b/include/etl/generate_type_traits.bat index 39366a70..a1e5f97b 100644 --- a/include/etl/generate_type_traits.bat +++ b/include/etl/generate_type_traits.bat @@ -1 +1 @@ -python -m cogapp -d -e -otype_traits.h -DIsOneOf=17 type_traits_generator.h +python -m cogapp -d -e -otype_traits.h -DIsOneOf=16 type_traits_generator.h diff --git a/include/etl/indirect_vector.h b/include/etl/indirect_vector.h index 68e820bc..09511ddb 100644 --- a/include/etl/indirect_vector.h +++ b/include/etl/indirect_vector.h @@ -716,10 +716,10 @@ namespace etl template void assign(TIterator first, TIterator last) { - ETL_STATIC_ASSERT((etlstd::is_same::type, typename etlstd::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); + ETL_STATIC_ASSERT((etl::is_same::type, typename etl::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(static_cast(d) <= capacity(), ETL_ERROR(vector_full)); #endif @@ -785,7 +785,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(size() != capacity(), ETL_ERROR(vector_full)); #endif - T* p = storage.create(etlstd::move(value)); + T* p = storage.create(etl::move(value)); lookup.push_back(p); } #endif @@ -799,7 +799,7 @@ namespace etl template void emplace_back(Args && ... args) { - T* p = storage.create(etlstd::forward(args)...); + T* p = storage.create(etl::forward(args)...); lookup.push_back(p); } #else @@ -891,7 +891,7 @@ namespace etl { ETL_ASSERT(size() + 1 <= capacity(), ETL_ERROR(vector_full)); - T* p = storage.create(T(etlstd::move(value))); + T* p = storage.create(T(etl::move(value))); position = iterator(lookup.insert(position.lookup_itr, p)); return position; @@ -907,7 +907,7 @@ namespace etl { ETL_ASSERT(!full(), ETL_ERROR(vector_full)); - T* p = storage.create(T(etlstd::forward(args)...)); + T* p = storage.create(T(etl::forward(args)...)); position = iterator(lookup.insert(position.lookup_itr, p)); return position; @@ -990,7 +990,7 @@ namespace etl template void insert(iterator position, TIterator first, TIterator last) { - size_t count = size_t(etlstd::distance(first, last)); + size_t count = size_t(etl::distance(first, last)); ETL_ASSERT((size() + count) <= capacity(), ETL_ERROR(vector_full)); @@ -1066,7 +1066,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(etlstd::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -1171,7 +1171,7 @@ namespace etl while (itr != other.end()) { - push_back(etlstd::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -1212,7 +1212,7 @@ namespace etl template bool operator ==(const etl::iindirect_vector& lhs, const etl::iindirect_vector& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1238,7 +1238,7 @@ namespace etl template bool operator <(const etl::iindirect_vector& lhs, const etl::iindirect_vector& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** @@ -1375,7 +1375,7 @@ namespace etl indirect_vector(indirect_vector&& other) : etl::iindirect_vector(lookup_vector, storage_pool) { - this->move_container(etlstd::move(other)); + this->move_container(etl::move(other)); } //************************************************************************* @@ -1383,7 +1383,7 @@ namespace etl //************************************************************************* indirect_vector& operator = (indirect_vector&& rhs) { - this->move_container(etlstd::move(rhs)); + this->move_container(etl::move(rhs)); return *this; } @@ -1503,7 +1503,7 @@ namespace etl : etl::iindirect_vector(lookup_, pool_) { ETL_ASSERT(lookup_.capacity() <= pool_.capacity(), ETL_ERROR(indirect_vector_buffer_missmatch)); - this->move_container(etlstd::move(other)); + this->move_container(etl::move(other)); } //************************************************************************* @@ -1511,7 +1511,7 @@ namespace etl //************************************************************************* indirect_vector& operator = (indirect_vector&& rhs) { - this->move_container(etlstd::move(rhs)); + this->move_container(etl::move(rhs)); return *this; } diff --git a/include/etl/integral_limits.h b/include/etl/integral_limits.h index 4d06c57b..3a33bbde 100644 --- a/include/etl/integral_limits.h +++ b/include/etl/integral_limits.h @@ -31,7 +31,6 @@ SOFTWARE. #ifndef ETL_INTEGRAL_LIMITS_INCLUDED #define ETL_INTEGRAL_LIMITS_INCLUDED -#include #include #include "platform.h" @@ -74,7 +73,7 @@ namespace etl static const signed char min = SCHAR_MIN; static const signed char max = SCHAR_MAX; static const int bits = CHAR_BIT; - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -86,7 +85,7 @@ namespace etl static const unsigned char min = 0; static const unsigned char max = UCHAR_MAX; static const int bits = CHAR_BIT; - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -95,10 +94,10 @@ namespace etl template <> struct integral_limits { - static const char min = (etlstd::is_signed::value) ? SCHAR_MIN : 0; - static const char max = (etlstd::is_signed::value) ? SCHAR_MAX : char(UCHAR_MAX); + static const char min = (etl::is_signed::value) ? SCHAR_MIN : 0; + static const char max = (etl::is_signed::value) ? SCHAR_MAX : char(UCHAR_MAX); static const int bits = CHAR_BIT; - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -110,7 +109,7 @@ namespace etl static const short min = SHRT_MIN; static const short max = SHRT_MAX; static const int bits = CHAR_BIT * (sizeof(short) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -122,7 +121,7 @@ namespace etl static const unsigned short min = 0; static const unsigned short max = USHRT_MAX; static const int bits = CHAR_BIT * (sizeof(unsigned short) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -134,7 +133,7 @@ namespace etl static const int min = INT_MIN; static const int max = INT_MAX; static const int bits = CHAR_BIT * (sizeof(int) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -146,7 +145,7 @@ namespace etl static const unsigned int min = 0; static const unsigned int max = UINT_MAX; static const int bits = CHAR_BIT * (sizeof(unsigned int) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -158,7 +157,7 @@ namespace etl static const long min = LONG_MIN; static const long max = LONG_MAX; static const int bits = CHAR_BIT * (sizeof(long) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -170,7 +169,7 @@ namespace etl static const unsigned long min = 0; static const unsigned long max = ULONG_MAX; static const int bits = CHAR_BIT * (sizeof(unsigned long) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; #ifndef LLONG_MAX @@ -194,7 +193,7 @@ namespace etl static const long long min = LLONG_MIN; static const long long max = LLONG_MAX; static const int bits = CHAR_BIT * (sizeof(long long) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; //*************************************************************************** @@ -206,7 +205,7 @@ namespace etl static const unsigned long long min = 0; static const unsigned long long max = ULLONG_MAX; static const int bits = CHAR_BIT * (sizeof(unsigned long long) / sizeof(char)); - static const bool is_signed = etlstd::is_signed::value; + static const bool is_signed = etl::is_signed::value; }; } diff --git a/include/etl/intrusive_forward_list.h b/include/etl/intrusive_forward_list.h index 253abba2..48ed3972 100644 --- a/include/etl/intrusive_forward_list.h +++ b/include/etl/intrusive_forward_list.h @@ -153,7 +153,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - intmax_t d = etlstd::distance(first, last); + intmax_t d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(intrusive_forward_list_iterator_exception)); #endif @@ -495,7 +495,7 @@ namespace etl const value_type* p_value; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //************************************************************************* /// Constructor. @@ -651,7 +651,7 @@ namespace etl { if (first != end() && (first != last)) { - this->current_size -= etlstd::distance(first, last) - 1; + this->current_size -= etl::distance(first, last) - 1; link_type* p_first = first.p_value; link_type* p_last = last.p_value; @@ -712,7 +712,7 @@ namespace etl //************************************************************************* void sort() { - sort(etlstd::less()); + sort(etl::less()); } //************************************************************************* @@ -958,7 +958,7 @@ namespace etl { if (&other != this) { - size_t n = etlstd::distance(begin_, end_) - 1; + size_t n = etl::distance(begin_, end_) - 1; this->current_size += n; other.current_size -= n; } @@ -987,7 +987,7 @@ namespace etl //************************************************************************* void merge(list_type& other) { - merge(other, etlstd::less()); + merge(other, etl::less()); } //************************************************************************* diff --git a/include/etl/intrusive_links.h b/include/etl/intrusive_links.h index 1a652f56..c8149514 100644 --- a/include/etl/intrusive_links.h +++ b/include/etl/intrusive_links.h @@ -110,7 +110,7 @@ namespace etl // Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink& lhs, TLink& rhs) { lhs.etl_next = &rhs; @@ -118,7 +118,7 @@ namespace etl // Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink& lhs, TLink& rhs) { rhs.etl_next = lhs.etl_next; @@ -127,7 +127,7 @@ namespace etl // Pointer, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink* lhs, TLink* rhs) { if (lhs != nullptr) @@ -138,7 +138,7 @@ namespace etl // Pointer, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink* lhs, TLink* rhs) { if (lhs != nullptr) @@ -154,7 +154,7 @@ namespace etl // Reference, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink& lhs, TLink* rhs) { lhs.etl_next = rhs; @@ -162,7 +162,7 @@ namespace etl // Reference, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink& lhs, TLink* rhs) { if (rhs != nullptr) @@ -175,7 +175,7 @@ namespace etl // Pointer, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink* lhs, TLink& rhs) { if (lhs != nullptr) @@ -186,7 +186,7 @@ namespace etl // Pointer, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink* lhs, TLink& rhs) { if (lhs != nullptr) @@ -198,7 +198,7 @@ namespace etl // Reference, Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink& lhs, TLink& first, TLink& last) { last.etl_next = lhs.etl_next; @@ -207,7 +207,7 @@ namespace etl // Pointer, Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink* lhs, TLink& first, TLink& last) { if (lhs != nullptr) @@ -223,7 +223,7 @@ namespace etl // Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type unlink_after(TLink& node) { if (node.etl_next != nullptr) @@ -235,7 +235,7 @@ namespace etl // Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type unlink_after(TLink& before, TLink& last) { before.etl_next = last.etl_next; @@ -265,11 +265,7 @@ namespace etl void reverse() { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL swap(etl_previous, etl_next); } @@ -295,7 +291,7 @@ namespace etl // Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink& lhs, TLink& rhs) { lhs.etl_next = &rhs; @@ -304,7 +300,7 @@ namespace etl // Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink& lhs, TLink& rhs) { rhs.etl_next = lhs.etl_next; @@ -320,7 +316,7 @@ namespace etl // Pointer, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink* lhs, TLink* rhs) { if (lhs != nullptr) @@ -336,7 +332,7 @@ namespace etl // Pointer, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink* lhs, TLink* rhs) { if (rhs != nullptr) @@ -362,7 +358,7 @@ namespace etl // Reference, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink& lhs, TLink* rhs) { lhs.etl_next = rhs; @@ -375,7 +371,7 @@ namespace etl // Reference, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink& lhs, TLink* rhs) { if (rhs != nullptr) @@ -394,7 +390,7 @@ namespace etl // Pointer, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link(TLink* lhs, TLink& rhs) { if (lhs != nullptr) @@ -407,7 +403,7 @@ namespace etl // Pointer, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink* lhs, TLink& rhs) { if (lhs != nullptr) @@ -430,7 +426,7 @@ namespace etl // Reference, Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink& lhs, TLink& first, TLink& last) { last.etl_next = lhs.etl_next; @@ -446,7 +442,7 @@ namespace etl // Pointer, Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_splice(TLink* lhs, TLink& first, TLink& last) { if (lhs != nullptr) @@ -473,7 +469,7 @@ namespace etl // Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type unlink(TLink& node) { node.unlink(); @@ -481,7 +477,7 @@ namespace etl // Reference Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type unlink(TLink& first, TLink& last) { if (&first == &last) @@ -532,7 +528,7 @@ namespace etl // Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_left(TLink& parent, TLink& leaf) { parent.etl_left = &leaf; @@ -540,7 +536,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_right(TLink& parent, TLink& leaf) { parent.etl_right = &leaf; @@ -549,7 +545,7 @@ namespace etl // Pointer, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_left(TLink* parent, TLink* leaf) { if (parent != nullptr) @@ -564,7 +560,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_right(TLink* parent, TLink* leaf) { if (parent != nullptr) @@ -580,7 +576,7 @@ namespace etl // Reference, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_left(TLink& parent, TLink* leaf) { parent.etl_left = leaf; @@ -592,7 +588,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_right(TLink& parent, TLink* leaf) { parent.etl_right = leaf; @@ -605,7 +601,7 @@ namespace etl // Pointer, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_left(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -617,7 +613,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_right(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -630,7 +626,7 @@ namespace etl // Reference, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_left(TLink& parent, TLink& leaf) { parent.etl_right = leaf.etl_left; @@ -646,7 +642,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_right(TLink& parent, TLink& leaf) { parent.etl_left = leaf.etl_right; @@ -663,7 +659,7 @@ namespace etl // Pointer, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_left(TLink* parent, TLink* leaf) { if ((parent != nullptr) && (leaf != nullptr)) @@ -673,7 +669,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_right(TLink* parent, TLink* leaf) { if ((parent != nullptr) && (leaf != nullptr)) @@ -684,7 +680,7 @@ namespace etl // Reference, Pointer template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_left(TLink& parent, TLink* leaf) { if (leaf != nullptr) @@ -694,7 +690,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_right(TLink& parent, TLink* leaf) { if (leaf != nullptr) @@ -705,7 +701,7 @@ namespace etl // Pointer, Reference template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_left(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -715,7 +711,7 @@ namespace etl } template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate_right(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -727,7 +723,7 @@ namespace etl // Reference, Reference /// Automatically detects whether a left or right rotate is expected. template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate(TLink& parent, TLink& leaf) { if (parent.etl_left == &leaf) @@ -743,7 +739,7 @@ namespace etl // Pointer, Pointer /// Automatically detects whether a left or right rotate is expected. template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate(TLink* parent, TLink* leaf) { if ((parent != nullptr) && (leaf != nullptr)) @@ -762,7 +758,7 @@ namespace etl // Reference, Pointer /// Automatically detects whether a left or right rotate is expected. template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate(TLink& parent, TLink* leaf) { if (leaf != nullptr) @@ -781,7 +777,7 @@ namespace etl // Pointer, Reference /// Automatically detects whether a left or right rotate is expected. template - typename etlstd::enable_if >::value, void>::type + typename etl::enable_if >::value, void>::type link_rotate(TLink* parent, TLink& leaf) { if (parent != nullptr) diff --git a/include/etl/intrusive_list.h b/include/etl/intrusive_list.h index ddc691ce..f618ef9b 100644 --- a/include/etl/intrusive_list.h +++ b/include/etl/intrusive_list.h @@ -133,7 +133,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - intmax_t d = etlstd::distance(first, last); + intmax_t d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(intrusive_list_iterator_exception)); #endif @@ -580,7 +580,7 @@ namespace etl const value_type* p_value; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //************************************************************************* /// Constructor. @@ -734,7 +734,7 @@ namespace etl // Join the ends. etl::link(p_first->etl_previous, p_last); - this->current_size -= etlstd::distance(first, last); + this->current_size -= etl::distance(first, last); if (p_last == &this->terminal_link) { @@ -781,7 +781,7 @@ namespace etl //************************************************************************* void sort() { - sort(etlstd::less()); + sort(etl::less()); } //************************************************************************* @@ -1013,7 +1013,7 @@ namespace etl { if (&other != this) { - size_t n = etlstd::distance(begin_, end_); + size_t n = etl::distance(begin_, end_); this->current_size += n; other.current_size -= n; } @@ -1036,7 +1036,7 @@ namespace etl //************************************************************************* void merge(list_type& other) { - merge(other, etlstd::less()); + merge(other, etl::less()); } //************************************************************************* diff --git a/include/etl/iterator.h b/include/etl/iterator.h index 4f7665c2..5ca901c6 100644 --- a/include/etl/iterator.h +++ b/include/etl/iterator.h @@ -41,7 +41,7 @@ SOFTWARE. ///\defgroup iterator iterator ///\ingroup utilities -namespace etlstd +namespace etl { //*************************************************************************** // iterator tags @@ -133,7 +133,7 @@ namespace etlstd template ETL_CONSTEXPR17 void advance(TIterator& itr, TDistance n) { - typedef typename etlstd::iterator_traits::iterator_category tag; + typedef typename etl::iterator_traits::iterator_category tag; advance_helper(itr, n, tag()); } @@ -152,9 +152,9 @@ namespace etlstd // distance #if defined(ETL_NO_STL) template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::input_iterator_tag) + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::input_iterator_tag) { - typename etlstd::iterator_traits::difference_type d = 0; + typename etl::iterator_traits::difference_type d = 0; while (first != last) { @@ -166,9 +166,9 @@ namespace etlstd } template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::forward_iterator_tag) + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::forward_iterator_tag) { - typename etlstd::iterator_traits::difference_type d = 0; + typename etl::iterator_traits::difference_type d = 0; while (first != last) { @@ -180,9 +180,9 @@ namespace etlstd } template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::bidirectional_iterator_tag) + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::bidirectional_iterator_tag) { - typename etlstd::iterator_traits::difference_type d = 0; + typename etl::iterator_traits::difference_type d = 0; while (first != last) { @@ -194,15 +194,15 @@ namespace etlstd } template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::random_access_iterator_tag) + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::random_access_iterator_tag) { return last - first; } template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance(TIterator first, TIterator last) + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance(TIterator first, TIterator last) { - typedef typename etlstd::iterator_traits::iterator_category tag; + typedef typename etl::iterator_traits::iterator_category tag; return distance_helper(first, last, tag()); } @@ -220,10 +220,10 @@ namespace etlstd //*************************************************************************** // Previous template - ETL_CONSTEXPR17 TIterator prev(TIterator itr, typename etlstd::iterator_traits::difference_type n = 1) + ETL_CONSTEXPR17 TIterator prev(TIterator itr, typename etl::iterator_traits::difference_type n = 1) { #if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED - etlstd::advance(itr, -n); + etl::advance(itr, -n); #else std::advance(itr, -n); #endif @@ -233,10 +233,10 @@ namespace etlstd //*************************************************************************** // Next template - ETL_CONSTEXPR17 TIterator next(TIterator itr, typename etlstd::iterator_traits::difference_type n = 1) + ETL_CONSTEXPR17 TIterator next(TIterator itr, typename etl::iterator_traits::difference_type n = 1) { #if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED - etlstd::advance(itr, n); + etl::advance(itr, n); #else std::advance(itr, n); #endif @@ -436,31 +436,31 @@ namespace etl template struct is_input_iterator { - static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::input_iterator_tag>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_same::iterator_category, ETL_OR_STD::input_iterator_tag>::value; }; template struct is_output_iterator { - static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::output_iterator_tag>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_same::iterator_category, ETL_OR_STD::output_iterator_tag>::value; }; template struct is_forward_iterator { - static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::forward_iterator_tag>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_same::iterator_category, ETL_OR_STD::forward_iterator_tag>::value; }; template struct is_bidirectional_iterator { - static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_same::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value; }; template struct is_random_iterator { - static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_same::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value; }; template diff --git a/include/etl/largest.h b/include/etl/largest.h index 0ebdc414..5880d907 100644 --- a/include/etl/largest.h +++ b/include/etl/largest.h @@ -82,7 +82,7 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - using type = typename etlstd::conditional<(etl::size_of::value > etl::size_of::value), // Boolean + using type = typename etl::conditional<(etl::size_of::value > etl::size_of::value), // Boolean T1, // TrueType largest_other> // FalseType ::type; // The largest type of the two. @@ -128,7 +128,7 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - typedef typename etlstd::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean + typedef typename etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean T1, // TrueType largest_other> // FalseType ::type type; // The largest type of the two. @@ -170,7 +170,7 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - using type = typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::alignment_of::value), // Boolean + using type = typename etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean T1, // TrueType largest_other> // FalseType ::type; // The largest type of the two. @@ -178,7 +178,7 @@ namespace etl // The largest alignment. enum { - value = etlstd::alignment_of::value + value = etl::alignment_of::value }; }; @@ -192,7 +192,7 @@ namespace etl enum { - value = etlstd::alignment_of::value + value = etl::alignment_of::value }; }; #else @@ -213,7 +213,7 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - typedef typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::alignment_of::value), // Boolean + typedef typename etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean T1, // TrueType largest_other> // FalseType ::type type; // The largest type of the two. @@ -221,7 +221,7 @@ namespace etl // The largest alignment. enum { - value = etlstd::alignment_of::value + value = etl::alignment_of::value }; }; @@ -236,7 +236,7 @@ namespace etl enum { - value = etlstd::alignment_of::value + value = etl::alignment_of::value }; }; #endif @@ -249,7 +249,7 @@ namespace etl template struct larger_int_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_int_for_bits::type>::bits + 1>::type type; }; @@ -262,7 +262,7 @@ namespace etl template struct larger_uint_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_uint_for_bits::type>::bits + 1>::type type; }; @@ -273,13 +273,13 @@ namespace etl /// The returned type will be of the same sign. ///\ingroup largest //*************************************************************************** - template ::value> + template ::value> struct larger_type; template struct larger_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_uint_for_bits::bits + 1>::type type; }; @@ -287,7 +287,7 @@ namespace etl template struct larger_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_int_for_bits::bits + 1>::type type; }; diff --git a/include/etl/largest_generator.h b/include/etl/largest_generator.h index bfe55b50..dfd05dd7 100644 --- a/include/etl/largest_generator.h +++ b/include/etl/largest_generator.h @@ -94,7 +94,7 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - using type = typename etlstd::conditional<(etl::size_of::value > etl::size_of::value), // Boolean + using type = typename etl::conditional<(etl::size_of::value > etl::size_of::value), // Boolean T1, // TrueType largest_other> // FalseType ::type; // The largest type of the two. @@ -151,7 +151,7 @@ namespace etl cog.outl("") cog.outl(" // Set 'type' to be the largest of the first parameter and any of the others.") cog.outl(" // This is recursive.") - cog.outl(" typedef typename etlstd::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean") + cog.outl(" typedef typename etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean") cog.outl(" T1, // TrueType") cog.outl(" largest_other> // FalseType") cog.outl(" ::type type; // The largest type of the two.") @@ -200,7 +200,7 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - using type = typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::alignment_of::value), // Boolean + using type = typename etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean T1, // TrueType largest_other> // FalseType ::type; // The largest type of the two. @@ -208,7 +208,7 @@ namespace etl // The largest alignment. enum { - value = etlstd::alignment_of::value + value = etl::alignment_of::value }; }; @@ -222,7 +222,7 @@ namespace etl enum { - value = etlstd::alignment_of::value + value = etl::alignment_of::value }; }; #else @@ -254,7 +254,7 @@ namespace etl cog.outl("") cog.outl(" // Set 'type' to be the largest of the first parameter and any of the others.") cog.outl(" // This is recursive.") - cog.outl(" typedef typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::alignment_of::value), // Boolean") + cog.outl(" typedef typename etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean") cog.outl(" T1, // TrueType") cog.outl(" largest_other> // FalseType") cog.outl(" ::type type; // The largest type of the two.") @@ -262,7 +262,7 @@ namespace etl cog.outl(" // The largest alignment.") cog.outl(" enum") cog.outl(" {") - cog.outl(" value = etlstd::alignment_of::value") + cog.outl(" value = etl::alignment_of::value") cog.outl(" };") cog.outl("};") cog.outl("") @@ -282,7 +282,7 @@ namespace etl cog.outl("") cog.outl(" enum") cog.outl(" {") - cog.outl(" value = etlstd::alignment_of::value") + cog.outl(" value = etl::alignment_of::value") cog.outl(" };") cog.outl("};") ]]]*/ @@ -297,7 +297,7 @@ namespace etl template struct larger_int_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_int_for_bits::type>::bits + 1>::type type; }; @@ -310,7 +310,7 @@ namespace etl template struct larger_uint_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_uint_for_bits::type>::bits + 1>::type type; }; @@ -321,13 +321,13 @@ namespace etl /// The returned type will be of the same sign. ///\ingroup largest //*************************************************************************** - template ::value> + template ::value> struct larger_type; template struct larger_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_uint_for_bits::bits + 1>::type type; }; @@ -335,7 +335,7 @@ namespace etl template struct larger_type { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_int_for_bits::bits + 1>::type type; }; diff --git a/include/etl/limits.h b/include/etl/limits.h index 5ee6c417..a934e292 100644 --- a/include/etl/limits.h +++ b/include/etl/limits.h @@ -43,10 +43,8 @@ SOFTWARE. #if defined(ETL_NO_STL) #define ETL_LOG2(x) (((x) * 301) / 1000) -namespace etlstd +namespace etl { - template class numeric_limits; - enum float_round_style { round_indeterminate = -1, @@ -63,87 +61,6 @@ namespace etlstd denorm_present = 1 }; - //*************************************************************************** - // Base for integral types. - template - class etl_integral_type - { - public: - static ETL_CONST_OR_CONSTEXPR bool is_specialized = true; - - static ETL_CONST_OR_CONSTEXPR int max_digits10 = 0; - - static ETL_CONST_OR_CONSTEXPR bool is_integer = true; - static ETL_CONST_OR_CONSTEXPR bool is_exact = true; - - static ETL_CONST_OR_CONSTEXPR int radix = 2; - static ETL_CONSTEXPR T epsilon() { return 0; } - static ETL_CONSTEXPR T round_error() { return 0; } - - static ETL_CONST_OR_CONSTEXPR int digits = (CHAR_BIT * sizeof(T)) - (etlstd::is_signed::value ? 1 : 0); - static ETL_CONST_OR_CONSTEXPR int digits10 = ETL_LOG2(digits); - - static ETL_CONST_OR_CONSTEXPR bool is_signed = etlstd::is_signed::value; - - static ETL_CONST_OR_CONSTEXPR int min_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = 0; - - static ETL_CONST_OR_CONSTEXPR bool has_infinity = false; - static ETL_CONST_OR_CONSTEXPR bool has_quiet_NaN = false; - static ETL_CONST_OR_CONSTEXPR bool has_signaling_NaN = false; - static ETL_CONST_OR_CONSTEXPR float_denorm_style has_denorm = denorm_absent; - static ETL_CONST_OR_CONSTEXPR bool has_denorm_loss = false; - - static ETL_CONSTEXPR T infinity() { return 0; } - static ETL_CONSTEXPR T quiet_NaN() { return 0; } - static ETL_CONSTEXPR T signaling_NaN() { return 0; } - static ETL_CONSTEXPR T denorm_min() { return 0; } - - static ETL_CONST_OR_CONSTEXPR bool is_iec559 = false; - static ETL_CONST_OR_CONSTEXPR bool is_bounded = true; - static ETL_CONST_OR_CONSTEXPR bool is_modulo = etlstd::is_unsigned::value; - - static ETL_CONST_OR_CONSTEXPR bool traps = false; - static ETL_CONST_OR_CONSTEXPR bool tinyness_before = false; - static ETL_CONST_OR_CONSTEXPR float_round_style round_style = round_toward_zero; - }; - - //*************************************************************************** - // Base for floating point types. - template - class etl_floating_point_type - { - public: - static ETL_CONST_OR_CONSTEXPR bool is_specialized = true; - - static ETL_CONST_OR_CONSTEXPR bool is_signed = true; - static ETL_CONST_OR_CONSTEXPR bool is_integer = false; - static ETL_CONST_OR_CONSTEXPR bool is_exact = false; - - static ETL_CONST_OR_CONSTEXPR int radix = 2; - - static ETL_CONST_OR_CONSTEXPR bool has_infinity = false; - static ETL_CONST_OR_CONSTEXPR bool has_quiet_NaN = false; - static ETL_CONST_OR_CONSTEXPR bool has_signaling_NaN = false; - static ETL_CONST_OR_CONSTEXPR float_denorm_style has_denorm = denorm_present; - static ETL_CONST_OR_CONSTEXPR bool has_denorm_loss = true; - - static ETL_CONST_OR_CONSTEXPR bool is_iec559 = true; - static ETL_CONST_OR_CONSTEXPR bool is_bounded = true; - static ETL_CONST_OR_CONSTEXPR bool is_modulo = false; - - static ETL_CONSTEXPR T round_error() { return T(0.5); } - static ETL_CONSTEXPR T infinity() { return 0; } - static ETL_CONSTEXPR T quiet_NaN() { return 0; } - static ETL_CONSTEXPR T signaling_NaN() { return 0; } - - static ETL_CONST_OR_CONSTEXPR bool traps = false; - static ETL_CONST_OR_CONSTEXPR bool tinyness_before = true; - static ETL_CONST_OR_CONSTEXPR float_round_style round_style = round_to_nearest; - }; - //*************************************************************************** // Default template @@ -165,296 +82,1355 @@ namespace etlstd { public: - static ETL_CONST_OR_CONSTEXPR bool is_specialized = true; + static const bool is_specialized = true; - static ETL_CONSTEXPR bool min() { return false; } - static ETL_CONSTEXPR bool max() { return true; } - static ETL_CONSTEXPR bool lowest() { return false; } + static const int digits = 1; + static const int digits10 = 0; + static const int max_digits10 = 0; - static ETL_CONST_OR_CONSTEXPR int digits = 1; - static ETL_CONST_OR_CONSTEXPR int digits10 = 0; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = 0; + static const bool is_signed = false; + static const bool is_integer = true; + static const bool is_exact = true; - static ETL_CONST_OR_CONSTEXPR bool is_signed = false; - static ETL_CONST_OR_CONSTEXPR bool is_integer = true; - static ETL_CONST_OR_CONSTEXPR bool is_exact = true; + static const int radix = 2; + static const bool epsilon() { return false; } + static const bool round_error() { return false; } - static ETL_CONST_OR_CONSTEXPR int radix = 2; - static ETL_CONST_OR_CONSTEXPR bool epsilon() { return false; } - static ETL_CONST_OR_CONSTEXPR bool round_error() { return false; } + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; - static ETL_CONST_OR_CONSTEXPR int min_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = 0; + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; - static ETL_CONST_OR_CONSTEXPR bool has_infinity = false; - static ETL_CONST_OR_CONSTEXPR bool has_quiet_NaN = false; - static ETL_CONST_OR_CONSTEXPR bool has_signaling_NaN = false; - static ETL_CONST_OR_CONSTEXPR float_denorm_style has_denorm = denorm_absent; - static ETL_CONST_OR_CONSTEXPR bool has_denorm_loss = false; + static const bool infinity() { return false; } + static const bool quiet_NaN() { return false; } + static const bool signaling_NaN() { return false; } + static const bool denorm_min() { return false; } - static ETL_CONSTEXPR bool infinity() { return false; } - static ETL_CONSTEXPR bool quiet_NaN() { return false; } - static ETL_CONSTEXPR bool signaling_NaN() { return false; } - static ETL_CONSTEXPR bool denorm_min() { return false; } + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = false; - static ETL_CONST_OR_CONSTEXPR bool is_iec559 = false; - static ETL_CONST_OR_CONSTEXPR bool is_bounded = true; - static ETL_CONST_OR_CONSTEXPR bool is_modulo = false; + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; - static ETL_CONST_OR_CONSTEXPR bool traps = false; - static ETL_CONST_OR_CONSTEXPR bool tinyness_before = false; - static ETL_CONST_OR_CONSTEXPR float_round_style round_style = round_toward_zero; + static const bool min() { return false; } + static const bool max() { return true; } + static const bool lowest() { return false; } }; //*************************************************************************** // char template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR char min() { return char(CHAR_MIN); } - static ETL_CONSTEXPR char max() { return char(CHAR_MAX); } - static ETL_CONSTEXPR char lowest() { return char(CHAR_MIN); } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(char)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const char infinity() { return 0; } + static const char quiet_NaN() { return 0; } + static const char signaling_NaN() { return 0; } + static const char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const char min() { return char(CHAR_MIN); } + static const char max() { return char(CHAR_MAX); } + static const char lowest() { return char(CHAR_MIN); } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // unsigned char template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR unsigned char min() { return 0; } - static ETL_CONSTEXPR unsigned char max() { return UCHAR_MAX; } - static ETL_CONSTEXPR unsigned char lowest() { return 0; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(unsigned char)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const unsigned char min() { return 0; } + static const unsigned char max() { return UCHAR_MAX; } + static const unsigned char lowest() { return 0; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // signed char template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR signed char min() { return SCHAR_MIN; } - static ETL_CONSTEXPR signed char max() { return SCHAR_MAX; } - static ETL_CONSTEXPR signed char lowest() { return SCHAR_MIN; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(char)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const char infinity() { return 0; } + static const char quiet_NaN() { return 0; } + static const char signaling_NaN() { return 0; } + static const char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const signed char min() { return SCHAR_MIN; } + static const signed char max() { return SCHAR_MAX; } + static const signed char lowest() { return SCHAR_MIN; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + #if (ETL_NO_LARGE_CHAR_SUPPORT == false) //*************************************************************************** // char16_t template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR char16_t min() { return 0; } - static ETL_CONSTEXPR char16_t max() { return UINT_LEAST16_MAX; } - static ETL_CONSTEXPR char16_t lowest() { return 0; } - static ETL_CONST_OR_CONSTEXPR bool is_modulo = true; + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(char16_t)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = true; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const char16_t min() { return 0; } + static const char16_t max() { return UINT_LEAST16_MAX; } + static const char16_t lowest() { return 0; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // char32_t template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR char32_t min() { return 0; } - static ETL_CONSTEXPR char32_t max() { return UINT_LEAST32_MAX; } - static ETL_CONSTEXPR char32_t lowest() { return 0; } - static ETL_CONST_OR_CONSTEXPR bool is_modulo = true; + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(char32_t)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = true; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const char32_t min() { return 0; } + static const char32_t max() { return UINT_LEAST32_MAX; } + static const char32_t lowest() { return 0; } }; + + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + #endif //*************************************************************************** // wchar_t template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR wchar_t min() { return WCHAR_MIN; } - static ETL_CONSTEXPR wchar_t max() { return WCHAR_MAX; } - static ETL_CONSTEXPR wchar_t lowest() { return WCHAR_MIN; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(wchar_t)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const wchar_t min() { return WCHAR_MIN; } + static const wchar_t max() { return WCHAR_MAX; } + static const wchar_t lowest() { return WCHAR_MIN; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // short template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR short min() { return SHRT_MIN; } - static ETL_CONSTEXPR short max() { return SHRT_MAX; } - static ETL_CONSTEXPR short lowest() { return SHRT_MIN; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(short)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const short min() { return SHRT_MIN; } + static const short max() { return SHRT_MAX; } + static const short lowest() { return SHRT_MIN; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // unsigned short template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR unsigned short min() { return 0; } - static ETL_CONSTEXPR unsigned short max() { return USHRT_MAX; } - static ETL_CONSTEXPR unsigned short lowest() { return 0; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(unsigned short)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const unsigned short min() { return 0; } + static const unsigned short max() { return USHRT_MAX; } + static const unsigned short lowest() { return 0; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // int template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR int min() { return INT_MIN; } - static ETL_CONSTEXPR int max() { return INT_MAX; } - static ETL_CONSTEXPR int lowest() { return INT_MIN; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(int)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const int min() { return INT_MIN; } + static const int max() { return INT_MAX; } + static const int lowest() { return INT_MIN; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // unsigned int template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR unsigned int min() { return 0; } - static ETL_CONSTEXPR unsigned int max() { return UINT_MAX; } - static ETL_CONSTEXPR unsigned int lowest() { return 0; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(unsigned int)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const unsigned int min() { return 0; } + static const unsigned int max() { return UINT_MAX; } + static const unsigned int lowest() { return 0; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // long template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR long min() { return LONG_MIN; } - static ETL_CONSTEXPR long max() { return LONG_MAX; } - static ETL_CONSTEXPR long lowest() { return LONG_MIN; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const long min() { return LONG_MIN; } + static const long max() { return LONG_MAX; } + static const long lowest() { return LONG_MIN; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // unsigned long template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR unsigned long min() { return 0; } - static ETL_CONSTEXPR unsigned long max() { return ULONG_MAX; } - static ETL_CONSTEXPR unsigned long lowest() { return 0; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(unsigned long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const unsigned long min() { return 0; } + static const unsigned long max() { return ULONG_MAX; } + static const unsigned long lowest() { return 0; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // long long template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR long long min() { return LLONG_MIN; } - static ETL_CONSTEXPR long long max() { return LLONG_MAX; } - static ETL_CONSTEXPR long long lowest() { return LLONG_MIN; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(long long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const long long min() { return LLONG_MIN; } + static const long long max() { return LLONG_MAX; } + static const long long lowest() { return LLONG_MIN; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // unsigned long long template<> - class numeric_limits : public etl_integral_type + class numeric_limits { public: - static ETL_CONSTEXPR unsigned long long min() { return 0; } - static ETL_CONSTEXPR unsigned long long max() { return ULLONG_MAX; } - static ETL_CONSTEXPR unsigned long long lowest() { return 0; } + static const bool is_specialized = true; + + static const bool is_integer = true; + static const bool is_exact = true; + + static const int radix = 2; + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + + static const int digits = (CHAR_BIT * sizeof(unsigned long long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG2(digits); + static const int max_digits10 = 0; + + static const bool is_signed = etl::is_signed::value; + + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_absent; + static const bool has_denorm_loss = false; + + static const unsigned char infinity() { return 0; } + static const unsigned char quiet_NaN() { return 0; } + static const unsigned char signaling_NaN() { return 0; } + static const unsigned char denorm_min() { return 0; } + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = etl::is_unsigned::value; + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_toward_zero; + + static const unsigned long long min() { return 0; } + static const unsigned long long max() { return ULLONG_MAX; } + static const unsigned long long lowest() { return 0; } }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + #endif + //*************************************************************************** // float template<> - class numeric_limits : public etl_floating_point_type + class numeric_limits { public: - static ETL_CONSTEXPR float min() { return FLT_MIN; } - static ETL_CONSTEXPR float max() { return FLT_MAX; } - static ETL_CONSTEXPR float lowest() { return -FLT_MAX; } - static ETL_CONSTEXPR float epsilon() { return FLT_EPSILON; } - static ETL_CONSTEXPR float denorm_min() { return FLT_MIN; } + static const bool is_specialized = true; - static ETL_CONST_OR_CONSTEXPR int digits = FLT_MANT_DIG; - static ETL_CONST_OR_CONSTEXPR int digits10 = FLT_DIG; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = ETL_LOG2(FLT_MANT_DIG) + 2; + static const bool is_signed = true; + static const bool is_integer = false; + static const bool is_exact = false; - static ETL_CONST_OR_CONSTEXPR int min_exponent = FLT_MIN_EXP; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = FLT_MIN_10_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent = FLT_MAX_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = FLT_MAX_10_EXP; + static const int radix = 2; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_indeterminate; + static const bool has_denorm_loss = false; + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = false; + + static const float round_error() { return float(0.5); } + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_indeterminate; + + static const float min() { return FLT_MIN; } + static const float max() { return FLT_MAX; } + static const float lowest() { return -FLT_MAX; } + static const float epsilon() { return FLT_EPSILON; } + static const float denorm_min() { return FLT_MIN; } + + static const int digits = FLT_MANT_DIG; + static const int digits10 = FLT_DIG; + static const int max_digits10 = ETL_LOG2(FLT_MANT_DIG) + 2; + + static const int min_exponent = FLT_MIN_EXP; + static const int min_exponent10 = FLT_MIN_10_EXP; + static const int max_exponent = FLT_MAX_EXP; + static const int max_exponent10 = FLT_MAX_10_EXP; }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + #endif + //*************************************************************************** // double template<> - class numeric_limits : public etl_floating_point_type + class numeric_limits { public: - static ETL_CONSTEXPR double min() { return DBL_MIN; } - static ETL_CONSTEXPR double max() { return DBL_MAX; } - static ETL_CONSTEXPR double lowest() { return -DBL_MAX; } - static ETL_CONSTEXPR double epsilon() { return DBL_EPSILON; } - static ETL_CONSTEXPR double denorm_min() { return DBL_MIN; } + static const bool is_specialized = true; - static ETL_CONST_OR_CONSTEXPR int digits = DBL_MANT_DIG; - static ETL_CONST_OR_CONSTEXPR int digits10 = DBL_DIG; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = ETL_LOG2(DBL_MANT_DIG) + 2; + static const bool is_signed = true; + static const bool is_integer = false; + static const bool is_exact = false; - static ETL_CONST_OR_CONSTEXPR int min_exponent = DBL_MIN_EXP; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = DBL_MIN_10_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent = DBL_MAX_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = DBL_MAX_10_EXP; + static const int radix = 2; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_indeterminate; + static const bool has_denorm_loss = false; + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = false; + + static const float round_error() { return double(0.5); } + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_indeterminate; + + static const double min() { return DBL_MIN; } + static const double max() { return DBL_MAX; } + static const double lowest() { return -DBL_MAX; } + static const double epsilon() { return DBL_EPSILON; } + static const double denorm_min() { return DBL_MIN; } + + static const int digits = DBL_MANT_DIG; + static const int digits10 = DBL_DIG; + static const int max_digits10 = ETL_LOG2(DBL_MANT_DIG) + 2; + + static const int min_exponent = DBL_MIN_EXP; + static const int min_exponent10 = DBL_MIN_10_EXP; + static const int max_exponent = DBL_MAX_EXP; + static const int max_exponent10 = DBL_MAX_10_EXP; }; + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + #endif + //*************************************************************************** // long double template<> - class numeric_limits : public etl_floating_point_type + class numeric_limits { public: - static ETL_CONSTEXPR long double min() { return LDBL_MIN; } - static ETL_CONSTEXPR long double max() { return LDBL_MAX; } - static ETL_CONSTEXPR long double lowest() { return -LDBL_MAX; } - static ETL_CONSTEXPR long double epsilon() { return LDBL_EPSILON; } - static ETL_CONSTEXPR long double denorm_min() { return LDBL_MIN; } + static const bool is_specialized = true; - static ETL_CONST_OR_CONSTEXPR int digits = LDBL_MANT_DIG; - static ETL_CONST_OR_CONSTEXPR int digits10 = LDBL_DIG; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = ETL_LOG2(LDBL_MANT_DIG) + 2; + static const bool is_signed = true; + static const bool is_integer = false; + static const bool is_exact = false; - static ETL_CONST_OR_CONSTEXPR int min_exponent = LDBL_MIN_EXP; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = LDBL_MIN_10_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent = LDBL_MAX_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = LDBL_MAX_10_EXP; + static const int radix = 2; + + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const float_denorm_style has_denorm = denorm_indeterminate; + static const bool has_denorm_loss = false; + + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = false; + + static const float round_error() { return (long double)(0.5); } + + static const bool traps = false; + static const bool tinyness_before = false; + static const float_round_style round_style = round_indeterminate; + + static const long double min() { return LDBL_MIN; } + static const long double max() { return LDBL_MAX; } + static const long double lowest() { return -LDBL_MAX; } + static const long double epsilon() { return LDBL_EPSILON; } + static const long double denorm_min() { return LDBL_MIN; } + + static const int digits = LDBL_MANT_DIG; + static const int digits10 = LDBL_DIG; + static const int max_digits10 = ETL_LOG2(LDBL_MANT_DIG) + 2; + + static const int min_exponent = LDBL_MIN_EXP; + static const int min_exponent10 = LDBL_MIN_10_EXP; + static const int max_exponent = LDBL_MAX_EXP; + static const int max_exponent10 = LDBL_MAX_10_EXP; }; + + #if !defined(ETL_COMPILER_MICROSOFT) + const bool numeric_limits::is_specialized; + const bool numeric_limits::is_signed; + const bool numeric_limits::is_integer; + const bool numeric_limits::is_exact; + const int numeric_limits::radix; + const bool numeric_limits::has_infinity; + const bool numeric_limits::has_quiet_NaN; + const bool numeric_limits::has_signaling_NaN; + const float_denorm_style numeric_limits::has_denorm; + const bool numeric_limits::has_denorm_loss; + const bool numeric_limits::is_iec559; + const bool numeric_limits::is_bounded; + const bool numeric_limits::is_modulo; + const bool numeric_limits::traps; + const bool numeric_limits::tinyness_before; + const float_round_style numeric_limits::round_style; + const int numeric_limits::digits; + const int numeric_limits::digits10; + const int numeric_limits::max_digits10; + const int numeric_limits::min_exponent; + const int numeric_limits::min_exponent10; + const int numeric_limits::max_exponent; + const int numeric_limits::max_exponent10; + #endif } #else #include -namespace etlstd +namespace etl { enum float_round_style { diff --git a/include/etl/list.h b/include/etl/list.h index 2147daa8..6225d011 100644 --- a/include/etl/list.h +++ b/include/etl/list.h @@ -182,6 +182,8 @@ namespace etl //*********************************************************************** inline void reverse() { + using ETL_OR_STD::swap; // Allow ADL + swap(previous, next); } @@ -676,7 +678,7 @@ namespace etl const node_t* p_node; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; @@ -810,7 +812,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(list_iterator)); ETL_ASSERT(size_t(d) <= MAX_SIZE, ETL_ERROR(list_full)); #endif @@ -866,7 +868,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(list_full)); #endif - insert_node(get_head(), allocate_data_node(etlstd::move(value))); + insert_node(get_head(), allocate_data_node(etl::move(value))); } #endif @@ -883,7 +885,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(etlstd::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(get_head(), *p_data_node); } @@ -989,7 +991,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(list_full)); #endif - insert_node(terminal_node, allocate_data_node(etlstd::move(value))); + insert_node(terminal_node, allocate_data_node(etl::move(value))); } #endif @@ -1006,7 +1008,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(etlstd::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(terminal_node, *p_data_node); } @@ -1101,7 +1103,7 @@ namespace etl { ETL_ASSERT(!full(), ETL_ERROR(list_full)); - data_node_t& data_node = allocate_data_node(etlstd::move(value)); + data_node_t& data_node = allocate_data_node(etl::move(value)); insert_node(*position.p_node, data_node); return iterator(data_node); @@ -1119,7 +1121,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(etlstd::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(*position.p_node, *p_data_node); @@ -1269,7 +1271,7 @@ namespace etl else if (n < size()) { iterator i_start = end(); - etlstd::advance(i_start, -difference_type(size() - n)); + etl::advance(i_start, -difference_type(size() - n)); erase(i_start, end()); } // Larger? @@ -1334,7 +1336,7 @@ namespace etl //************************************************************************* void unique() { - unique(etlstd::equal_to()); + unique(etl::equal_to()); } //************************************************************************* @@ -1390,7 +1392,7 @@ namespace etl typename ilist::iterator itr = other.begin(); while (itr != other.end()) { - to = insert(to, etlstd::move(*itr++)); + to = insert(to, etl::move(*itr++)); } other.erase(other.begin(), other.end()); @@ -1430,7 +1432,7 @@ namespace etl else { // From another list. - insert(to, etlstd::move(*from)); + insert(to, etl::move(*from)); other.erase(from); } } @@ -1471,7 +1473,7 @@ namespace etl ilist::iterator itr = first; while (itr != last) { - to = insert(to, etlstd::move(*itr++)); + to = insert(to, etl::move(*itr++)); ++to; } @@ -1485,7 +1487,7 @@ namespace etl //************************************************************************* void merge(ilist& other) { - merge(other, etlstd::less()); + merge(other, etl::less()); } //************************************************************************* @@ -1542,7 +1544,7 @@ namespace etl //************************************************************************* void merge(ilist&& other) { - merge(etlstd::move(other), etlstd::less()); + merge(etl::move(other), etl::less()); } //************************************************************************* @@ -1577,7 +1579,7 @@ namespace etl { while ((other_begin != other_end) && (compare(*other_begin, *this_begin))) { - insert(this_begin, etlstd::move(*other_begin)); + insert(this_begin, etl::move(*other_begin)); ++other_begin; } } @@ -1588,7 +1590,7 @@ namespace etl { while (other_begin != other_end) { - insert(this_end, etlstd::move(*other_begin++)); + insert(this_end, etl::move(*other_begin++)); } } @@ -1603,7 +1605,7 @@ namespace etl //************************************************************************* void sort() { - sort(etlstd::less()); + sort(etl::less()); } //************************************************************************* @@ -1765,7 +1767,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(etlstd::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -1917,7 +1919,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(etlstd::move(value)); + ::new (&(p_data_node->value)) T(etl::move(value)); ETL_INCREMENT_DEBUG_COUNT return *p_data_node; @@ -2033,7 +2035,7 @@ namespace etl typename etl::ilist::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2089,7 +2091,7 @@ namespace etl typename etl::ilist::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2191,7 +2193,7 @@ namespace etl typename etl::ilist::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2247,7 +2249,7 @@ namespace etl typename etl::ilist::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2282,7 +2284,7 @@ namespace etl template bool operator ==(const etl::ilist& lhs, const etl::ilist& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -2307,7 +2309,7 @@ namespace etl template bool operator <(const etl::ilist& lhs, const etl::ilist& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/map.h b/include/etl/map.h index 131e3dd1..b068888f 100755 --- a/include/etl/map.h +++ b/include/etl/map.h @@ -462,7 +462,7 @@ namespace etl /// A templated base for all etl::map types. ///\ingroup map //*************************************************************************** - template > + template > class imap : public etl::map_base { public: @@ -804,7 +804,7 @@ namespace etl friend class const_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; @@ -917,7 +917,7 @@ namespace etl if (!i_element.p_node) { // Doesn't exist, so create a new one. - i_element = insert(ETL_MAKE_PAIR(key, mapped_type())).first; + i_element = insert(ETL_OR_STD::make_pair(key, mapped_type())).first; } return i_element->second; @@ -991,7 +991,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, key)), iterator(*this, find_upper_node(root_node, key))); } @@ -1002,7 +1002,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, key)), const_iterator(*this, find_upper_node(root_node, key))); } @@ -1109,7 +1109,7 @@ namespace etl inserted = inserted_node == &node; // Insert node into tree and return iterator to new node location in tree - return ETL_MAKE_PAIR(iterator(*this, inserted_node), inserted); + return ETL_OR_STD::make_pair(iterator(*this, inserted_node), inserted); } //********************************************************************* @@ -2042,7 +2042,7 @@ namespace etl //************************************************************************* /// A templated map implementation that uses a fixed size buffer. //************************************************************************* - template > + template > class map : public etl::imap { public: @@ -2129,7 +2129,7 @@ namespace etl template bool operator ==(const etl::imap& lhs, const etl::imap& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2155,7 +2155,7 @@ namespace etl template bool operator <(const etl::imap& lhs, const etl::imap& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/memory.h b/include/etl/memory.h index 53623b2b..8d9c1aa1 100644 --- a/include/etl/memory.h +++ b/include/etl/memory.h @@ -48,9 +48,9 @@ SOFTWARE. #endif ///\defgroup memory memory -///\ingroup etlstd +///\ingroup etl -namespace etlstd +namespace etl { //***************************************************************************** /// Gets the address of an object. @@ -74,10 +74,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value) { - etlstd::fill(o_begin, o_end, value); + etl::fill(o_begin, o_end, value); return o_end; } @@ -88,10 +88,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value) { - typedef typename etlstd::iterator_traits::value_type value_type; + typedef typename etl::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -109,12 +109,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) { - count += int32_t(etlstd::distance(o_begin, o_end)); + count += int32_t(etl::distance(o_begin, o_end)); - etlstd::fill(o_begin, o_end, value); + etl::fill(o_begin, o_end, value); return o_end; } @@ -126,12 +126,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) { - count += int32_t(etlstd::distance(o_begin, o_end)); + count += int32_t(etl::distance(o_begin, o_end)); - etlstd::uninitialized_fill(o_begin, o_end, value); + etl::uninitialized_fill(o_begin, o_end, value); return o_end; } @@ -159,7 +159,7 @@ namespace etlstd template TOutputIterator uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) { - count += int32_t(etlstd::distance(o_begin, o_end)); + count += int32_t(etl::distance(o_begin, o_end)); std::uninitialized_fill(o_begin, o_end, value); @@ -176,7 +176,7 @@ namespace etlstd template TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T& value) { - return etlstd::uninitialized_fill(o_begin, o_begin + n, value); + return etl::uninitialized_fill(o_begin, o_begin + n, value); } //***************************************************************************** @@ -190,7 +190,7 @@ namespace etlstd { count += n; - return etlstd::uninitialized_fill(o_begin, o_begin + n, value); + return etl::uninitialized_fill(o_begin, o_begin + n, value); } #else //***************************************************************************** @@ -226,10 +226,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin) { - return etlstd::copy(i_begin, i_end, o_begin); + return etl::copy(i_begin, i_end, o_begin); } //***************************************************************************** @@ -238,10 +238,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin) { - typedef typename etlstd::iterator_traits::value_type value_type; + typedef typename etl::iterator_traits::value_type value_type; TOutputIterator o_end = o_begin; @@ -262,11 +262,11 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter& count) { - TOutputIterator o_end = etlstd::copy(i_begin, i_end, o_begin); - count += int32_t(etlstd::distance(o_begin, o_end)); + TOutputIterator o_end = etl::copy(i_begin, i_end, o_begin); + count += int32_t(etl::distance(o_begin, o_end)); return o_end; } @@ -278,12 +278,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter& count) { - TOutputIterator o_end = etlstd::uninitialized_copy(i_begin, i_end, o_begin); + TOutputIterator o_end = etl::uninitialized_copy(i_begin, i_end, o_begin); - count += int32_t(etlstd::distance(o_begin, o_end)); + count += int32_t(etl::distance(o_begin, o_end)); return o_end; } @@ -321,7 +321,7 @@ namespace etlstd template TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin) { - return etlstd::uninitialized_copy(i_begin, i_begin + n, o_begin); + return etl::uninitialized_copy(i_begin, i_begin + n, o_begin); } //***************************************************************************** @@ -335,7 +335,7 @@ namespace etlstd { count += n; - return etlstd::uninitialized_copy(i_begin, i_begin + n, o_begin); + return etl::uninitialized_copy(i_begin, i_begin + n, o_begin); } #else //***************************************************************************** @@ -371,7 +371,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_default_construct(TOutputIterator /*o_begin*/, TOutputIterator /*o_end*/) { // Do nothing @@ -383,11 +383,11 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end) { - typedef typename etlstd::iterator_traits::value_type value_type; + typedef typename etl::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -403,10 +403,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count = int32_t(etlstd::distance(o_begin, o_end)); + count = int32_t(etl::distance(o_begin, o_end)); } //***************************************************************************** @@ -416,12 +416,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count += int32_t(etlstd::distance(o_begin, o_end)); + count += int32_t(etl::distance(o_begin, o_end)); - etlstd::uninitialized_default_construct(o_begin, o_end); + etl::uninitialized_default_construct(o_begin, o_end); } #else //***************************************************************************** @@ -430,7 +430,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end) { std::uninitialized_default_construct(o_begin, o_end); @@ -443,10 +443,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count = int32_t(etlstd::distance(o_begin, o_end)); + count = int32_t(etl::distance(o_begin, o_end)); std::uninitialized_default_construct(o_begin, o_end); } @@ -459,7 +459,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) { TOutputIterator o_end = o_begin + n; @@ -472,12 +472,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) { TOutputIterator o_end = o_begin + n; - etlstd::uninitialized_default_construct(o_begin, o_end); + etl::uninitialized_default_construct(o_begin, o_end); return o_end; } @@ -489,7 +489,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { TOutputIterator o_end = o_begin + n; @@ -506,12 +506,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + typename etl::enable_if::value_type>::value, TOutputIterator>::type uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { TOutputIterator o_end = o_begin + n; - etlstd::uninitialized_default_construct(o_begin, o_end); + etl::uninitialized_default_construct(o_begin, o_end); count += n; @@ -524,13 +524,11 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) + TOutputIterator uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) { return std::uninitialized_default_construct_n(o_begin, n); } - //***************************************************************************** /// Default initialises N objects to uninitialised memory. /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n @@ -538,8 +536,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) + TOutputIterator uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { count += n; @@ -554,12 +551,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) { - typedef typename etlstd::iterator_traits::value_type value_type; + typedef typename etl::iterator_traits::value_type value_type; - etlstd::fill(o_begin, o_end, value_type()); + etl::fill(o_begin, o_end, value_type()); } //***************************************************************************** @@ -568,10 +565,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) { - typedef typename etlstd::iterator_traits::value_type value_type; + typedef typename etl::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -589,9 +586,9 @@ namespace etlstd template void uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count += int32_t(etlstd::distance(o_begin, o_end)); + count += int32_t(etl::distance(o_begin, o_end)); - etlstd::uninitialized_value_construct(o_begin, o_end); + etl::uninitialized_value_construct(o_begin, o_end); } #else //***************************************************************************** @@ -614,7 +611,7 @@ namespace etlstd template void uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count += int32_t(etlstd::distance(o_begin, o_end)); + count += int32_t(etl::distance(o_begin, o_end)); std::uninitialized_value_construct(o_begin, o_end); } @@ -632,7 +629,7 @@ namespace etlstd { TOutputIterator o_end = o_begin + n; - etlstd::uninitialized_value_construct(o_begin, o_end); + etl::uninitialized_value_construct(o_begin, o_end); return o_end; } @@ -648,7 +645,7 @@ namespace etlstd { TOutputIterator o_end = o_begin + n; - etlstd::uninitialized_value_construct(o_begin, o_end); + etl::uninitialized_value_construct(o_begin, o_end); count += n; @@ -688,7 +685,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type destroy_at(T* /*p*/) { } @@ -699,7 +696,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type destroy_at(T* p) { p->~T(); @@ -712,7 +709,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type destroy_at(T* /*p*/, TCounter& count) { --count; @@ -725,7 +722,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type destroy_at(T* p, TCounter& count) { p->~T(); @@ -750,7 +747,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - void destroy_at(T* /*p*/, TCounter& count) + void destroy_at(T* p, TCounter& count) { --count; std::destroy_at(p); @@ -764,7 +761,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type destroy(TIterator /*i_begin*/, TIterator /*i_end*/) { } @@ -775,12 +772,12 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type destroy(TIterator i_begin, TIterator i_end) { while (i_begin != i_end) { - etlstd::destroy_at(etl::addressof(*i_begin)); + etl::destroy_at(etl::addressof(*i_begin)); ++i_begin; } } @@ -792,10 +789,10 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type destroy(TIterator i_begin, TIterator i_end, TCounter& count) { - count -= int32_t(etlstd::distance(i_begin, i_end)); + count -= int32_t(etl::distance(i_begin, i_end)); } //***************************************************************************** @@ -805,14 +802,14 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, void>::type + typename etl::enable_if::value_type>::value, void>::type destroy(TIterator i_begin, TIterator i_end, TCounter& count) { - count -= int32_t(etlstd::distance(i_begin, i_end)); + count -= int32_t(etl::distance(i_begin, i_end)); while (i_begin != i_end) { - etlstd::destroy_at(etl::addressof(*i_begin)); + etl::destroy_at(etl::addressof(*i_begin)); ++i_begin; } } @@ -837,7 +834,7 @@ namespace etlstd template void destroy(TIterator i_begin, TIterator i_end, TCounter& count) { - count -= int32_t(etlstd::distance(i_begin, i_end)); + count -= int32_t(etl::distance(i_begin, i_end)); std::destroy(i_begin, i_end); } @@ -850,7 +847,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TIterator>::type + typename etl::enable_if::value_type>::value, TIterator>::type destroy_n(TIterator i_begin, TSize n) { return i_begin + n; @@ -862,7 +859,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TIterator>::type + typename etl::enable_if::value_type>::value, TIterator>::type destroy_n(TIterator i_begin, TSize n) { while (n > 0) @@ -882,7 +879,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TIterator>::type + typename etl::enable_if::value_type>::value, TIterator>::type destroy_n(TIterator i_begin, TSize n, TCounter& count) { count -= n; @@ -896,7 +893,7 @@ namespace etlstd ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value_type>::value, TIterator>::type + typename etl::enable_if::value_type>::value, TIterator>::type destroy_n(TIterator i_begin, TSize n, TCounter& count) { count -= n; @@ -974,7 +971,7 @@ namespace etlstd /// https://en.cppreference.com/w/cpp/memory/unique_ptr ///\ingroup memory //***************************************************************************** - template > + template > class unique_ptr { public: @@ -1247,7 +1244,7 @@ namespace etl ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type create_default_at(T* /*p*/) { } @@ -1257,7 +1254,7 @@ namespace etl ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type create_default_at(T* /*p*/, TCounter& count) { ++count; @@ -1268,7 +1265,7 @@ namespace etl ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type create_default_at(T* p) { ::new (p) T; @@ -1279,7 +1276,7 @@ namespace etl ///\ingroup memory //***************************************************************************** template - typename etlstd::enable_if::value, void>::type + typename etl::enable_if::value, void>::type create_default_at(T* p, TCounter& count) { ::new (p) T; @@ -1325,7 +1322,7 @@ namespace etl template void create_copy_at(T* p, T&& value) { - ::new (p) T(etlstd::move(value)); + ::new (p) T(etl::move(value)); } #endif @@ -1382,7 +1379,7 @@ namespace etl template T& make_copy_at(T* p, T&& other) { - ::new (p) T(etlstd::move(other)); + ::new (p) T(etl::move(other)); return *reinterpret_cast(p); } #endif @@ -1418,7 +1415,7 @@ namespace etl template T& make_value_at(T* p, TParameter&& value) { - ::new (p) T(etlstd::move(value)); + ::new (p) T(etl::move(value)); return *reinterpret_cast(p); } #endif @@ -1519,7 +1516,7 @@ namespace etl template void memory_clear_range(volatile T* begin, volatile T* end) { - const size_t n = static_cast(etlstd::distance(begin, end)); + const size_t n = static_cast(etl::distance(begin, end)); memory_clear_range(begin, n); } @@ -1577,7 +1574,7 @@ namespace etl template void memory_set_range(volatile T* begin, volatile T* end, const char value) { - const size_t n = static_cast(etlstd::distance(begin, end)); + const size_t n = static_cast(etl::distance(begin, end)); memory_set_range(begin, n, value); } diff --git a/include/etl/message_bus.h b/include/etl/message_bus.h index 32e4eb7f..12e75c8f 100644 --- a/include/etl/message_bus.h +++ b/include/etl/message_bus.h @@ -102,7 +102,7 @@ namespace etl if (ok) { - router_list_t::iterator irouter = etlstd::upper_bound(router_list.begin(), + router_list_t::iterator irouter = etl::upper_bound(router_list.begin(), router_list.end(), router.get_message_router_id(), compare_router_id()); @@ -125,7 +125,7 @@ namespace etl } else { - ETL_OR_STD::pair range = etlstd::equal_range(router_list.begin(), + ETL_OR_STD::pair range = etl::equal_range(router_list.begin(), router_list.end(), id, compare_router_id()); @@ -137,7 +137,7 @@ namespace etl //******************************************* void unsubscribe(etl::imessage_router& router) { - router_list_t::iterator irouter = etlstd::find(router_list.begin(), + router_list_t::iterator irouter = etl::find(router_list.begin(), router_list.end(), &router); @@ -212,7 +212,7 @@ namespace etl router_list_t::iterator irouter = router_list.begin(); // Find routers with the id. - ETL_OR_STD::pair range = etlstd::equal_range(router_list.begin(), + ETL_OR_STD::pair range = etl::equal_range(router_list.begin(), router_list.end(), destination_router_id, compare_router_id()); @@ -230,7 +230,7 @@ namespace etl // Do any message buses. // These are always at the end of the list. - irouter = etlstd::lower_bound(router_list.begin(), + irouter = etl::lower_bound(router_list.begin(), router_list.end(), etl::imessage_bus::MESSAGE_BUS, compare_router_id()); diff --git a/include/etl/multimap.h b/include/etl/multimap.h index e9b88f50..37ca3902 100644 --- a/include/etl/multimap.h +++ b/include/etl/multimap.h @@ -624,7 +624,7 @@ namespace etl /// A templated base for all etl::multimap types. ///\ingroup map //*************************************************************************** - template > + template > class imultimap : public etl::multimap_base { public: @@ -960,7 +960,7 @@ namespace etl }; friend class const_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; @@ -1099,7 +1099,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, key)), iterator(*this, find_upper_node(root_node, key))); } @@ -1110,7 +1110,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, key)), const_iterator(*this, find_upper_node(root_node, key))); } @@ -1931,7 +1931,7 @@ namespace etl //************************************************************************* /// A templated multimap implementation that uses a fixed size buffer. //************************************************************************* - template > + template > class multimap : public etl::imultimap { public: @@ -2018,7 +2018,7 @@ namespace etl template bool operator ==(const etl::imultimap& lhs, const etl::imultimap& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2044,7 +2044,7 @@ namespace etl template bool operator <(const etl::imultimap& lhs, const etl::imultimap& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/multiset.h b/include/etl/multiset.h index 72111914..ffc63709 100644 --- a/include/etl/multiset.h +++ b/include/etl/multiset.h @@ -925,7 +925,7 @@ namespace etl }; friend class const_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; @@ -1064,7 +1064,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(const value_type& key) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, key)), iterator(*this, find_upper_node(root_node, key))); } @@ -1075,7 +1075,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(const value_type& key) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, key)), const_iterator(*this, find_upper_node(root_node, key))); } diff --git a/include/etl/murmur3.h b/include/etl/murmur3.h index 6b869c7b..bb15c259 100644 --- a/include/etl/murmur3.h +++ b/include/etl/murmur3.h @@ -57,7 +57,7 @@ namespace etl { public: - ETL_STATIC_ASSERT((etlstd::is_same::value || etlstd::is_same::value), "Only 32 & 64 bit types supported"); + ETL_STATIC_ASSERT((etl::is_same::value || etl::is_same::value), "Only 32 & 64 bit types supported"); typedef THash value_type; @@ -81,7 +81,7 @@ namespace etl murmur3(TIterator begin, const TIterator end, value_type seed_ = 0) : seed(seed_) { - ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Incompatible type"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Incompatible type"); reset(); while (begin != end) @@ -119,7 +119,7 @@ namespace etl template void add(TIterator begin, const TIterator end) { - ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Incompatible type"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Incompatible type"); ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised)); while (begin != end) diff --git a/include/etl/negative.h b/include/etl/negative.h index eecf73a8..7b2a6b33 100644 --- a/include/etl/negative.h +++ b/include/etl/negative.h @@ -39,7 +39,7 @@ namespace etl // For signed types. //*************************************************************************** template - typename etlstd::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type is_negative(const T value) { return (value < T(0)); @@ -49,7 +49,7 @@ namespace etl // For unsigned types. //*************************************************************************** template - typename etlstd::enable_if::value, T>::type + typename etl::enable_if::value, T>::type is_negative(const T) { return false; diff --git a/include/etl/observer.h b/include/etl/observer.h index 9441f07c..188ecc87 100644 --- a/include/etl/observer.h +++ b/include/etl/observer.h @@ -115,7 +115,7 @@ namespace etl void add_observer(TObserver& observer) { // See if we already have it in our list. - typename Observer_List::const_iterator i_observer = etlstd::find(observer_list.begin(), + typename Observer_List::const_iterator i_observer = etl::find(observer_list.begin(), observer_list.end(), &observer); @@ -138,7 +138,7 @@ namespace etl bool remove_observer(TObserver& observer) { // See if we have it in our list. - typename Observer_List::iterator i_observer = etlstd::find(observer_list.begin(), + typename Observer_List::iterator i_observer = etl::find(observer_list.begin(), observer_list.end(), &observer); diff --git a/include/etl/packet.h b/include/etl/packet.h index b25e55fe..35390315 100644 --- a/include/etl/packet.h +++ b/include/etl/packet.h @@ -64,9 +64,9 @@ namespace etl template explicit packet(const T& value) { - ETL_STATIC_ASSERT((etlstd::is_base_of::value), "Unsupported type"); + ETL_STATIC_ASSERT((etl::is_base_of::value), "Unsupported type"); ETL_STATIC_ASSERT(sizeof(T) <= SIZE, "Unsupported size"); - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Unsupported alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Unsupported alignment"); ::new (static_cast(data)) T(value); } @@ -86,9 +86,9 @@ namespace etl template packet& operator =(const T& value) { - ETL_STATIC_ASSERT((etlstd::is_base_of::value), "Unsupported type"); + ETL_STATIC_ASSERT((etl::is_base_of::value), "Unsupported type"); ETL_STATIC_ASSERT(sizeof(T) <= SIZE, "Unsupported size"); - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Unsupported alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Unsupported alignment"); static_cast(data)->~TBase(); ::new (static_cast(data)) T(value); diff --git a/include/etl/parameter_type.h b/include/etl/parameter_type.h index a8587c71..1150c86b 100644 --- a/include/etl/parameter_type.h +++ b/include/etl/parameter_type.h @@ -43,7 +43,7 @@ namespace etl struct parameter_type { /// By default fundamental and pointer types are passed by value. - typedef typename etlstd::conditional::value || is_pointer::value, + typedef typename etl::conditional::value || etl::is_pointer::value, T, const T&>::type type; }; diff --git a/include/etl/pearson.h b/include/etl/pearson.h index eebcec57..d7379c78 100644 --- a/include/etl/pearson.h +++ b/include/etl/pearson.h @@ -81,7 +81,7 @@ namespace etl pearson(TIterator begin, const TIterator end) : first(true) { - ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Type not supported"); reset(); add(begin, end); @@ -103,7 +103,7 @@ namespace etl template void add(TIterator begin, const TIterator end) { - ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Type not supported"); while (begin != end) { diff --git a/include/etl/platform.h b/include/etl/platform.h index e5a21937..eaf3ae58 100644 --- a/include/etl/platform.h +++ b/include/etl/platform.h @@ -72,7 +72,7 @@ SOFTWARE. #endif // The macros below are dependent on the profile. -#if ETL_CPP11_SUPPORTED +#if ETL_CPP11_SUPPORTED && !defined(ETL_FORCE_NO_ADVANCED_CPP) #define ETL_CONSTEXPR constexpr #define ETL_CONST_OR_CONSTEXPR constexpr #define ETL_DELETE = delete @@ -86,7 +86,7 @@ SOFTWARE. #define ETL_NOEXCEPT_EXPR(expression) #endif -#if ETL_CPP17_SUPPORTED +#if ETL_CPP17_SUPPORTED && !defined(ETL_FORCE_NO_ADVANCED_CPP) #define ETL_CONSTEXPR17 constexpr #define ETL_IF_CONSTEXPR constexpr #define ETL_NODISCARD [[nodiscard]] @@ -102,7 +102,7 @@ SOFTWARE. #define ETL_EXPLICIT_STRING_FROM_CHAR #endif -// Sort out names for STL/No STL options. +// Sort out namespaces for STL/No STL options. #include "private/choose_namespace.h" #endif diff --git a/include/etl/pool.h b/include/etl/pool.h index 232f504a..8f051420 100644 --- a/include/etl/pool.h +++ b/include/etl/pool.h @@ -224,7 +224,7 @@ namespace etl if (p) { - ::new (p) T(etlstd::forward(args)...); + ::new (p) T(etl::forward(args)...); } return p; @@ -492,7 +492,7 @@ namespace etl template U* allocate() { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return ipool::allocate(); } @@ -506,7 +506,7 @@ namespace etl template U* create() { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return ipool::create(); } @@ -519,7 +519,7 @@ namespace etl template U* create(const T1& value1) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return ipool::create(value1); } @@ -532,7 +532,7 @@ namespace etl template U* create(const T1& value1, const T2& value2) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return ipool::create(value1, value2); } @@ -545,7 +545,7 @@ namespace etl template U* create(const T1& value1, const T2& value2, const T3& value3) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return ipool::create(value1, value2, value3); } @@ -558,7 +558,7 @@ namespace etl template U* create(const T1& value1, const T2& value2, const T3& value3, const T4& value4) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return ipool::create(value1, value2, value3, value4); } @@ -569,9 +569,9 @@ namespace etl template U* create(Args&&... args) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); - return ipool::create(etlstd::forward(args)...); + return ipool::create(etl::forward(args)...); } #endif @@ -583,7 +583,7 @@ namespace etl template void destroy(const void* const p_object) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); reinterpret_cast((const_cast(p_object)))->~U(); ipool::release(p_object); @@ -600,7 +600,7 @@ namespace etl }; ///< The memory for the pool of objects. - typename etl::aligned_storage::value>::type buffer[SIZE]; + typename etl::aligned_storage::value>::type buffer[SIZE]; static const uint32_t ELEMENT_SIZE = sizeof(Element); @@ -614,11 +614,11 @@ namespace etl ///\ingroup pool //************************************************************************* template - class pool : public etl::generic_pool::value, SIZE_> + class pool : public etl::generic_pool::value, SIZE_> { private: - typedef etl::generic_pool::value, SIZE_> base_t; + typedef etl::generic_pool::value, SIZE_> base_t; public: @@ -643,7 +643,7 @@ namespace etl template U* allocate() { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return base_t::template allocate(); } @@ -657,7 +657,7 @@ namespace etl template U* create() { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return base_t::template create(); } @@ -670,7 +670,7 @@ namespace etl template U* create(const T1& value1) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return base_t::template create(value1); } @@ -683,7 +683,7 @@ namespace etl template U* create(const T1& value1, const T2& value2) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return base_t::template create(value1, value2); } @@ -696,7 +696,7 @@ namespace etl template U* create(const T1& value1, const T2& value2, const T3& value3) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return base_t::template create(value1, value2, value3); } @@ -709,7 +709,7 @@ namespace etl template U* create(const T1& value1, const T2& value2, const T3& value3, const T4& value4) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); return base_t::template create(value1, value2, value3, value4); } @@ -722,9 +722,9 @@ namespace etl template U* create(Args&&... args) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); - return base_t::template create(etlstd::forward(args)...); + return base_t::template create(etl::forward(args)...); } #endif @@ -736,7 +736,7 @@ namespace etl template void destroy(const void* const p_object) { - ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); reinterpret_cast((const_cast(p_object)))->~U(); base_t::release(p_object); diff --git a/include/etl/priority_queue.h b/include/etl/priority_queue.h index 5a232a4d..8f1174ed 100644 --- a/include/etl/priority_queue.h +++ b/include/etl/priority_queue.h @@ -115,7 +115,7 @@ namespace etl /// \tparam TContainer to hold the T queue values /// \tparam TCompare to use in comparing T values //*************************************************************************** - template > + template > class ipriority_queue { public: @@ -126,7 +126,7 @@ namespace etl typedef T& reference; ///< A reference to the type used in the queue. typedef const T& const_reference; ///< A const reference to the type used in the queue. typedef typename TContainer::size_type size_type; ///< The type used for determining the size of the queue. - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; private: @@ -165,7 +165,7 @@ namespace etl // Put element at end container.push_back(value); // Make elements in container into heap - etlstd::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_PRIORITY_QUEUE_FORCE_CPP03) @@ -181,9 +181,9 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(etl::priority_queue_full)); // Put element at end - container.emplace_back(etlstd::forward(args)...); + container.emplace_back(etl::forward(args)...); // Make elements in container into heap - etlstd::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } #else //************************************************************************* @@ -200,7 +200,7 @@ namespace etl // Put element at end container.emplace_back(value1); // Make elements in container into heap - etlstd::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -217,7 +217,7 @@ namespace etl // Put element at end container.emplace_back(value1, value2); // Make elements in container into heap - etlstd::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -234,7 +234,7 @@ namespace etl // Put element at end container.emplace_back(value1, value2, value3); // Make elements in container into heap - etlstd::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -251,7 +251,7 @@ namespace etl // Put element at end container.emplace_back(value1, value2, value3, value4); // Make elements in container into heap - etlstd::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } #endif @@ -268,14 +268,14 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(etl::priority_queue_iterator)); ETL_ASSERT(static_cast(d) <= max_size(), ETL_ERROR(etl::priority_queue_full)); #endif clear(); container.assign(first, last); - etlstd::make_heap(container.begin(), container.end(), compare); + etl::make_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -285,7 +285,7 @@ namespace etl void pop() { // Move largest element to end - etlstd::pop_heap(container.begin(), container.end(), compare); + etl::pop_heap(container.begin(), container.end(), compare); // Actually remove largest element at end container.pop_back(); } @@ -386,7 +386,7 @@ namespace etl /// \tparam T The type this queue should support. /// \tparam SIZE The maximum capacity of the queue. //*************************************************************************** - template , typename TCompare = etlstd::less > + template , typename TCompare = etl::less > class priority_queue : public etl::ipriority_queue { public: diff --git a/include/etl/private/choose_namespace.h b/include/etl/private/choose_namespace.h index c8271715..a36a0984 100644 --- a/include/etl/private/choose_namespace.h +++ b/include/etl/private/choose_namespace.h @@ -36,8 +36,8 @@ SOFTWARE. #undef ETL_OR_STD #if defined(ETL_NO_STL) && !defined(ETL_IN_UNIT_TEST) - // If we're not using the STL and we are not unit testing, then use the ETL's definitions under the etlstd namespace - #define ETL_OR_STD etlstd + // If we're not using the STL and we are not unit testing, then use the ETL's definitions under the etl namespace + #define ETL_OR_STD etl #else // We will use the STL's definitions under the std namespace #define ETL_OR_STD std diff --git a/include/etl/private/ivectorpointer.h b/include/etl/private/ivectorpointer.h index 3497cf2c..9093eaf1 100644 --- a/include/etl/private/ivectorpointer.h +++ b/include/etl/private/ivectorpointer.h @@ -59,7 +59,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -441,7 +441,7 @@ namespace etl //********************************************************************* void initialise_source_external_buffer_after_move() { - ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -451,7 +451,7 @@ namespace etl //********************************************************************* void initialise_destination_external_buffer_after_move() { - ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) } }; @@ -470,7 +470,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -852,7 +852,7 @@ namespace etl //********************************************************************* void initialise_source_external_buffer_after_move() { - ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -862,7 +862,7 @@ namespace etl //********************************************************************* void initialise_destination_external_buffer_after_move() { - ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) } }; diff --git a/include/etl/private/minmax_pop.h b/include/etl/private/minmax_pop.h index 778f63b4..f46e46a1 100644 --- a/include/etl/private/minmax_pop.h +++ b/include/etl/private/minmax_pop.h @@ -33,7 +33,7 @@ SOFTWARE. * This file is intended to evaluated multiple times by design. */ -#ifdef ETL_COMPILER_MICROSOFT -#pragma pop_macro("min") -#pragma pop_macro("max") +#if defined(ETL_COMPILER_MICROSOFT) + #pragma pop_macro("min") + #pragma pop_macro("max") #endif diff --git a/include/etl/private/minmax_push.h b/include/etl/private/minmax_push.h index 4b009771..290a2024 100644 --- a/include/etl/private/minmax_push.h +++ b/include/etl/private/minmax_push.h @@ -33,9 +33,9 @@ SOFTWARE. * This file is intended to evaluated multiple times by design. */ -#ifdef ETL_COMPILER_MICROSOFT -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max +#if defined(ETL_COMPILER_MICROSOFT) + #pragma push_macro("min") + #pragma push_macro("max") + #undef min + #undef max #endif diff --git a/include/etl/private/pvoidvector.h b/include/etl/private/pvoidvector.h index 172dd41b..58963d8a 100644 --- a/include/etl/private/pvoidvector.h +++ b/include/etl/private/pvoidvector.h @@ -70,7 +70,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef etlstd::iterator_traits::difference_type difference_type; + typedef etl::iterator_traits::difference_type difference_type; public: @@ -211,7 +211,7 @@ namespace etl // Size up if necessary. if (p_end < p_new_end) { - etlstd::fill(p_end, p_new_end, value); + etl::fill(p_end, p_new_end, value); } p_end = p_new_end; @@ -326,7 +326,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(static_cast(d) <= CAPACITY, ETL_ERROR(vector_full)); #endif @@ -402,7 +402,7 @@ namespace etl if (position != end()) { ++p_end; - etlstd::copy_backward(position, end() - 1, end()); + etl::copy_backward(position, end() - 1, end()); *position = value; } else @@ -424,8 +424,8 @@ namespace etl { ETL_ASSERT((size() + 1) <= CAPACITY, ETL_ERROR(vector_full)); - etlstd::copy_backward(position, p_end, p_end + n); - etlstd::fill_n(position, n, value); + etl::copy_backward(position, p_end, p_end + n); + etl::fill_n(position, n, value); p_end += n; } @@ -441,12 +441,12 @@ namespace etl template void insert(iterator position, TIterator first, TIterator last) { - size_t count = etlstd::distance(first, last); + size_t count = etl::distance(first, last); ETL_ASSERT((size() + count) <= CAPACITY, ETL_ERROR(vector_full)); - etlstd::copy_backward(position, p_end, p_end + count); - etlstd::copy(first, last, position); + etl::copy_backward(position, p_end, p_end + count); + etl::copy(first, last, position); p_end += count; } @@ -457,7 +457,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - etlstd::copy(i_element + 1, end(), i_element); + etl::copy(i_element + 1, end(), i_element); --p_end; return i_element; @@ -473,8 +473,8 @@ namespace etl //********************************************************************* iterator erase(iterator first, iterator last) { - etlstd::copy(last, end(), first); - size_t n_delete = etlstd::distance(first, last); + etl::copy(last, end(), first); + size_t n_delete = etl::distance(first, last); // Just adjust the count. p_end -= n_delete; @@ -580,7 +580,7 @@ namespace etl //*************************************************************************** inline bool operator ==(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -604,7 +604,7 @@ namespace etl //*************************************************************************** inline bool operator <(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** diff --git a/include/etl/private/to_string_helper.h b/include/etl/private/to_string_helper.h index f2102f41..42514d68 100644 --- a/include/etl/private/to_string_helper.h +++ b/include/etl/private/to_string_helper.h @@ -56,7 +56,7 @@ namespace etl template void add_alignment(TIString& str, typename TIString::iterator position, const etl::basic_format_spec& format) { - uint32_t length = static_cast(etlstd::distance(position, str.end())); + uint32_t length = static_cast(etl::distance(position, str.end())); if (length < format.get_width()) { @@ -165,7 +165,7 @@ namespace etl } // Reverse the string we appended. - etlstd::reverse(start, str.end()); + etl::reverse(start, str.end()); } etl::private_to_string::add_alignment(str, start, format); @@ -241,7 +241,7 @@ namespace etl else { // Make sure we format the two halves correctly. - uint32_t max_precision = etlstd::numeric_limits::digits10; + uint32_t max_precision = etl::numeric_limits::digits10; etl::basic_format_spec integral_format = format; integral_format.decimal().width(0).precision(format.get_precision() > max_precision ? max_precision : format.get_precision()); @@ -354,10 +354,10 @@ namespace etl /// For signed integrals less than 64 bits. Default format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_signed::value && - !etlstd::is_same::value && - !etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_signed::value && + !etl::is_same::value && + !etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -371,10 +371,10 @@ namespace etl /// For signed integrals less than 64 bits. Supplied format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_signed::value && - !etlstd::is_same::value && - !etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_signed::value && + !etl::is_same::value && + !etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const etl::basic_format_spec& format, const bool append = false) { etl::private_to_string::add_integral(int32_t(value), str, format, append); @@ -386,10 +386,10 @@ namespace etl /// For unsigned integrals less then 64 bits. Default format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_unsigned::value && - !etlstd::is_same::value && - !etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_unsigned::value && + !etl::is_same::value && + !etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -403,10 +403,10 @@ namespace etl /// For unsigned integrals less than 64 bits. Supplied format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_unsigned::value && - !etlstd::is_same::value && - !etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_unsigned::value && + !etl::is_same::value && + !etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const etl::basic_format_spec& format, const bool append = false) { etl::private_to_string::add_integral(uint32_t(value), str, format, append); @@ -418,10 +418,10 @@ namespace etl /// For signed 64 bit integrals. Default format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_signed::value && - !etlstd::is_same::value && - etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_signed::value && + !etl::is_same::value && + etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -435,10 +435,10 @@ namespace etl /// For signed 64 bit integrals. Supplied format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_signed::value && - !etlstd::is_same::value && - etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_signed::value && + !etl::is_same::value && + etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const etl::basic_format_spec& format, const bool append = false) { etl::private_to_string::add_integral(int64_t(value), str, format, append); @@ -450,10 +450,10 @@ namespace etl /// For unsigned 64 bit integrals. Default format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_unsigned::value && - !etlstd::is_same::value && - etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_unsigned::value && + !etl::is_same::value && + etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -467,10 +467,10 @@ namespace etl /// For unsigned 64 bit integrals. Supplied format spec. //*************************************************************************** template - typename etlstd::enable_if::value && - etlstd::is_unsigned::value && - !etlstd::is_same::value && - etlstd::is_same::value, const TIString&>::type + typename etl::enable_if::value && + etl::is_unsigned::value && + !etl::is_same::value && + etl::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const etl::basic_format_spec& format, const bool append = false) { etl::private_to_string::add_integral(uint64_t(value), str, format, append); @@ -482,7 +482,7 @@ namespace etl /// For floating point. Default format spec. //*************************************************************************** template - typename etlstd::enable_if::value, const TIString&>::type + typename etl::enable_if::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -496,7 +496,7 @@ namespace etl /// For floating point. Supplied format spec. //*************************************************************************** template - typename etlstd::enable_if::value, const TIString&>::type + typename etl::enable_if::value, const TIString&>::type to_string(const T value, TIString& str, const etl::basic_format_spec& format, const bool append = false) { etl::private_to_string::add_floating_point(value, str, format, append); diff --git a/include/etl/queue.h b/include/etl/queue.h index a251690b..f669be1d 100644 --- a/include/etl/queue.h +++ b/include/etl/queue.h @@ -330,7 +330,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(queue_full)); #endif - ::new (&p_buffer[in]) T(etlstd::forward(args)...); + ::new (&p_buffer[in]) T(etl::forward(args)...); add_in(); } #else @@ -582,7 +582,7 @@ namespace etl private: /// The uninitialised buffer of T used in the stack. - typename etl::aligned_storage::value>::type buffer[SIZE]; + typename etl::aligned_storage::value>::type buffer[SIZE]; }; } diff --git a/include/etl/queue_mpmc_mutex.h b/include/etl/queue_mpmc_mutex.h index e71de49f..b8d220d1 100644 --- a/include/etl/queue_mpmc_mutex.h +++ b/include/etl/queue_mpmc_mutex.h @@ -179,7 +179,7 @@ namespace etl { access.lock(); - bool result = emplace_implementation(etlstd::forward(args)...); + bool result = emplace_implementation(etl::forward(args)...); access.unlock(); @@ -392,7 +392,7 @@ namespace etl { if (current_size != MAX_SIZE) { - ::new (&p_buffer[write_index]) T(etlstd::forward(args)...); + ::new (&p_buffer[write_index]) T(etl::forward(args)...); write_index = get_next_index(write_index, MAX_SIZE); @@ -585,7 +585,7 @@ namespace etl queue_mpmc_mutex& operator = (const queue_mpmc_mutex&); /// The uninitialised buffer of T used in the queue_mpmc_mutex. - typename etl::aligned_storage::value>::type buffer[MAX_SIZE]; + typename etl::aligned_storage::value>::type buffer[MAX_SIZE]; }; } diff --git a/include/etl/queue_spsc_atomic.h b/include/etl/queue_spsc_atomic.h index 98f681b8..f0490385 100644 --- a/include/etl/queue_spsc_atomic.h +++ b/include/etl/queue_spsc_atomic.h @@ -239,7 +239,7 @@ namespace etl if (next_index != read.load(etl::memory_order_acquire)) { - ::new (&p_buffer[write_index]) T(etlstd::forward(args)...); + ::new (&p_buffer[write_index]) T(etl::forward(args)...); write.store(next_index, etl::memory_order_release); @@ -469,7 +469,7 @@ namespace etl private: /// The uninitialised buffer of T used in the queue_spsc. - typename etl::aligned_storage::value>::type buffer[RESERVED_SIZE]; + typename etl::aligned_storage::value>::type buffer[RESERVED_SIZE]; }; } diff --git a/include/etl/queue_spsc_isr.h b/include/etl/queue_spsc_isr.h index 87ae3c98..aadd8420 100644 --- a/include/etl/queue_spsc_isr.h +++ b/include/etl/queue_spsc_isr.h @@ -82,7 +82,7 @@ namespace etl template bool emplace_from_isr(Args&&... args) { - return emplace_implementation(etlstd::forward(args)...); + return emplace_implementation(etl::forward(args)...); } #endif @@ -207,7 +207,7 @@ namespace etl { if (current_size != MAX_SIZE) { - ::new (&p_buffer[write_index]) T(etlstd::forward(args)...); + ::new (&p_buffer[write_index]) T(etl::forward(args)...); write_index = get_next_index(write_index, MAX_SIZE); @@ -440,7 +440,7 @@ namespace etl { TAccess::lock(); - bool result = this->emplace_implementation(etlstd::forward(args)...); + bool result = this->emplace_implementation(etl::forward(args)...); TAccess::unlock(); @@ -676,7 +676,7 @@ namespace etl queue_spsc_isr& operator = (const queue_spsc_isr&); /// The uninitialised buffer of T used in the queue_spsc_isr. - typename etl::aligned_storage::value>::type buffer[MAX_SIZE]; + typename etl::aligned_storage::value>::type buffer[MAX_SIZE]; }; } diff --git a/include/etl/queue_spsc_locked.h b/include/etl/queue_spsc_locked.h index 52f7e5f5..75053fd1 100644 --- a/include/etl/queue_spsc_locked.h +++ b/include/etl/queue_spsc_locked.h @@ -83,7 +83,7 @@ namespace etl template bool emplace_from_unlocked(Args&&... args) { - return emplace_implementation(etlstd::forward(args)...); + return emplace_implementation(etl::forward(args)...); } #endif @@ -208,7 +208,7 @@ namespace etl { if (current_size != MAX_SIZE) { - ::new (&p_buffer[write_index]) T(etlstd::forward(args)...); + ::new (&p_buffer[write_index]) T(etl::forward(args)...); write_index = get_next_index(write_index, MAX_SIZE); @@ -437,7 +437,7 @@ namespace etl { lock(); - bool result = this->emplace_implementation(etlstd::forward(args)...); + bool result = this->emplace_implementation(etl::forward(args)...); unlock(); @@ -677,7 +677,7 @@ namespace etl queue_spsc_locked& operator = (const queue_spsc_locked&); /// The uninitialised buffer of T used in the queue_spsc_locked. - typename etl::aligned_storage::value>::type buffer[MAX_SIZE]; + typename etl::aligned_storage::value>::type buffer[MAX_SIZE]; }; } diff --git a/include/etl/reference_flat_map.h b/include/etl/reference_flat_map.h index 2293fe7e..c5ac11c8 100644 --- a/include/etl/reference_flat_map.h +++ b/include/etl/reference_flat_map.h @@ -103,7 +103,7 @@ namespace etl /// Can be used as a reference type for all reference_flat_maps containing a specific type. ///\ingroup reference_flat_map //*************************************************************************** - template > + template > class ireference_flat_map { public: @@ -319,7 +319,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -525,10 +525,10 @@ namespace etl template void assign(TIterator first, TIterator last) { - ETL_STATIC_ASSERT((etlstd::is_same::value_type>::value), "Incompatible data for assign"); + ETL_STATIC_ASSERT((etl::is_same::value_type>::value), "Incompatible data for assign"); #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_map_full)); #endif @@ -693,7 +693,7 @@ namespace etl //********************************************************************* iterator lower_bound(key_parameter_t key) { - return etlstd::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -703,7 +703,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(key_parameter_t key) const { - return etlstd::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -713,7 +713,7 @@ namespace etl //********************************************************************* iterator upper_bound(key_parameter_t key) { - return etlstd::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -723,7 +723,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(key_parameter_t key) const { - return etlstd::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -733,9 +733,9 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) { - iterator i_lower = etlstd::lower_bound(begin(), end(), key, compare); + iterator i_lower = etl::lower_bound(begin(), end(), key, compare); - return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, end(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, end(), key, compare)); } //********************************************************************* @@ -745,9 +745,9 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) const { - const_iterator i_lower = etlstd::lower_bound(cbegin(), cend(), key, compare); + const_iterator i_lower = etl::lower_bound(cbegin(), cend(), key, compare); - return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, cend(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, cend(), key, compare)); } //************************************************************************* @@ -886,7 +886,7 @@ namespace etl template bool operator ==(const etl::ireference_flat_map& lhs, const etl::ireference_flat_map& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -906,11 +906,11 @@ namespace etl /// A reference_flat_map implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = etlstd::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup reference_flat_map //*************************************************************************** - template > + template > class reference_flat_map : public ireference_flat_map { public: diff --git a/include/etl/reference_flat_multimap.h b/include/etl/reference_flat_multimap.h index 08afd781..8a170cfa 100644 --- a/include/etl/reference_flat_multimap.h +++ b/include/etl/reference_flat_multimap.h @@ -78,7 +78,7 @@ namespace etl /// Can be used as a reference type for all reference_flat_multimaps containing a specific type. ///\ingroup reference_flat_multimap //*************************************************************************** - template > + template > class ireference_flat_multimap { public: @@ -294,7 +294,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -443,7 +443,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multimap_full)); #endif @@ -513,7 +513,7 @@ namespace etl } else { - size_t d = etlstd::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -605,7 +605,7 @@ namespace etl { ETL_OR_STD::pair range = equal_range(key); - return etlstd::distance(range.first, range.second); + return etl::distance(range.first, range.second); } //********************************************************************* @@ -615,7 +615,7 @@ namespace etl //********************************************************************* iterator lower_bound(key_parameter_t key) { - return etlstd::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -625,7 +625,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(key_parameter_t key) const { - return etlstd::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -635,7 +635,7 @@ namespace etl //********************************************************************* iterator upper_bound(key_parameter_t key) { - return etlstd::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -645,7 +645,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(key_parameter_t key) const { - return etlstd::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -655,9 +655,9 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) { - iterator i_lower = etlstd::lower_bound(begin(), end(), key, compare); + iterator i_lower = etl::lower_bound(begin(), end(), key, compare); - return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, end(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, end(), key, compare)); } //********************************************************************* @@ -667,9 +667,9 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(key_parameter_t key) const { - const_iterator i_lower = etlstd::lower_bound(cbegin(), cend(), key, compare); + const_iterator i_lower = etl::lower_bound(cbegin(), cend(), key, compare); - return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, cend(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, cend(), key, compare)); } //************************************************************************* @@ -799,7 +799,7 @@ namespace etl template bool operator ==(const etl::ireference_flat_multimap& lhs, const etl::ireference_flat_multimap& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -819,11 +819,11 @@ namespace etl /// A reference_flat_multimap implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = etlstd::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup reference_flat_multimap //*************************************************************************** - template > + template > class reference_flat_multimap : public ireference_flat_multimap { public: diff --git a/include/etl/reference_flat_multiset.h b/include/etl/reference_flat_multiset.h index 48decc45..47d390e6 100644 --- a/include/etl/reference_flat_multiset.h +++ b/include/etl/reference_flat_multiset.h @@ -98,7 +98,7 @@ namespace etl /// Can be used as a reference type for all reference_flat_multisets containing a specific type. ///\ingroup reference_flat_multiset //*************************************************************************** - template > + template > class ireference_flat_multiset { public: @@ -318,7 +318,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the reference_flat_multiset. @@ -439,7 +439,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multiset_full)); #endif @@ -462,7 +462,7 @@ namespace etl ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_multiset_full)); - iterator i_element = etlstd::lower_bound(begin(), end(), value, compare); + iterator i_element = etl::lower_bound(begin(), end(), value, compare); if (i_element == end()) { @@ -524,7 +524,7 @@ namespace etl } else { - size_t d = etlstd::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -566,7 +566,7 @@ namespace etl //********************************************************************* iterator find(parameter_t key) { - iterator itr = etlstd::lower_bound(begin(), end(), key, compare); + iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -590,7 +590,7 @@ namespace etl //********************************************************************* const_iterator find(parameter_t key) const { - const_iterator itr = etlstd::lower_bound(begin(), end(), key, compare); + const_iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -616,7 +616,7 @@ namespace etl { ETL_OR_STD::pair range = equal_range(key); - return etlstd::distance(range.first, range.second); + return etl::distance(range.first, range.second); } //********************************************************************* @@ -626,7 +626,7 @@ namespace etl //********************************************************************* iterator lower_bound(parameter_t key) { - return etlstd::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -636,7 +636,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(parameter_t key) const { - return etlstd::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -646,7 +646,7 @@ namespace etl //********************************************************************* iterator upper_bound(parameter_t key) { - return etlstd::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -656,7 +656,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(parameter_t key) const { - return etlstd::upper_bound(cbegin(), cend(), key, compare); + return etl::upper_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -666,7 +666,7 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(parameter_t key) { - return etlstd::equal_range(begin(), end(), key, compare); + return etl::equal_range(begin(), end(), key, compare); } //********************************************************************* @@ -676,7 +676,7 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(parameter_t key) const { - return etlstd::equal_range(begin(), end(), key, compare); + return etl::equal_range(begin(), end(), key, compare); } //************************************************************************* @@ -805,7 +805,7 @@ namespace etl /// An reference flat set ///\ingroup reference_flat_multiset //*************************************************************************** - template > + template > class reference_flat_multiset : public ireference_flat_multiset { public: @@ -868,7 +868,7 @@ namespace etl template bool operator ==(const etl::ireference_flat_multiset& lhs, const etl::ireference_flat_multiset& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** diff --git a/include/etl/reference_flat_set.h b/include/etl/reference_flat_set.h index a8b5faf9..94003f97 100644 --- a/include/etl/reference_flat_set.h +++ b/include/etl/reference_flat_set.h @@ -99,7 +99,7 @@ namespace etl /// Can be used as a reference type for all reference_flat_sets containing a specific type. ///\ingroup reference_flat_set //*************************************************************************** - template > + template > class ireference_flat_set { public: @@ -319,7 +319,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the reference_flat_set. @@ -440,7 +440,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full)); #endif @@ -547,7 +547,7 @@ namespace etl //********************************************************************* iterator find(parameter_t key) { - iterator itr = etlstd::lower_bound(begin(), end(), key, compare); + iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -571,7 +571,7 @@ namespace etl //********************************************************************* const_iterator find(parameter_t key) const { - const_iterator itr = etlstd::lower_bound(begin(), end(), key, compare); + const_iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -605,7 +605,7 @@ namespace etl //********************************************************************* iterator lower_bound(parameter_t key) { - return etlstd::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -615,7 +615,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(parameter_t key) const { - return etlstd::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -625,7 +625,7 @@ namespace etl //********************************************************************* iterator upper_bound(parameter_t key) { - return etlstd::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -635,7 +635,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(parameter_t key) const { - return etlstd::upper_bound(cbegin(), cend(), key, compare); + return etl::upper_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -645,7 +645,7 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(parameter_t key) { - return etlstd::equal_range(begin(), end(), key, compare); + return etl::equal_range(begin(), end(), key, compare); } //********************************************************************* @@ -655,7 +655,7 @@ namespace etl //********************************************************************* ETL_OR_STD::pair equal_range(parameter_t key) const { - return etlstd::upper_bound(cbegin(), cend(), key, compare); + return etl::upper_bound(cbegin(), cend(), key, compare); } //************************************************************************* @@ -788,7 +788,7 @@ namespace etl /// An reference flat set ///\ingroup reference_flat_set //*************************************************************************** - template > + template > class reference_flat_set : public ireference_flat_set { public: @@ -851,7 +851,7 @@ namespace etl template bool operator ==(const etl::ireference_flat_set& lhs, const etl::ireference_flat_set& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** diff --git a/include/etl/scaled_rounding.h b/include/etl/scaled_rounding.h index c2a27cdb..bef1d15a 100644 --- a/include/etl/scaled_rounding.h +++ b/include/etl/scaled_rounding.h @@ -41,7 +41,7 @@ namespace etl template struct scaled_rounding_t { - typedef typename etlstd::conditional::value, int32_t, uint32_t>::type type; + typedef typename etl::conditional::value, int32_t, uint32_t>::type type; }; //***************************************************************************** @@ -67,7 +67,7 @@ namespace etl template T round_ceiling_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); typedef typename scaled_rounding_t::type scale_t; if (value >= 0) @@ -101,7 +101,7 @@ namespace etl template T round_floor_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); typedef typename scaled_rounding_t::type scale_t; if (value >= 0) @@ -136,7 +136,7 @@ namespace etl template T round_half_up_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); ETL_STATIC_ASSERT((((SCALING / 2U) * 2U) == SCALING), "Scaling must be divisible by 2"); typedef typename scaled_rounding_t::type scale_t; @@ -173,7 +173,7 @@ namespace etl template T round_half_down_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); ETL_STATIC_ASSERT((((SCALING / 2U) * 2U) == SCALING), "Scaling must be divisible by 2"); typedef typename scaled_rounding_t::type scale_t; @@ -209,7 +209,7 @@ namespace etl template T round_zero_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); typedef typename scaled_rounding_t::type scale_t; return T(value / scale_t(SCALING)); @@ -236,7 +236,7 @@ namespace etl template T round_infinity_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); typedef typename scaled_rounding_t::type scale_t; if (value >= 0) @@ -271,7 +271,7 @@ namespace etl template T round_half_even_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); typedef typename scaled_rounding_t::type scale_t; // Half? @@ -316,7 +316,7 @@ namespace etl template T round_half_odd_unscaled(T value) { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); typedef typename scaled_rounding_t::type scale_t; // Half? diff --git a/include/etl/scheduler.h b/include/etl/scheduler.h index ade7fc20..3a6f9e85 100644 --- a/include/etl/scheduler.h +++ b/include/etl/scheduler.h @@ -285,7 +285,7 @@ namespace etl if (!task_list.full()) { - typename task_list_t::iterator itask = etlstd::upper_bound(task_list.begin(), + typename task_list_t::iterator itask = etl::upper_bound(task_list.begin(), task_list.end(), task.get_task_priority(), compare_priority()); diff --git a/include/etl/set.h b/include/etl/set.h index 566781c2..92b24109 100755 --- a/include/etl/set.h +++ b/include/etl/set.h @@ -457,7 +457,7 @@ namespace etl /// A templated base for all etl::set types. ///\ingroup set //*************************************************************************** - template > + template > class iset : public etl::set_base { public: @@ -761,7 +761,7 @@ namespace etl }; friend class const_iterator; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; @@ -913,7 +913,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(const value_type& value) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, value)), iterator(*this, find_upper_node(root_node, value))); } @@ -924,7 +924,7 @@ namespace etl //************************************************************************* ETL_OR_STD::pair equal_range(const value_type& value) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, value)), const_iterator(*this, find_upper_node(root_node, value))); } @@ -1031,7 +1031,7 @@ namespace etl inserted = inserted_node == &node; // Insert node into tree and return iterator to new node location in tree - return ETL_MAKE_PAIR(iterator(*this, inserted_node), inserted); + return ETL_OR_STD::make_pair(iterator(*this, inserted_node), inserted); } //********************************************************************* @@ -1950,7 +1950,7 @@ namespace etl //************************************************************************* /// A templated set implementation that uses a fixed size buffer. //************************************************************************* - template > + template > class set : public etl::iset { public: @@ -2037,7 +2037,7 @@ namespace etl template bool operator ==(const etl::iset& lhs, const etl::iset& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2063,7 +2063,7 @@ namespace etl template bool operator <(const etl::iset& lhs, const etl::iset& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/smallest.h b/include/etl/smallest.h index 0301376c..87a59af0 100644 --- a/include/etl/smallest.h +++ b/include/etl/smallest.h @@ -82,7 +82,7 @@ namespace etl // Set 'type' to be the smallest of the first parameter and any of the others. // This is recursive. - using type = typename etlstd::conditional<(etl::size_of::value < etl::size_of::value), // Boolean + using type = typename etl::conditional<(etl::size_of::value < etl::size_of::value), // Boolean T1, // TrueType smallest_other> // FalseType ::type; // The smallest type of the two. diff --git a/include/etl/smallest_generator.h b/include/etl/smallest_generator.h index 54142e44..6290b65d 100644 --- a/include/etl/smallest_generator.h +++ b/include/etl/smallest_generator.h @@ -94,7 +94,7 @@ namespace etl // Set 'type' to be the smallest of the first parameter and any of the others. // This is recursive. - using type = typename etlstd::conditional<(etl::size_of::value < etl::size_of::value), // Boolean + using type = typename etl::conditional<(etl::size_of::value < etl::size_of::value), // Boolean T1, // TrueType smallest_other> // FalseType ::type; // The smallest type of the two. diff --git a/include/etl/sqrt.h b/include/etl/sqrt.h index d23da550..9fda08bf 100644 --- a/include/etl/sqrt.h +++ b/include/etl/sqrt.h @@ -45,7 +45,7 @@ namespace etl template struct sqrt { - typedef typename etlstd::conditional<((I * I) > VALUE), + typedef typename etl::conditional<((I * I) > VALUE), etl::constant, etl::sqrt >::type type; diff --git a/include/etl/stack.h b/include/etl/stack.h index 84c99360..a12618c1 100644 --- a/include/etl/stack.h +++ b/include/etl/stack.h @@ -278,7 +278,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(stack_full)); #endif base_t::add_in(); - ::new (&p_buffer[top_index]) T(etlstd::forward(args)...); + ::new (&p_buffer[top_index]) T(etl::forward(args)...); } #else //************************************************************************* @@ -408,7 +408,7 @@ namespace etl //************************************************************************* void reverse() { - etlstd::reverse(p_buffer, p_buffer + current_size); + etl::reverse(p_buffer, p_buffer + current_size); } //************************************************************************* @@ -527,7 +527,7 @@ namespace etl private: /// The unintitialised buffer of T used in the stack. - typename etl::aligned_storage::value>::type buffer[SIZE]; + typename etl::aligned_storage::value>::type buffer[SIZE]; }; } diff --git a/include/etl/state_chart.h b/include/etl/state_chart.h index 09aebb4c..449e5aa0 100644 --- a/include/etl/state_chart.h +++ b/include/etl/state_chart.h @@ -235,7 +235,7 @@ namespace etl } else { - return etlstd::find_if(state_table.begin(), + return etl::find_if(state_table.begin(), state_table.end(), is_state(state_id)); } @@ -280,7 +280,7 @@ namespace etl while (t != transition_table.end()) { // Scan the transition table from the latest position. - t = etlstd::find_if(t, + t = etl::find_if(t, transition_table.end(), is_transition(event_id, current_state_id)); diff --git a/include/etl/string_view.h b/include/etl/string_view.h index 40acb1b6..5a690632 100644 --- a/include/etl/string_view.h +++ b/include/etl/string_view.h @@ -155,7 +155,7 @@ namespace etl //************************************************************************* /// Construct from iterator/size. //************************************************************************* - template ::value, void>::type> + template ::value, void>::type> ETL_CONSTEXPR17 basic_string_view(const T* begin_, TSize size_) : mbegin(begin_), mend(begin_ + size_) @@ -309,11 +309,11 @@ namespace etl /// Assign from iterators //************************************************************************* template ::value, void>::type> + typename TDummy = typename etl::enable_if::value, void>::type> void assign(TIterator begin_, TIterator end_) { mbegin = etl::addressof(*begin_); - mend = etl::addressof(*begin_) + etlstd::distance(begin_, end_); + mend = etl::addressof(*begin_) + etl::distance(begin_, end_); } //************************************************************************* @@ -321,7 +321,7 @@ namespace etl //************************************************************************* template ::value, void>::type> + typename TDummy = typename etl::enable_if::value, void>::type> void assign(TIterator begin_, TSize size_) { mbegin = etl::addressof(*begin_); @@ -351,11 +351,7 @@ namespace etl //************************************************************************* void swap(basic_string_view& other) { -#if defined(ETL_NO_STL) - using etlstd::swap; -#else - using std::swap; -#endif + using ETL_OR_STD::swap; // Allow ADL swap(mbegin, other.mbegin); swap(mend, other.mend); @@ -370,9 +366,9 @@ namespace etl if (position < size()) { - n = etlstd::min(count, size() - position); + n = etl::min(count, size() - position); - etlstd::copy(mbegin + position, mbegin + position + n, destination); + etl::copy(mbegin + position, mbegin + position + n, destination); } return n; @@ -387,7 +383,7 @@ namespace etl if (position < size()) { - size_t n = etlstd::min(count, size() - position); + size_t n = etl::min(count, size() - position); view = basic_string_view(mbegin + position, mbegin + position + n); } @@ -501,7 +497,7 @@ namespace etl return npos; } - const_iterator iposition = etlstd::search(begin() + position, end(), view.begin(), view.end()); + const_iterator iposition = etl::search(begin() + position, end(), view.begin(), view.end()); if (iposition == end()) { @@ -509,7 +505,7 @@ namespace etl } else { - return etlstd::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -538,9 +534,9 @@ namespace etl return npos; } - position = etlstd::min(position, size()); + position = etl::min(position, size()); - const_iterator iposition = etlstd::find_end(begin(), + const_iterator iposition = etl::find_end(begin(), begin() + position, view.begin(), view.end()); @@ -551,7 +547,7 @@ namespace etl } else { - return etlstd::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -621,7 +617,7 @@ namespace etl return npos; } - position = etlstd::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -717,7 +713,7 @@ namespace etl return npos; } - position = etlstd::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -768,7 +764,7 @@ namespace etl friend bool operator == (const etl::basic_string_view& lhs, const etl::basic_string_view& rhs) { return (lhs.size() == rhs.size()) && - etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -784,7 +780,7 @@ namespace etl //************************************************************************* friend bool operator < (const etl::basic_string_view& lhs, const etl::basic_string_view& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/type_lookup.h b/include/etl/type_lookup.h index 4a583a24..4d5b780b 100644 --- a/include/etl/type_lookup.h +++ b/include/etl/type_lookup.h @@ -101,28 +101,28 @@ namespace etl struct type_from_id { typedef - typename etlstd::conditional >::type>::type>::type>::type> ::type>::type>::type>::type> ::type>::type>::type>::type> ::type>::type>::type>::type type; - ETL_STATIC_ASSERT(!(etlstd::is_same, type>::value), "Invalid id"); + ETL_STATIC_ASSERT(!(etl::is_same, type>::value), "Invalid id"); }; //************************************ @@ -137,22 +137,22 @@ namespace etl enum { value = - (unsigned int) etlstd::is_same::value ? T1::ID : - (unsigned int) etlstd::is_same::value ? T2::ID : - (unsigned int) etlstd::is_same::value ? T3::ID : - (unsigned int) etlstd::is_same::value ? T4::ID : - (unsigned int) etlstd::is_same::value ? T5::ID : - (unsigned int) etlstd::is_same::value ? T6::ID : - (unsigned int) etlstd::is_same::value ? T7::ID : - (unsigned int) etlstd::is_same::value ? T8::ID : - (unsigned int) etlstd::is_same::value ? T9::ID : - (unsigned int) etlstd::is_same::value ? T10::ID : - (unsigned int) etlstd::is_same::value ? T11::ID : - (unsigned int) etlstd::is_same::value ? T12::ID : - (unsigned int) etlstd::is_same::value ? T13::ID : - (unsigned int) etlstd::is_same::value ? T14::ID : - (unsigned int) etlstd::is_same::value ? T15::ID : - (unsigned int) etlstd::is_same::value ? T16::ID : + (unsigned int) etl::is_same::value ? T1::ID : + (unsigned int) etl::is_same::value ? T2::ID : + (unsigned int) etl::is_same::value ? T3::ID : + (unsigned int) etl::is_same::value ? T4::ID : + (unsigned int) etl::is_same::value ? T5::ID : + (unsigned int) etl::is_same::value ? T6::ID : + (unsigned int) etl::is_same::value ? T7::ID : + (unsigned int) etl::is_same::value ? T8::ID : + (unsigned int) etl::is_same::value ? T9::ID : + (unsigned int) etl::is_same::value ? T10::ID : + (unsigned int) etl::is_same::value ? T11::ID : + (unsigned int) etl::is_same::value ? T12::ID : + (unsigned int) etl::is_same::value ? T13::ID : + (unsigned int) etl::is_same::value ? T14::ID : + (unsigned int) etl::is_same::value ? T15::ID : + (unsigned int) etl::is_same::value ? T16::ID : (unsigned int) UNKNOWN }; @@ -202,26 +202,26 @@ namespace etl struct type_from_type { typedef - typename etlstd::conditional::value, typename T1::type2, - typename etlstd::conditional::value, typename T2::type2, - typename etlstd::conditional::value, typename T3::type2, - typename etlstd::conditional::value, typename T4::type2, - typename etlstd::conditional::value, typename T5::type2, - typename etlstd::conditional::value, typename T6::type2, - typename etlstd::conditional::value, typename T7::type2, - typename etlstd::conditional::value, typename T8::type2, - typename etlstd::conditional::value, typename T9::type2, - typename etlstd::conditional::value, typename T10::type2, - typename etlstd::conditional::value, typename T11::type2, - typename etlstd::conditional::value, typename T12::type2, - typename etlstd::conditional::value, typename T13::type2, - typename etlstd::conditional::value, typename T14::type2, - typename etlstd::conditional::value, typename T15::type2, - typename etlstd::conditional::value, typename T16::type2, + typename etl::conditional::value, typename T1::type2, + typename etl::conditional::value, typename T2::type2, + typename etl::conditional::value, typename T3::type2, + typename etl::conditional::value, typename T4::type2, + typename etl::conditional::value, typename T5::type2, + typename etl::conditional::value, typename T6::type2, + typename etl::conditional::value, typename T7::type2, + typename etl::conditional::value, typename T8::type2, + typename etl::conditional::value, typename T9::type2, + typename etl::conditional::value, typename T10::type2, + typename etl::conditional::value, typename T11::type2, + typename etl::conditional::value, typename T12::type2, + typename etl::conditional::value, typename T13::type2, + typename etl::conditional::value, typename T14::type2, + typename etl::conditional::value, typename T15::type2, + typename etl::conditional::value, typename T16::type2, etl::null_type<0> >::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type>::type>::type>::type>::type>::type type; - ETL_STATIC_ASSERT(!(etlstd::is_same, type>::value), "Invalid type"); + ETL_STATIC_ASSERT(!(etl::is_same, type>::value), "Invalid type"); }; }; } diff --git a/include/etl/type_lookup_generator.h b/include/etl/type_lookup_generator.h index 8a814ca5..1e5a785f 100644 --- a/include/etl/type_lookup_generator.h +++ b/include/etl/type_lookup_generator.h @@ -104,7 +104,7 @@ namespace etl cog.outl(" {") cog.outl(" typedef ") for n in range(1, int(NTypes) + 1): - cog.outl(" typename etlstd::conditional >") for n in range(1, int(NTypes) + 1): if n == int(NTypes): @@ -116,7 +116,7 @@ namespace etl cog.outl("") cog.out(" ") cog.outl("") - cog.outl(" ETL_STATIC_ASSERT(!(etlstd::is_same, type>::value), \"Invalid id\");") + cog.outl(" ETL_STATIC_ASSERT(!(etl::is_same, type>::value), \"Invalid id\");") cog.outl(" };") cog.outl("") cog.outl(" //************************************") @@ -132,7 +132,7 @@ namespace etl cog.outl(" {") cog.outl(" value =") for n in range(1, int(NTypes) + 1) : - cog.outl(" (unsigned int) etlstd::is_same::value ? T%s::ID :" % (n, n)) + cog.outl(" (unsigned int) etl::is_same::value ? T%s::ID :" % (n, n)) cog.outl(" (unsigned int) UNKNOWN") cog.outl(" };") cog.outl("") @@ -171,7 +171,7 @@ namespace etl cog.outl(" {") cog.outl(" typedef ") for n in range(1, int(NTypes) + 1): - cog.outl(" typename etlstd::conditional::value, typename T%s::type2," %(n, n)) + cog.outl(" typename etl::conditional::value, typename T%s::type2," %(n, n)) cog.out(" etl::null_type<0> >") for n in range(1, int(NTypes) + 1): if n == int(NTypes): @@ -183,7 +183,7 @@ namespace etl cog.outl("") cog.out(" ") cog.outl("") - cog.outl(" ETL_STATIC_ASSERT(!(etlstd::is_same, type>::value), \"Invalid type\");") + cog.outl(" ETL_STATIC_ASSERT(!(etl::is_same, type>::value), \"Invalid type\");") cog.outl(" };") cog.outl("};") ]]]*/ diff --git a/include/etl/type_select.h b/include/etl/type_select.h index 94b70004..894b642d 100644 --- a/include/etl/type_select.h +++ b/include/etl/type_select.h @@ -73,22 +73,22 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type>::type>::type>::type>::type>::type type; @@ -121,21 +121,21 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type>::type>::type>::type>::type type; @@ -167,20 +167,20 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type>::type>::type>::type type; @@ -211,19 +211,19 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type>::type>::type type; @@ -253,18 +253,18 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type>::type type; @@ -293,17 +293,17 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type type; @@ -331,16 +331,16 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type type; @@ -367,15 +367,15 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type type; @@ -401,14 +401,14 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type>::type type; @@ -432,13 +432,13 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type>::type type; @@ -461,12 +461,12 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type>::type type; @@ -488,11 +488,11 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type>::type type; @@ -513,10 +513,10 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type>::type type; @@ -536,9 +536,9 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type>::type type; @@ -557,8 +557,8 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type>::type type; @@ -576,7 +576,7 @@ namespace etl template struct select { - typedef typename etlstd::conditional > ::type type; diff --git a/include/etl/type_select_generator.h b/include/etl/type_select_generator.h index 7b3f1fc2..70880f9c 100644 --- a/include/etl/type_select_generator.h +++ b/include/etl/type_select_generator.h @@ -75,9 +75,9 @@ namespace etl cog.outl(" template ") cog.outl(" struct select") cog.outl(" {") - cog.outl(" typedef typename etlstd::conditional >") cog.out(" ") for n in range(1, int(NTypes)) : @@ -110,9 +110,9 @@ namespace etl cog.outl(" template ") cog.outl(" struct select") cog.outl(" {") - cog.outl(" typedef typename etlstd::conditional >") cog.out(" ") for n in range(1, s) : diff --git a/include/etl/type_traits.h b/include/etl/type_traits.h index d4dac3c6..617b2f75 100644 --- a/include/etl/type_traits.h +++ b/include/etl/type_traits.h @@ -65,13 +65,17 @@ SOFTWARE. /// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined. /// \ingroup utilities -#if defined(ETL_NO_STL) +#if !defined(ETL_NO_STL) && ETL_CPP11_SUPPORTED + #include +#endif -//***************************************************************************** -// Traits are defined by the ETL -//***************************************************************************** -namespace etlstd +namespace etl { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //***************************************************************************** + // Traits are defined by the ETL + //***************************************************************************** //*************************************************************************** /// integral_constant template @@ -92,6 +96,9 @@ namespace etlstd typedef integral_constant false_type; typedef integral_constant true_type; + template + const T integral_constant::value; + #if ETL_CPP17_SUPPORTED template using bool_constant = integral_constant; @@ -248,7 +255,7 @@ namespace etlstd /// is_signed template struct is_signed : false_type {}; template <> struct is_signed : integral_constant {}; - template <> struct is_signed : public etlstd::integral_constant(wchar_t(-1) < wchar_t(0))> {}; + template <> struct is_signed : public etl::integral_constant(wchar_t(-1) < wchar_t(0))> {}; template <> struct is_signed : true_type {}; template <> struct is_signed : true_type {}; template <> struct is_signed : true_type {}; @@ -272,7 +279,7 @@ namespace etlstd template <> struct is_unsigned : true_type {}; template <> struct is_unsigned : integral_constant 0)> {}; template <> struct is_unsigned : true_type {}; - template <> struct is_unsigned : public etlstd::integral_constant wchar_t(0))> {}; + template <> struct is_unsigned : public etl::integral_constant wchar_t(0))> {}; template <> struct is_unsigned : true_type {}; template <> struct is_unsigned : true_type {}; template <> struct is_unsigned : true_type {}; @@ -391,7 +398,7 @@ namespace etlstd #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_lvalue_reference_v = etlstd::is_lvalue_reference::value; + inline constexpr bool is_lvalue_reference_v = etl::is_lvalue_reference::value; #endif //*************************************************************************** @@ -402,67 +409,67 @@ namespace etlstd #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_rvalue_reference_v = etlstd::is_rvalue_reference::value; + inline constexpr bool is_rvalue_reference_v = etl::is_rvalue_reference::value; #endif //*************************************************************************** /// is_pod /// Only fundamental and pointers types are recognised. - template struct is_pod : etlstd::integral_constant::value || etlstd::is_pointer::value> {}; + template struct is_pod : etl::integral_constant::value || etl::is_pointer::value> {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_pod_v = etlstd::is_pod::value; + inline constexpr bool is_pod_v = etl::is_pod::value; #endif //*************************************************************************** /// is_trivially_constructible /// Only POD types are recognised. - template struct is_trivially_constructible : etlstd::is_pod {}; + template struct is_trivially_constructible : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_constructible_v = etlstd::is_trivially_constructible::value; + inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible::value; #endif //*************************************************************************** /// is_trivially_copy_constructible /// Only POD types are recognised. - template struct is_trivially_copy_constructible : etlstd::is_pod {}; + template struct is_trivially_copy_constructible : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copy_constructible_v = etlstd::is_trivially_copy_constructible::value; + inline constexpr bool is_trivially_copy_constructible_v = etl::is_trivially_copy_constructible::value; #endif //*************************************************************************** /// is_trivially_destructible /// Only POD types are recognised. - template struct is_trivially_destructible : etlstd::is_pod {}; + template struct is_trivially_destructible : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_destructible_v = etlstd::is_trivially_destructible::value; + inline constexpr bool is_trivially_destructible_v = etl::is_trivially_destructible::value; #endif //*************************************************************************** /// is_trivially_copy_assignable /// Only POD types are recognised. - template struct is_trivially_copy_assignable : etlstd::is_pod {}; + template struct is_trivially_copy_assignable : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copy_assignable_v = etlstd::is_trivially_copy_assignable::value; + inline constexpr bool is_trivially_copy_assignable_v = etl::is_trivially_copy_assignable::value; #endif //*************************************************************************** /// is_trivially_copyable /// Only POD types are recognised. - template struct is_trivially_copyable : etlstd::is_pod {}; + template struct is_trivially_copyable : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copyable_v = etlstd::is_trivially_copyable::value; + inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable::value; #endif //*************************************************************************** @@ -478,9 +485,9 @@ namespace etlstd template <> struct make_signed { - typedef etlstd::conditional::type>::type type; }; @@ -507,9 +514,9 @@ namespace etlstd template <> struct make_unsigned { - typedef etlstd::conditional::type>::type type; }; @@ -596,10 +603,10 @@ namespace etlstd template struct decay { - typedef typename etlstd::remove_reference::type U; - typedef typename etlstd::conditional::value, - typename etlstd::remove_extent::type*, - typename etlstd::remove_cv::type>::type type; + typedef typename etl::remove_reference::type U; + typedef typename etl::conditional::value, + typename etl::remove_extent::type*, + typename etl::remove_cv::type>::type type; }; #if ETL_CPP14_SUPPORTED @@ -611,7 +618,7 @@ namespace etlstd /// is_base_of template::value || etlstd::is_fundamental::value)> + const bool IsFundamental = (etl::is_fundamental::value || etl::is_fundamental::value)> struct is_base_of { private: @@ -650,7 +657,7 @@ namespace etlstd #if ETL_CPP14_SUPPORTED template - using add_lvalue_reference_t = typename etlstd::add_lvalue_reference::type; + using add_lvalue_reference_t = typename etl::add_lvalue_reference::type; #endif //*************************************************************************** @@ -666,14 +673,14 @@ namespace etlstd #if ETL_CPP14_SUPPORTED template - using add_rvalue_reference_t = typename etlstd::add_rvalue_reference::type; + using add_rvalue_reference_t = typename etl::add_rvalue_reference::type; #endif //*************************************************************************** /// decval #if ETL_CPP11_SUPPORTED template - typename etlstd::add_rvalue_reference::type declval() ETL_NOEXCEPT; + typename etl::add_rvalue_reference::type declval() ETL_NOEXCEPT; #endif //*************************************************************************** @@ -682,30 +689,30 @@ namespace etlstd namespace private_type_traits { template - using true_type_for = etlstd::true_type; + using true_type_for = etl::true_type; template auto returnable(int)->true_type_for; template - auto returnable(...)->etlstd::false_type; + auto returnable(...)->etl::false_type; template - auto nonvoid_convertible(int)->true_type_for()(etlstd::declval())) + auto nonvoid_convertible(int)->true_type_for()(etl::declval())) >; template - auto nonvoid_convertible(...)->etlstd::false_type; + auto nonvoid_convertible(...)->etl::false_type; } template - struct is_convertible : etlstd::integral_constant(0))::value && - decltype(private_type_traits::nonvoid_convertible(0))::value) || - (etlstd::is_void::value && etlstd::is_void::value)> {}; + struct is_convertible : etl::integral_constant(0))::value && + decltype(private_type_traits::nonvoid_convertible(0))::value) || + (etl::is_void::value && etl::is_void::value)> {}; #endif #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_convertible_v = etlstd::is_convertible::value; + inline constexpr bool is_convertible_v = etl::is_convertible::value; #endif //*************************************************************************** @@ -725,19 +732,15 @@ namespace etlstd #if ETL_CPP17_SUPPORTED template - inline constexpr size_t alignment_of_v = etlstd::alignment_of::value; + inline constexpr size_t alignment_of_v = etl::alignment_of::value; #endif -} -#else +#else // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED -//***************************************************************************** -// Traits are derived from the STL -//***************************************************************************** -#include + //***************************************************************************** + // Traits are derived from the STL + //***************************************************************************** -namespace etlstd -{ //*************************************************************************** /// integral_constant ///\ingroup type_traits @@ -751,7 +754,7 @@ namespace etlstd #if ETL_CPP17_SUPPORTED template - using bool_constant = std::integral_constant; + using bool_constant = std::bool_constant; #endif //*************************************************************************** @@ -1017,105 +1020,105 @@ namespace etlstd #endif #if !defined(ARDUINO) && !defined(ETL_STLPORT) + //*************************************************************************** + /// is_trivially_constructible + ///\ingroup type_traits + template struct is_trivially_constructible : std::is_trivially_constructible {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = std::is_trivially_constructible_v; +#endif + + //*************************************************************************** + /// is_trivially_copy_constructible + ///\ingroup type_traits + template struct is_trivially_copy_constructible : std::is_trivially_copy_constructible {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_constructible_v = std::is_trivially_copy_constructible_v; +#endif + + //*************************************************************************** + /// is_trivially_destructible + ///\ingroup type_traits + template struct is_trivially_destructible : std::is_trivially_destructible {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_destructible_v = std::is_trivially_destructible_v; +#endif + + //*************************************************************************** + /// is_trivially_copy_assignable + ///\ingroup type_traits + template struct is_trivially_copy_assignable : std::is_trivially_copy_assignable {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_assignable_v = std::is_trivially_copy_assignable_v; +#endif + + //*************************************************************************** + /// is_trivially_copyable + ///\ingroup type_traits + template struct is_trivially_copyable : std::is_trivially_copyable {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = std::is_trivially_copyable_v; +#endif +#else //*************************************************************************** /// is_trivially_constructible ///\ingroup type_traits - template struct is_trivially_constructible : std::is_trivially_constructible {}; + template struct is_trivially_constructible : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_constructible_v = std::is_trivially_constructible_v; + inline constexpr bool is_trivially_constructible_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_copy_constructible ///\ingroup type_traits - template struct is_trivially_copy_constructible : std::is_trivially_copy_constructible {}; + template struct is_trivially_copy_constructible : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copy_constructible_v = std::is_trivially_copy_constructible_v; + inline constexpr bool is_trivially_copy_constructible_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_destructible ///\ingroup type_traits - template struct is_trivially_destructible : std::is_trivially_destructible {}; + template struct is_trivially_destructible : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_destructible_v = std::is_trivially_destructible_v; + inline constexpr bool is_trivially_destructible_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_copy_assignable ///\ingroup type_traits - template struct is_trivially_copy_assignable : std::is_trivially_copy_assignable {}; + template struct is_trivially_copy_assignable : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copy_assignable_v = std::is_trivially_copy_assignable_v; + inline constexpr bool is_trivially_copy_assignable_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_copyable ///\ingroup type_traits - template struct is_trivially_copyable : std::is_trivially_copyable {}; + template struct is_trivially_copyable : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copyable_v = std::is_trivially_copyable_v; + inline constexpr bool is_trivially_copyable_v = std::is_pod_v; #endif -#else - // //*************************************************************************** - // /// is_trivially_constructible - // ///\ingroup type_traits - // template struct is_trivially_constructible : etlstd::is_trivially_constructible {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_constructible_v = typename etlstd::::is_trivially_constructible_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_copy_constructible - // ///\ingroup type_traits - // template struct is_trivially_copy_constructible : etlstd::::is_trivially_copy_constructible {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_copy_constructible_v = typename etlstd::::is_trivially_copy_constructible_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_destructible - // ///\ingroup type_traits - // template struct is_trivially_destructible : etlstd::::is_trivially_destructible {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_destructible_v = typename etlstd::::is_trivially_destructible_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_copy_assignable - // ///\ingroup type_traits - // template struct is_trivially_copy_assignable : etlstd::::is_trivially_copy_assignable {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_copy_assignable_v = typename etlstd::::is_trivially_copy_assignable_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_copyable - // ///\ingroup type_traits - // template struct is_trivially_copyable : etlstd::::is_trivially_copyable {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_copyable_v = typename etlstd::::is_trivially_copyable_v; - //#endif #endif //*************************************************************************** @@ -1265,14 +1268,13 @@ namespace etlstd template inline constexpr size_t alignment_of_v = std::alignment_of_v; #endif -} -#endif -//*************************************************************************** -// ETL specific type traits. -//*************************************************************************** -namespace etl -{ +#endif // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //*************************************************************************** + // ETL extended type traits. + //*************************************************************************** + //*************************************************************************** /// conditional_integral_constant // /\ingroup type_traits @@ -1282,14 +1284,14 @@ namespace etl template struct conditional_integral_constant { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); static const T value = TRUE_VALUE; }; template struct conditional_integral_constant { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); static const T value = FALSE_VALUE; }; @@ -1301,18 +1303,16 @@ namespace etl template struct is_one_of { - static const bool value = etlstd::is_same::value || - etl::is_one_of::value; + static const bool value = etl::is_same::value || + etl::is_one_of::value; }; template struct is_one_of { - static const bool value = etlstd::is_same::value; + static const bool value = etl::is_same::value; }; - #else - //*************************************************************************** /// Template to determine if a type is one of a specified list. ///\ingroup types @@ -1320,8 +1320,7 @@ namespace etl typename T1, typename T2 = void, typename T3 = void, typename T4 = void, typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void, typename T9 = void, typename T10 = void, typename T11 = void, typename T12 = void, - typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void, - typename T17 = void> + typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void> struct is_one_of { static const bool value = @@ -1340,10 +1339,8 @@ namespace etl etlstd::is_same::value || etlstd::is_same::value || etlstd::is_same::value || - etlstd::is_same::value || - etlstd::is_same::value; + etlstd::is_same::value; }; - #endif #if ETL_CPP17_SUPPORTED @@ -1361,7 +1358,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1379,7 +1376,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1397,7 +1394,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1415,7 +1412,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1434,7 +1431,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1470,8 +1467,8 @@ namespace etl //*************************************************************************** /// size_of ///\ingroup types - template struct size_of : etlstd::integral_constant {}; - template <> struct size_of : etlstd::integral_constant {}; + template struct size_of : etl::integral_constant {}; + template <> struct size_of : etl::integral_constant {}; #if ETL_CPP17_SUPPORTED template @@ -1479,5 +1476,4 @@ namespace etl #endif } - -#endif +#endif // ETL_TYPE_TRAITS_INCLUDED diff --git a/include/etl/type_traits_generator.h b/include/etl/type_traits_generator.h index 1da6f67a..78a42254 100644 --- a/include/etl/type_traits_generator.h +++ b/include/etl/type_traits_generator.h @@ -77,13 +77,17 @@ cog.outl("//******************************************************************** /// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined. /// \ingroup utilities -#if defined(ETL_NO_STL) +#if !defined(ETL_NO_STL) && ETL_CPP11_SUPPORTED + #include +#endif -//***************************************************************************** -// Traits are defined by the ETL -//***************************************************************************** -namespace etlstd +namespace etl { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //***************************************************************************** + // Traits are defined by the ETL + //***************************************************************************** //*************************************************************************** /// integral_constant template @@ -104,6 +108,9 @@ namespace etlstd typedef integral_constant false_type; typedef integral_constant true_type; + template + const T integral_constant::value; + #if ETL_CPP17_SUPPORTED template using bool_constant = integral_constant; @@ -420,27 +427,27 @@ namespace etlstd //*************************************************************************** /// is_pod /// Only fundamental and pointers types are recognised. - template struct is_pod : etl::integral_constant::value || etlstd::is_pointer::value> {}; + template struct is_pod : etl::integral_constant::value || etl::is_pointer::value> {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_pod_v = etlstd::is_pod::value; + inline constexpr bool is_pod_v = etl::is_pod::value; #endif //*************************************************************************** /// is_trivially_constructible /// Only POD types are recognised. - template struct is_trivially_constructible : etlstd::is_pod {}; + template struct is_trivially_constructible : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_constructible_v = etlstd::is_trivially_constructible::value; + inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible::value; #endif //*************************************************************************** /// is_trivially_copy_constructible /// Only POD types are recognised. - template struct is_trivially_copy_constructible : etlstd::is_pod {}; + template struct is_trivially_copy_constructible : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template @@ -450,7 +457,7 @@ namespace etlstd //*************************************************************************** /// is_trivially_destructible /// Only POD types are recognised. - template struct is_trivially_destructible : etlstd::is_pod {}; + template struct is_trivially_destructible : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template @@ -460,7 +467,7 @@ namespace etlstd //*************************************************************************** /// is_trivially_copy_assignable /// Only POD types are recognised. - template struct is_trivially_copy_assignable : etlstd::is_pod {}; + template struct is_trivially_copy_assignable : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template @@ -470,7 +477,7 @@ namespace etlstd //*************************************************************************** /// is_trivially_copyable /// Only POD types are recognised. - template struct is_trivially_copyable : etlstd::is_pod {}; + template struct is_trivially_copyable : etl::is_pod {}; #if ETL_CPP17_SUPPORTED template @@ -490,9 +497,9 @@ namespace etlstd template <> struct make_signed { - typedef etlstd::conditional::type>::type type; }; @@ -519,9 +526,9 @@ namespace etlstd template <> struct make_unsigned { - typedef etlstd::conditional::type>::type type; }; @@ -608,10 +615,10 @@ namespace etlstd template struct decay { - typedef typename etlstd::remove_reference::type U; - typedef typename etlstd::conditional::value, - typename etlstd::remove_extent::type*, - typename etlstd::remove_cv::type>::type type; + typedef typename etl::remove_reference::type U; + typedef typename etl::conditional::value, + typename etl::remove_extent::type*, + typename etl::remove_cv::type>::type type; }; #if ETL_CPP14_SUPPORTED @@ -623,7 +630,7 @@ namespace etlstd /// is_base_of template::value || etlstd::is_fundamental::value)> + const bool IsFundamental = (etl::is_fundamental::value || etl::is_fundamental::value)> struct is_base_of { private: @@ -662,7 +669,7 @@ namespace etlstd #if ETL_CPP14_SUPPORTED template - using add_lvalue_reference_t = typename etlstd::add_lvalue_reference::type; + using add_lvalue_reference_t = typename etl::add_lvalue_reference::type; #endif //*************************************************************************** @@ -678,14 +685,14 @@ namespace etlstd #if ETL_CPP14_SUPPORTED template - using add_rvalue_reference_t = typename etlstd::add_rvalue_reference::type; + using add_rvalue_reference_t = typename etl::add_rvalue_reference::type; #endif //*************************************************************************** /// decval #if ETL_CPP11_SUPPORTED template - typename etlstd::add_rvalue_reference::type declval() ETL_NOEXCEPT; + typename etl::add_rvalue_reference::type declval() ETL_NOEXCEPT; #endif //*************************************************************************** @@ -694,30 +701,30 @@ namespace etlstd namespace private_type_traits { template - using true_type_for = etlstd::true_type; + using true_type_for = etl::true_type; template auto returnable(int)->true_type_for; template - auto returnable(...)->etlstd::false_type; + auto returnable(...)->etl::false_type; template auto nonvoid_convertible(int)->true_type_for()(etl::declval())) >; template - auto nonvoid_convertible(...)->etlstd::false_type; + auto nonvoid_convertible(...)->etl::false_type; } template struct is_convertible : etl::integral_constant(0))::value && - decltype(private_type_traits::nonvoid_convertible(0))::value) || - (etl::is_void::value && etl::is_void::value)> {}; + decltype(private_type_traits::nonvoid_convertible(0))::value) || + (etl::is_void::value && etl::is_void::value)> {}; #endif #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_convertible_v = etlstd::is_convertible::value; + inline constexpr bool is_convertible_v = etl::is_convertible::value; #endif //*************************************************************************** @@ -737,19 +744,15 @@ namespace etlstd #if ETL_CPP17_SUPPORTED template - inline constexpr size_t alignment_of_v = etlstd::alignment_of::value; + inline constexpr size_t alignment_of_v = etl::alignment_of::value; #endif -} -#else +#else // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED -//***************************************************************************** -// Traits are derived from the STL -//***************************************************************************** -#include + //***************************************************************************** + // Traits are derived from the STL + //***************************************************************************** -namespace etlstd -{ //*************************************************************************** /// integral_constant ///\ingroup type_traits @@ -763,7 +766,7 @@ namespace etlstd #if ETL_CPP17_SUPPORTED template - using bool_constant = std::integral_constant; + using bool_constant = std::bool_constant; #endif //*************************************************************************** @@ -1029,105 +1032,105 @@ namespace etlstd #endif #if !defined(ARDUINO) && !defined(ETL_STLPORT) + //*************************************************************************** + /// is_trivially_constructible + ///\ingroup type_traits + template struct is_trivially_constructible : std::is_trivially_constructible {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = std::is_trivially_constructible_v; +#endif + + //*************************************************************************** + /// is_trivially_copy_constructible + ///\ingroup type_traits + template struct is_trivially_copy_constructible : std::is_trivially_copy_constructible {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_constructible_v = std::is_trivially_copy_constructible_v; +#endif + + //*************************************************************************** + /// is_trivially_destructible + ///\ingroup type_traits + template struct is_trivially_destructible : std::is_trivially_destructible {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_destructible_v = std::is_trivially_destructible_v; +#endif + + //*************************************************************************** + /// is_trivially_copy_assignable + ///\ingroup type_traits + template struct is_trivially_copy_assignable : std::is_trivially_copy_assignable {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_assignable_v = std::is_trivially_copy_assignable_v; +#endif + + //*************************************************************************** + /// is_trivially_copyable + ///\ingroup type_traits + template struct is_trivially_copyable : std::is_trivially_copyable {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = std::is_trivially_copyable_v; +#endif +#else //*************************************************************************** /// is_trivially_constructible ///\ingroup type_traits - template struct is_trivially_constructible : std::is_trivially_constructible {}; + template struct is_trivially_constructible : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_constructible_v = std::is_trivially_constructible_v; + inline constexpr bool is_trivially_constructible_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_copy_constructible ///\ingroup type_traits - template struct is_trivially_copy_constructible : std::is_trivially_copy_constructible {}; + template struct is_trivially_copy_constructible : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copy_constructible_v = std::is_trivially_copy_constructible_v; + inline constexpr bool is_trivially_copy_constructible_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_destructible ///\ingroup type_traits - template struct is_trivially_destructible : std::is_trivially_destructible {}; + template struct is_trivially_destructible : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_destructible_v = std::is_trivially_destructible_v; + inline constexpr bool is_trivially_destructible_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_copy_assignable ///\ingroup type_traits - template struct is_trivially_copy_assignable : std::is_trivially_copy_assignable {}; + template struct is_trivially_copy_assignable : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copy_assignable_v = std::is_trivially_copy_assignable_v; + inline constexpr bool is_trivially_copy_assignable_v = std::is_pod_v; #endif //*************************************************************************** /// is_trivially_copyable ///\ingroup type_traits - template struct is_trivially_copyable : std::is_trivially_copyable {}; + template struct is_trivially_copyable : std::is_pod {}; #if ETL_CPP17_SUPPORTED template - inline constexpr bool is_trivially_copyable_v = std::is_trivially_copyable_v; + inline constexpr bool is_trivially_copyable_v = std::is_pod_v; #endif -#else - // //*************************************************************************** - // /// is_trivially_constructible - // ///\ingroup type_traits - // template struct is_trivially_constructible : etlstd::is_trivially_constructible {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_constructible_v = typename etl::::is_trivially_constructible_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_copy_constructible - // ///\ingroup type_traits - // template struct is_trivially_copy_constructible : etl::::is_trivially_copy_constructible {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_copy_constructible_v = typename etl::::is_trivially_copy_constructible_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_destructible - // ///\ingroup type_traits - // template struct is_trivially_destructible : etl::::is_trivially_destructible {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_destructible_v = typename etl::::is_trivially_destructible_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_copy_assignable - // ///\ingroup type_traits - // template struct is_trivially_copy_assignable : etl::::is_trivially_copy_assignable {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_copy_assignable_v = typename etl::::is_trivially_copy_assignable_v; - //#endif - - // //*************************************************************************** - // /// is_trivially_copyable - // ///\ingroup type_traits - // template struct is_trivially_copyable : etl::::is_trivially_copyable {}; - - //#if ETL_CPP17_SUPPORTED - // template - // inline constexpr bool is_trivially_copyable_v = typename etl::::is_trivially_copyable_v; - //#endif #endif //*************************************************************************** @@ -1277,14 +1280,13 @@ namespace etlstd template inline constexpr size_t alignment_of_v = std::alignment_of_v; #endif -} -#endif -//*************************************************************************** -// ETL specific type traits. -//*************************************************************************** -namespace etl -{ +#endif // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //*************************************************************************** + // ETL extended type traits. + //*************************************************************************** + //*************************************************************************** /// conditional_integral_constant // /\ingroup type_traits @@ -1294,14 +1296,14 @@ namespace etl template struct conditional_integral_constant { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); static const T value = TRUE_VALUE; }; template struct conditional_integral_constant { - ETL_STATIC_ASSERT(etlstd::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); static const T value = FALSE_VALUE; }; @@ -1313,18 +1315,16 @@ namespace etl template struct is_one_of { - static const bool value = etlstd::is_same::value || + static const bool value = etl::is_same::value || etl::is_one_of::value; }; template struct is_one_of { - static const bool value = etlstd::is_same::value; + static const bool value = etl::is_same::value; }; - #else - /*[[[cog import cog cog.outl("//***************************************************************************") @@ -1348,7 +1348,6 @@ namespace etl cog.outl("};") ]]]*/ /*[[[end]]]*/ - #endif #if ETL_CPP17_SUPPORTED @@ -1366,7 +1365,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1384,7 +1383,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1402,7 +1401,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1420,7 +1419,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1439,7 +1438,7 @@ namespace etl { private: - typedef typename etlstd::remove_cv::type type_t; + typedef typename etl::remove_cv::type type_t; public: @@ -1475,8 +1474,8 @@ namespace etl //*************************************************************************** /// size_of ///\ingroup types - template struct size_of : etlstd::integral_constant {}; - template <> struct size_of : etlstd::integral_constant {}; + template struct size_of : etl::integral_constant {}; + template <> struct size_of : etl::integral_constant {}; #if ETL_CPP17_SUPPORTED template @@ -1484,5 +1483,4 @@ namespace etl #endif } - -#endif +#endif // ETL_TYPE_TRAITS_INCLUDED diff --git a/include/etl/u16string.h b/include/etl/u16string.h index 4da9ff67..377d29e8 100644 --- a/include/etl/u16string.h +++ b/include/etl/u16string.h @@ -191,7 +191,7 @@ namespace etl { ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds)); - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/include/etl/u32string.h b/include/etl/u32string.h index 4606fe21..ee4ebabd 100644 --- a/include/etl/u32string.h +++ b/include/etl/u32string.h @@ -191,7 +191,7 @@ namespace etl { ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds)); - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/include/etl/unordered_map.h b/include/etl/unordered_map.h index eda2a631..c0a3bbf7 100644 --- a/include/etl/unordered_map.h +++ b/include/etl/unordered_map.h @@ -127,7 +127,7 @@ namespace etl /// Can be used as a reference type for all unordered_map containing a specific type. ///\ingroup unordered_map //*************************************************************************** - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class iunordered_map { public: @@ -482,7 +482,7 @@ namespace etl local_iterator inode; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_map. @@ -609,7 +609,7 @@ namespace etl { size_t index = bucket(key); - return etlstd::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -752,7 +752,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_map_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_map_full)); #endif @@ -1370,7 +1370,7 @@ namespace etl template bool operator ==(const etl::iunordered_map& lhs, const etl::iunordered_map& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1389,7 +1389,7 @@ namespace etl //************************************************************************* /// A templated unordered_map implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_map : public etl::iunordered_map { private: diff --git a/include/etl/unordered_multimap.h b/include/etl/unordered_multimap.h index 9f96a7a8..2e622058 100644 --- a/include/etl/unordered_multimap.h +++ b/include/etl/unordered_multimap.h @@ -127,7 +127,7 @@ namespace etl /// Can be used as a reference type for all unordered_multimap containing a specific type. ///\ingroup unordered_multimap //*************************************************************************** - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class iunordered_multimap { public: @@ -482,7 +482,7 @@ namespace etl local_iterator inode; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_multimap. @@ -609,7 +609,7 @@ namespace etl { size_t index = bucket(key); - return etlstd::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -641,7 +641,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_multimap_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_multimap_full)); #endif @@ -1279,7 +1279,7 @@ namespace etl template bool operator ==(const etl::iunordered_multimap& lhs, const etl::iunordered_multimap& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1298,7 +1298,7 @@ namespace etl //************************************************************************* /// A templated unordered_multimap implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_multimap : public etl::iunordered_multimap { private: diff --git a/include/etl/unordered_multiset.h b/include/etl/unordered_multiset.h index 2e03f02a..b8793407 100644 --- a/include/etl/unordered_multiset.h +++ b/include/etl/unordered_multiset.h @@ -126,7 +126,7 @@ namespace etl /// Can be used as a reference type for all unordered_multiset containing a specific type. ///\ingroup unordered_multiset //*************************************************************************** - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class iunordered_multiset { public: @@ -477,7 +477,7 @@ namespace etl local_iterator inode; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_multiset. @@ -604,7 +604,7 @@ namespace etl { size_t index = bucket(key); - return etlstd::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -636,7 +636,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_multiset_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_multiset_full)); #endif @@ -1274,7 +1274,7 @@ namespace etl template bool operator ==(const etl::iunordered_multiset& lhs, const etl::iunordered_multiset& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1293,7 +1293,7 @@ namespace etl //************************************************************************* /// A templated unordered_multiset implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_multiset : public etl::iunordered_multiset { private: diff --git a/include/etl/unordered_set.h b/include/etl/unordered_set.h index c16772de..9fbc3586 100644 --- a/include/etl/unordered_set.h +++ b/include/etl/unordered_set.h @@ -127,7 +127,7 @@ namespace etl /// Can be used as a reference type for all unordered_set containing a specific type. ///\ingroup unordered_set //*************************************************************************** - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class iunordered_set { public: @@ -169,7 +169,7 @@ namespace etl typedef typename bucket_t::const_iterator local_const_iterator; //********************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -328,7 +328,7 @@ namespace etl }; //********************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -478,7 +478,7 @@ namespace etl local_iterator inode; }; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_set. @@ -605,7 +605,7 @@ namespace etl { size_t index = bucket(key); - return etlstd::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -637,7 +637,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_set_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_set_full)); #endif @@ -1251,7 +1251,7 @@ namespace etl template bool operator ==(const etl::iunordered_set& lhs, const etl::iunordered_set& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1270,7 +1270,7 @@ namespace etl //************************************************************************* /// A templated unordered_set implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = etlstd::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_set : public etl::iunordered_set { private: diff --git a/include/etl/utility.h b/include/etl/utility.h index 6bec4c24..5f600f2f 100644 --- a/include/etl/utility.h +++ b/include/etl/utility.h @@ -41,7 +41,7 @@ SOFTWARE. ///\defgroup utility utility ///\ingroup utilities -namespace etlstd +namespace etl { //****************************************************************************** template @@ -144,20 +144,20 @@ namespace etlstd #if ETL_CPP11_SUPPORTED //****************************************************************************** template - constexpr typename etlstd::remove_reference::type&& move(T&& t) noexcept + constexpr typename etl::remove_reference::type&& move(T&& t) noexcept { - return static_cast::type&&>(t); + return static_cast::type&&>(t); } //****************************************************************************** template - constexpr T&& forward(typename etlstd::remove_reference::type& t) noexcept + constexpr T&& forward(typename etl::remove_reference::type& t) noexcept { return static_cast(t); } template - constexpr T&& forward(typename etlstd::remove_reference::type&& t) noexcept + constexpr T&& forward(typename etl::remove_reference::type&& t) noexcept { return static_cast(t); } @@ -189,7 +189,7 @@ namespace etlstd /// as_const //*************************************************************************** template - typename etlstd::add_const::type& as_const(T& t) + typename etl::add_const::type& as_const(T& t) { return t; } diff --git a/include/etl/variant.h b/include/etl/variant.h index 82f06e35..624c2310 100644 --- a/include/etl/variant.h +++ b/include/etl/variant.h @@ -164,14 +164,14 @@ namespace etl template struct Type_Id_Lookup { - static const uint_least8_t type_id = etlstd::is_same::value ? 0 : - etlstd::is_same::value ? 1 : - etlstd::is_same::value ? 2 : - etlstd::is_same::value ? 3 : - etlstd::is_same::value ? 4 : - etlstd::is_same::value ? 5 : - etlstd::is_same::value ? 6 : - etlstd::is_same::value ? 7 : + static const uint_least8_t type_id = etl::is_same::value ? 0 : + etl::is_same::value ? 1 : + etl::is_same::value ? 2 : + etl::is_same::value ? 3 : + etl::is_same::value ? 4 : + etl::is_same::value ? 5 : + etl::is_same::value ? 6 : + etl::is_same::value ? 7 : UNSUPPORTED_TYPE_ID; }; @@ -723,7 +723,7 @@ namespace etl ETL_STATIC_ASSERT(Type_Is_Supported::value, "Unsupported type"); destruct_current(); - ::new (static_cast(data)) T(etlstd::forward(args)...); + ::new (static_cast(data)) T(etl::forward(args)...); type_id = Type_Id_Lookup::type_id; return *static_cast(data); diff --git a/include/etl/variant_pool.h b/include/etl/variant_pool.h index ae53934f..48c34a62 100644 --- a/include/etl/variant_pool.h +++ b/include/etl/variant_pool.h @@ -290,7 +290,7 @@ namespace etl if (p != nullptr) { - new (p) T(etlstd::forward(args)...); + new (p) T(etl::forward(args)...); } } @@ -305,22 +305,22 @@ namespace etl bool destroy(const T* const p) { ETL_STATIC_ASSERT((etl::is_one_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value || - etlstd::is_base_of::value), "Invalid type"); + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value || + etl::is_base_of::value), "Invalid type"); p->~T(); diff --git a/include/etl/variant_pool_generator.h b/include/etl/variant_pool_generator.h index d6f785e3..a00f1748 100644 --- a/include/etl/variant_pool_generator.h +++ b/include/etl/variant_pool_generator.h @@ -382,8 +382,8 @@ namespace etl cog.outl("T%s>::value ||" % int(NTypes)) for n in range(1, int(NTypes)): - cog.outl(" etlstd::is_base_of::value ||" % n) - cog.outl(" etlstd::is_base_of::value), \"Invalid type\");" % int(NTypes)) + cog.outl(" etl::is_base_of::value ||" % n) + cog.outl(" etl::is_base_of::value), \"Invalid type\");" % int(NTypes)) ]]]*/ /*[[[end]]]*/ diff --git a/include/etl/vector.h b/include/etl/vector.h index 77d23d8a..03305767 100644 --- a/include/etl/vector.h +++ b/include/etl/vector.h @@ -95,7 +95,7 @@ namespace etl typedef ETL_OR_STD::reverse_iterator reverse_iterator; typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename etlstd::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; protected: @@ -365,17 +365,17 @@ namespace etl template void assign(TIterator first, TIterator last) { - ETL_STATIC_ASSERT((etlstd::is_same::type, typename etlstd::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); + ETL_STATIC_ASSERT((etl::is_same::type, typename etl::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); #if defined(ETL_DEBUG) - difference_type d = etlstd::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(static_cast(d) <= CAPACITY, ETL_ERROR(vector_full)); #endif initialise(); p_end = etl::uninitialized_copy(first, last, p_buffer); - ETL_ADD_DEBUG_COUNT(uint32_t(etlstd::distance(first, last))) + ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last))) } //********************************************************************* @@ -426,7 +426,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full)); #endif - create_back(etlstd::move(value)); + create_back(etl::move(value)); } #endif @@ -442,7 +442,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full)); #endif - ::new (p_end) T(etlstd::forward(args)...); + ::new (p_end) T(etl::forward(args)...); ++p_end; ETL_INCREMENT_DEBUG_COUNT } @@ -541,7 +541,7 @@ namespace etl else { create_back(back()); - etlstd::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); *position = value; } @@ -561,13 +561,13 @@ namespace etl if (position == end()) { - create_back(etlstd::move(value)); + create_back(etl::move(value)); } else { - create_back(etlstd::move(back())); - etlstd::move_backward(position, p_end - 2, p_end - 1); - *position = etlstd::move(value); + create_back(etl::move(back())); + etl::move_backward(position, p_end - 2, p_end - 1); + *position = etl::move(value); } return position; @@ -594,11 +594,11 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - etlstd::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } - ::new (p) T(etlstd::forward(args)...); + ::new (p) T(etl::forward(args)...); return position; } @@ -619,7 +619,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - etlstd::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -644,7 +644,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - etlstd::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -669,7 +669,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - etlstd::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -694,7 +694,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - etlstd::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -716,7 +716,7 @@ namespace etl ETL_ASSERT((size() + n) <= CAPACITY, ETL_ERROR(vector_full)); size_t insert_n = n; - size_t insert_begin = etlstd::distance(begin(), position); + size_t insert_begin = etl::distance(begin(), position); size_t insert_end = insert_begin + insert_n; // Copy old data. @@ -745,14 +745,14 @@ namespace etl ETL_ADD_DEBUG_COUNT(construct_old_n) // Copy old. - etlstd::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); + etl::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); // Construct new. etl::uninitialized_fill_n(p_end, construct_new_n, value); ETL_ADD_DEBUG_COUNT(construct_new_n) // Copy new. - etlstd::fill_n(p_buffer + insert_begin, copy_new_n, value); + etl::fill_n(p_buffer + insert_begin, copy_new_n, value); p_end += n; } @@ -768,12 +768,12 @@ namespace etl template void insert(iterator position, TIterator first, TIterator last) { - size_t count = etlstd::distance(first, last); + size_t count = etl::distance(first, last); ETL_ASSERT((size() + count) <= CAPACITY, ETL_ERROR(vector_full)); size_t insert_n = count; - size_t insert_begin = etlstd::distance(begin(), position); + size_t insert_begin = etl::distance(begin(), position); size_t insert_end = insert_begin + insert_n; // Copy old data. @@ -802,7 +802,7 @@ namespace etl ETL_ADD_DEBUG_COUNT(construct_old_n) // Copy old. - etlstd::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); + etl::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); // Construct new. etl::uninitialized_copy_n(first + copy_new_n, construct_new_n, p_end); @@ -821,7 +821,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - etlstd::copy(i_element + 1, end(), i_element); + etl::copy(i_element + 1, end(), i_element); destroy_back(); return i_element; @@ -843,8 +843,8 @@ namespace etl } else { - etlstd::copy(last, end(), first); - size_t n_delete = etlstd::distance(first, last); + etl::copy(last, end(), first); + size_t n_delete = etl::distance(first, last); // Destroy the elements left over at the end. etl::destroy(p_end - n_delete, p_end); @@ -880,7 +880,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(etlstd::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -952,7 +952,7 @@ namespace etl void initialise() { etl::destroy(p_buffer, p_end); - ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -962,7 +962,7 @@ namespace etl //********************************************************************* void initialise_source_external_buffer_after_move() { - ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -972,7 +972,7 @@ namespace etl //********************************************************************* void initialise_destination_external_buffer_after_move() { - ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) } //************************************************************************* @@ -1018,7 +1018,7 @@ namespace etl //********************************************************************* inline void create_back(rvalue_reference value) { - etl::create_copy_at(p_end, etlstd::move(value)); + etl::create_copy_at(p_end, etl::move(value)); ETL_INCREMENT_DEBUG_COUNT ++p_end; @@ -1065,7 +1065,7 @@ namespace etl template bool operator ==(const etl::ivector& lhs, const etl::ivector& rhs) { - return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1091,7 +1091,7 @@ namespace etl template bool operator <(const etl::ivector& lhs, const etl::ivector& rhs) { - return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** @@ -1243,7 +1243,7 @@ namespace etl typename etl::ivector::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -1262,7 +1262,7 @@ namespace etl typename etl::ivector::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -1298,7 +1298,7 @@ namespace etl private: - typename etl::aligned_storage::value>::type buffer; + typename etl::aligned_storage::value>::type buffer; }; //*************************************************************************** @@ -1560,7 +1560,7 @@ namespace etl typename etl::ivector::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -1579,7 +1579,7 @@ namespace etl typename etl::ivector::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(etlstd::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -1600,7 +1600,7 @@ namespace etl private: - typename etl::aligned_storage::value>::type buffer; + typename etl::aligned_storage::value>::type buffer; }; //*************************************************************************** diff --git a/include/etl/wstring.h b/include/etl/wstring.h index df0ac6d0..7447d962 100644 --- a/include/etl/wstring.h +++ b/include/etl/wstring.h @@ -192,7 +192,7 @@ namespace etl { ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds)); - length_ = etlstd::min(length_, size() - position); + length_ = etl::min(length_, size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index af18f98b..0aaac6e9 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -8,15 +8,6 @@ if(NOT UnitTest++_FOUND) # Add unittest-cpp as an ExternalProject include(cmake/unit-test_external_project.cmake) add_unittest_cpp() -else() - include(${UnitTest++_CONFIG}) - # The CMake install of UnitTest++ puts the include directory to ${CMAKE_INSTALL_PREFIX}/include - # under the assumptions that clients will consume the headers via - # #include - # However the tests in etl include the headers directly, e.g. - # #include "UnitTest++.h" - # Therefore we update the provide UTPP_INCLUDE_DIRS here - set(UTPP_INCLUDE_DIRS "${UTPP_INCLUDE_DIRS}/UnitTest++") endif() include_directories(${UTPP_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR}/../include) diff --git a/test/ExtraCheckMacros.h b/test/ExtraCheckMacros.h index 17fcd51a..be2df4c1 100644 --- a/test/ExtraCheckMacros.h +++ b/test/ExtraCheckMacros.h @@ -1,14 +1,14 @@ -#ifndef UNITTEST_EXTRA_CHECKMACROS_H +#ifndef UNITTEST_EXTRA_CHECKMACROS_H #define UNITTEST_EXTRA_CHECKMACROS_H -#include "HelperMacros.h" -#include "ExceptionMacros.h" -#include "Checks.h" -#include "AssertException.h" -#include "MemoryOutStream.h" -#include "TestDetails.h" -#include "CurrentTest.h" -#include "ReportAssertImpl.h" +#include "UnitTest++/HelperMacros.h" +#include "UnitTest++/ExceptionMacros.h" +#include "UnitTest++/Checks.h" +#include "UnitTest++/AssertException.h" +#include "UnitTest++/MemoryOutStream.h" +#include "UnitTest++/TestDetails.h" +#include "UnitTest++/CurrentTest.h" +#include "UnitTest++/ReportAssertImpl.h" #ifndef CHECK_NO_THROW #define CHECK_NO_THROW(expression) \ diff --git a/test/codeblocks/ETL.cbp b/test/codeblocks/ETL.cbp index 52a08930..e0014fc3 100644 --- a/test/codeblocks/ETL.cbp +++ b/test/codeblocks/ETL.cbp @@ -100,16 +100,37 @@ + + + + - - - + @@ -183,12 +204,14 @@