diff --git a/include/etl/absolute.h b/include/etl/absolute.h index 165dba9c..ba7f69ea 100644 --- a/include/etl/absolute.h +++ b/include/etl/absolute.h @@ -39,7 +39,7 @@ namespace etl // For signed types. //*************************************************************************** template - typename etl::enable_if::value, T>::type + typename etlstd::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 etl::enable_if::value, T>::type + typename etlstd::enable_if::value, T>::type absolute(T value) { return value; diff --git a/include/etl/algorithm.h b/include/etl/algorithm.h index 690a802b..f37e9eef 100644 --- a/include/etl/algorithm.h +++ b/include/etl/algorithm.h @@ -32,34 +32,1261 @@ SOFTWARE. #define ETL_ALGORITHM_INCLUDED ///\defgroup algorithm algorithm -/// Reverse engineered algorithms from C++ 0x11 +/// Including reverse engineered algorithms from C++ 0x11, 0x14, 0x17 /// Additional new variants of certain algorithms. ///\ingroup utilities -#include "stl/algorithm.h" -#include "stl/utility.h" -#include "stl/iterator.h" -#include "stl/functional.h" - #include #include "platform.h" -#include "iterator.h" #include "type_traits.h" #include "container.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" -namespace etl +#if !defined(ETL_NO_STL) + #include + #include + #include + #include +#endif + +//***************************************************************************** +// Algorithms defined by the ETL +//***************************************************************************** +#undef ETL_ALGORITHM + +namespace etlstd { +#if defined(ETL_NO_STL) + //*************************************************************************** + // 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); + } +#else + template + void swap(T& a, T& b) + { + T temp(a); + a = b; + b = temp; + } +#endif +#else + //*************************************************************************** + // swap + template + void swap(T& a, T& b) + { + using std::swap; + swap(a, b); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // iter_swap + template + void iter_swap(TIterator1 a, TIterator2 b) + { + typename etlstd::iterator_traits::value_type c = *a; + *a = *b; + *b = c; + } +#else + //*************************************************************************** + // iter_swap + template + void iter_swap(TIterator1 a, TIterator2 b) + { + std::iter_swap(a, b); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // swap_ranges + template + TIterator2 swap_ranges(T1terator1 first1, + T1terator1 last1, + TIterator2 first2) + { + while (first1 != last1) + { + iter_swap(first1++, first2++); + } + + return first2; + } +#else + //*************************************************************************** + // swap_ranges + template + TIterator2 swap_ranges(T1terator1 first1, + T1terator1 last1, + TIterator2 first2) + { + return std::swap_ranges(first1, last1, first2); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // copy + // Pointer + template + typename etlstd::enable_if::value && + etlstd::is_pointer::value && + etlstd::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; + + difference_t count = (se - sb); + + 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 + copy(TIterator1 sb, TIterator1 se, TIterator2 db) + { + while (sb != se) + { + *db++ = *sb++; + } + + return db; + } +#else + //*************************************************************************** + // copy + template + TIterator2 copy(TIterator1 sb, TIterator1 se, TIterator2 db) + { + return std::copy(sb, se, db); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // reverse_copy + template + TIterator2 reverse_copy(TIterator1 sb, TIterator1 se, TIterator2 db) + { + while (sb != se) + { + *(db++) = *(--se); + } + + return db; + } +#else + //*************************************************************************** + // reverse_copy + template + TIterator2 reverse_copy(TIterator1 sb, TIterator1 se, TIterator2 db) + { + return std::reverse_copy(sb, se, db); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + // copy_n + // Pointer + template + typename etlstd::enable_if::value && + etlstd::is_pointer::value && + etlstd::is_pod::value_type>::value, TIterator2>::type + copy_n(TIterator1 sb, TSize count, TIterator2 db) + { + typedef typename etlstd::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 + copy_n(TIterator1 sb, TSize count, TIterator2 db) + { + while (count != 0) + { + *db++ = *sb++; + --count; + } + + return db; + } +#else + //*************************************************************************** + /// copy_n + ///\ingroup algorithm + /// + //*************************************************************************** + template + TOutputIterator copy_n(TInputIterator i_begin, + TSize n, + TOutputIterator o_begin) + { + return std::copy_n(i_begin, n, o_begin); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // copy_backward + // Pointer + template + typename etlstd::enable_if::value && + etlstd::is_pointer::value && + etlstd::is_pod::value_type>::value, TIterator2>::type + copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de) + { + typedef typename etlstd::iterator_traits::value_type value_t; + + const size_t length = (se - sb); + + return TIterator2(memmove(de - length, sb, sizeof(value_t) * length)); + } + + // Other iterator + template + typename etlstd::enable_if::value || + !etlstd::is_pointer::value || + !etlstd::is_pod::value_type>::value, TIterator2>::type + copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de) + { + while (se != sb) + { + *(--de) = *(--se); + } + + return de; + } +#else + //*************************************************************************** + // copy_backward + template + TIterator2 copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de) + { + return std::copy_backward(sb, se, de); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // move + template + TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db) + { + while (sb != se) + { + *db++ = etlstd::move(*sb++); + } + + return db; + } +#else + //*************************************************************************** + // move + template + TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db) + { + return std::move(sb, se, db); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // move_backward + template + TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de) + { + while (sb != se) + { + *(--de) = etlstd::move(*(--se)); + } + + return de; + } +#else + //*************************************************************************** + // move_backward + template + TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de) + { + return std::move_backward(sb, se, de); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // reverse + // Pointers + template + typename etlstd::enable_if::value, void>::type + reverse(TIterator b, TIterator e) + { + if (b != e) + { + while (b < --e) + { + etl::iter_swap(b, e); + ++b; + } + } + } + + // Other + template + typename etlstd::enable_if::value, void>::type + reverse(TIterator b, TIterator e) + { + while ((b != e) && (b != --e)) + { + etl::iter_swap(b++, e); + } + } +#else + //*************************************************************************** + // reverse + template + void reverse(TIterator b, TIterator e) + { + std::reverse(b, e); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // lower_bound + template + TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + typedef typename etlstd::iterator_traits::difference_type difference_t; + + difference_t count = etlstd::distance(first, last); + + while (count > 0) + { + TIterator itr = first; + difference_t step = count / 2; + + etlstd::advance(itr, step); + + if (compare(*itr, value)) + { + first = ++itr; + count -= step + 1; + } + else + { + count = step; + } + } + + return first; + } + + template + TIterator lower_bound(TIterator first, TIterator last, const TValue& value) + { + typedef etlstd::less::value_type> compare; + + return etlstd::lower_bound(first, last, value, compare()); + } +#else + //*************************************************************************** + // lower_bound + template + TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + return std::lower_bound(first, last, value, compare); + } + + template + TIterator lower_bound(TIterator first, TIterator last, const TValue& value) + { + return std::lower_bound(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // upper_bound + template + TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + typedef typename etlstd::iterator_traits::difference_type difference_t; + + difference_t count = etlstd::distance(first, last); + + while (count > 0) + { + TIterator itr = first; + difference_t step = count / 2; + + etlstd::advance(itr, step); + + if (!compare(value, *itr)) + { + first = ++itr; + count -= step + 1; + } + else + { + count = step; + } + } + + return first; + } + + template + TIterator upper_bound(TIterator first, TIterator last, const TValue& value) + { + typedef etlstd::less::value_type> compare; + + return etl::upper_bound(first, last, value, compare()); + } +#else + //*************************************************************************** + // upper_bound + template + TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + return std::upper_bound(first, last, value, compare); + } + + template + TIterator upper_bound(TIterator first, TIterator last, const TValue& value) + { + return std::upper_bound(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // equal_range + template + 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)); + } + + template + ETL_OR_STD::pair equal_range(TIterator first, TIterator last, const TValue& value) + { + typedef etlstd::less::value_type> compare; + + return ETL_OR_STD::make_pair(etlstd::lower_bound(first, last, value, compare()), + etlstd::upper_bound(first, last, value, compare())); + } +#else + //*************************************************************************** + // equal_range + template + std::pair equal_range(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + return std::equal_range(first, last, value, compare); + } + + template + std::pair equal_range(TIterator first, TIterator last, const TValue& value) + { + return std::equal_range(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // find_if + template + TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate) + { + while (first != last) + { + if (predicate(*first)) + { + return first; + } + + ++first; + } + + return last; + } +#else + //*************************************************************************** + // find_if + template + TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate) + { + return std::find_if(first, last, predicate); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // find + template + TIterator find(TIterator first, TIterator last, const T& value) + { + while (first != last) + { + if (*first == value) + { + return first; + } + + ++first; + } + + return last; + } +#else + //*************************************************************************** + // find + template + TIterator find(TIterator first, TIterator last, const T& value) + { + return std::find(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // fill + template + typename etlstd::enable_if::value || etlstd::is_same::value) || !etlstd::is_pointer::value, void>::type + fill(TIterator first, TIterator last, const TValue& value) + { + while (first != last) + { + *first++ = value; + } + } + + template + typename etlstd::enable_if<(etlstd::is_same::value || etlstd::is_same::value) && etlstd::is_pointer::value, void>::type + fill(TIterator first, TIterator last, const TValue& value) + { + memset(first, value, last - first); + } +#else + //*************************************************************************** + // fill + template + void fill(TIterator first, TIterator last, const TValue& value) + { + std::fill(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // fill_n + template + typename etlstd::enable_if::value || etlstd::is_same::value) || !etlstd::is_pointer::value, TIterator>::type + fill_n(TIterator first, TSize count, const TValue& value) + { + for (TSize i = 0; i < count; ++i) + { + *first++ = value; + } + + return first; + } + + template + typename etlstd::enable_if<(etlstd::is_same::value || etlstd::is_same::value) && etlstd::is_pointer::value, void>::type + fill_n(TIterator first, TSize count, const TValue& value) + { + memset(first, value, count); + } +#else + //*************************************************************************** + // fill_n + template + TIterator fill_n(TIterator first, TSize count, const TValue& value) + { + return std::fill_n(first, count, value);; + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // count + template + typename etlstd::iterator_traits::difference_type count(TIterator first, TIterator last, const T& value) + { + typename iterator_traits::difference_type n = 0; + + while (first != last) + { + if (*first == value) + { + ++n; + } + + ++first; + } + + return n; + } +#else + //*************************************************************************** + // count + template + typename std::iterator_traits::difference_type count(TIterator first, TIterator last, const T& value) + { + return std::count(first, last, value); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // count_if + template + typename etlstd::iterator_traits::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate) + { + typename iterator_traits::difference_type n = 0; + + while (first != last) + { + if (predicate(*first)) + { + ++n; + } + + ++first; + } + + return n; + } +#else + //*************************************************************************** + // count_if + template + typename std::iterator_traits::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate) + { + return std::count_if(first, last, predicate); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // equal + template + typename etlstd::enable_if::value || !etlstd::is_pointer::value || !etlstd::is_pod::value_type>::value, bool>::type + equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) + { + while (first1 != last1) + { + if (*first1++ != *first2++) + { + return false; + } + } + + return true; + } + + template + typename etlstd::enable_if::value && etlstd::is_pointer::value && etlstd::is_pod::value_type>::value, bool>::type + equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) + { + typedef typename etlstd::iterator_traits::value_type value_t; + + return (memcmp(first1, first2, sizeof(value_t) * (last1 - first1)) == 0); + } +#else + //*************************************************************************** + // equal + template + bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) + { + return std::equal(first1, last1, first2); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // lexicographical_compare + template + bool lexicographical_compare(TIterator1 first1, TIterator1 last1, + TIterator2 first2, TIterator2 last2, + TCompare compare) + { + while ((first1 != last1) && (first2 != last2)) + { + if (compare(*first1, *first2)) + { + return true; + } + + if (compare(*first2, *first1)) + { + return false; + } + + ++first1; + ++first2; + } + + return (first1 == last1) && (first2 != last2); + } + + //*************************************************************************** + // lexicographical_compare + template + bool lexicographical_compare(TIterator1 first1, TIterator1 last1, + TIterator2 first2, TIterator2 last2) + { + typedef etlstd::less::value_type> compare; + + return etl::lexicographical_compare(first1, last1, first2, last2, compare()); + } +#else + //*************************************************************************** + // lexicographical_compare + template + bool lexicographical_compare(TIterator1 first1, TIterator1 last1, + TIterator2 first2, TIterator2 last2, + TCompare compare) + { + return std::lexicographical_compare(first1, last1, first2, last2, compare); + } + + //*************************************************************************** + // lexicographical_compare + template + bool lexicographical_compare(TIterator1 first1, TIterator1 last1, + TIterator2 first2, TIterator2 last2) + { + return std::lexicographical_compare(first1, last1, first2, last2); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // min + template + ETL_CONSTEXPR const T& min(const T& a, const T& b, TCompare compare) + { + return (compare(a, b)) ? a : b; + } + + template + ETL_CONSTEXPR const T& min(const T& a, const T& b) + { + typedef etlstd::less compare; + + return etl::min(a, b, compare()); + } +#else + //*************************************************************************** + // min + template + ETL_CONSTEXPR const T& min(const T& a, const T& b, TCompare compare) + { + return std::min(a, b, compare); + } + + template + ETL_CONSTEXPR const T& min(const T& a, const T& b) + { + return std::min(a, b); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // max + template + ETL_CONSTEXPR const T& max(const T& a, const T& b, TCompare compare) + { + return (compare(a, b)) ? b : a; + } + + template + ETL_CONSTEXPR const T& max(const T& a, const T& b) + { + typedef etlstd::less compare; + + return etl::max(a, b, compare()); + } +#else + //*************************************************************************** + // max + template + ETL_CONSTEXPR const T& max(const T& a, const T& b, TCompare compare) + { + return std::max(a, b, compare); + } + + template + ETL_CONSTEXPR const T& max(const T& a, const T& b) + { + return std::max(a, b); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // transform + template + TIteratorOut transform(TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation) + { + while (first1 != last1) + { + *d_first++ = unary_operation(*first1++); + } + + return d_first; + } + + template + TIteratorOut transform(TIteratorIn1 first1, TIteratorIn1 last1, TIteratorIn2 first2, TIteratorOut d_first, TBinaryOperation binary_operation) + { + while (first1 != last1) + { + *d_first++ = binary_operation(*first1++, *first2++); + } + + return d_first; + } +#else + //*************************************************************************** + // transform + template + TIteratorOut transform(TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation) + { + return std::transform(first1, last1, d_first, unary_operation);; + } + + template + TIteratorOut transform(TIteratorIn1 first1, TIteratorIn1 last1, TIteratorIn2 first2, TIteratorOut d_first, TBinaryOperation binary_operation) + { + return std::transform(first1, last1, first2, d_first, binary_operation); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // Heap + namespace private_heap + { + // Push Heap Helper + template + void push_heap(TIterator first, TDistance value_index, TDistance top_index, TValue value, TCompare compare) + { + TDistance parent = (value_index - 1) / 2; + + while ((value_index > top_index) && compare(first[parent], value)) + { + first[value_index] = first[parent]; + value_index = parent; + parent = (value_index - 1) / 2; + } + + first[value_index] = value; + } + + // Adjust Heap Helper + template + void adjust_heap(TIterator first, TDistance value_index, TDistance length, TValue value, TCompare compare) + { + TDistance top_index = value_index; + TDistance child2nd = (2 * value_index) + 2; + + while (child2nd < length) + { + if (compare(first[child2nd], first[child2nd - 1])) + { + child2nd--; + } + + first[value_index] = first[child2nd]; + value_index = child2nd; + child2nd = 2 * (child2nd + 1); + } + + if (child2nd == length) + { + first[value_index] = first[child2nd - 1]; + value_index = child2nd - 1; + } + + push_heap(first, value_index, top_index, value, compare); + } + + // Is Heap Helper + template + bool is_heap(const TIterator first, const TDistance n, TCompare compare) + { + TDistance parent = 0; + + for (TDistance child = 1; child < n; ++child) + { + if (compare(first[parent], first[child])) + { + return false; + } + + if ((child & 1) == 0) + { + ++parent; + } + } + + return true; + } + } + + // Pop Heap + 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; + + value_t value = last[-1]; + last[-1] = first[0]; + + private_heap::adjust_heap(first, distance_t(0), distance_t(last - first - 1), value, compare); + } + + // Pop Heap + template + void pop_heap(TIterator first, TIterator last) + { + typedef etlstd::less::value_type> 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; + + private_heap::push_heap(first, difference_t(last - first - 1), difference_t(0), value_t(*(last - 1)), compare); + } + + // Push Heap + template + void push_heap(TIterator first, TIterator last) + { + typedef etlstd::less::value_type> 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; + + if ((last - first) < 2) + { + return; + } + + difference_t length = last - first; + difference_t parent = (length - 2) / 2; + + while (true) + { + private_heap::adjust_heap(first, parent, length, *(first + parent), compare); + + if (parent == 0) + { + return; + } + + --parent; + } + } + + // Make Heap + template + void make_heap(TIterator first, TIterator last) + { + typedef etlstd::less::value_type> compare; + + etl::make_heap(first, last, compare()); + } + + // Is Heap + template + bool is_heap(TIterator first, TIterator last) + { + typedef etlstd::less::value_type> compare; + + return private_heap::is_heap(first, last - first, compare()); + } + + // Is Heap + template + bool is_heap(TIterator first, TIterator last, TCompare compare) + { + return private_heap::is_heap(first, last - first, compare); + } +#else + //*************************************************************************** + // Heap + // Pop Heap + template + void pop_heap(TIterator first, TIterator last, TCompare compare) + { + std::pop_heap(first, last, compare); + } + + // Pop Heap + template + void pop_heap(TIterator first, TIterator last) + { + std::pop_heap(first, last); + } + + // Push Heap + template + void push_heap(TIterator first, TIterator last, TCompare compare) + { + std::push_heap(first, last, compare); + } + + // Push Heap + template + void push_heap(TIterator first, TIterator last) + { + std::push_heap(first, last); + } + + // Make Heap + template + void make_heap(TIterator first, TIterator last, TCompare compare) + { + std::make_heap(first, last, compare); + } + + // Make Heap + template + void make_heap(TIterator first, TIterator last) + { + std::make_heap(first, last); + } + + // Is Heap + template + bool is_heap(TIterator first, TIterator last) + { + return std::is_heap(first, last); + } + + // Is Heap + template + bool is_heap(TIterator first, TIterator last, TCompare compare) + { + return std::is_heap(first, last, compare); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // Search + template + TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare) + { + while (true) + { + TIterator1 itr = first; + TIterator2 search_itr = search_first; + + while (true) + { + if (search_itr == search_last) + { + return first; + } + + if (itr == last) + { + return last; + } + + if (!compare(*itr, *search_itr)) + { + break; + } + + ++itr; + ++search_itr; + } + + ++first; + } + } + + // Search + template + TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last) + { + typedef etl::equal_to::value_type> compare; + + return etl::search(first, last, search_first, search_last, compare()); + } +#else + //*************************************************************************** + // Search + template + TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare) + { + return std::search(first, last, search_first, search_last, compare); + } + + // Search + template + TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last) + { + return std::search(first, last, search_first, search_last); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // Rotate + template + TIterator rotate(TIterator first, TIterator middle, TIterator last) + { +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + + TIterator next = middle; + + while (first != next) + { + swap(*first++, *next++); + + if (next == last) + { + next = middle; + } + else if (first == middle) + { + middle = next; + } + } + + return first; + } +#else + //*************************************************************************** + // Rotate + template + TIterator rotate(TIterator first, TIterator middle, TIterator last) + { + return std::rotate(first, middle, last); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // find_end + // Predicate + template + TIterator1 find_end(TIterator1 b, TIterator1 e, + TIterator2 sb, TIterator2 se, + TPredicate predicate) + { + if (sb == se) + { + return e; + } + + TIterator1 result = e; + + while (true) + { + TIterator1 new_result = etl::search(b, e, sb, se, predicate); + + if (new_result == e) + { + break; + } + else + { + result = new_result; + b = result; + ++b; + } + } + return result; + } + + // Default + template + TIterator1 find_end(TIterator1 b, TIterator1 e, + TIterator2 sb, TIterator2 se) + { + typedef etl::equal_to::value_type> predicate; + + return find_end(b, e, sb, se, predicate()); + } +#else + //*************************************************************************** + // find_end + // Predicate + template + TIterator1 find_end(TIterator1 b, TIterator1 e, + TIterator2 sb, TIterator2 se, + TPredicate predicate) + { + return std::find_end(b, e, sb, se, predicate); + } + + // Default + template + TIterator1 find_end(TIterator1 b, TIterator1 e, + TIterator2 sb, TIterator2 se) + { + return std::find_end(b, e, sb, se); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED //*************************************************************************** /// Finds the greatest and the smallest element in the range (begin, end).
/// ///\ingroup algorithm //*************************************************************************** - template - ETL_PAIR minmax_element(TIterator begin, - TIterator end, - TCompare compare) + template + ETL_OR_STD::pair minmax_element(TIterator begin, + TIterator end, + TCompare compare) { TIterator minimum = begin; TIterator maximum = begin; @@ -79,7 +1306,7 @@ namespace etl ++begin; } - return ETL_PAIR(minimum, maximum); + return ETL_OR_STD::pair(minimum, maximum); } //*************************************************************************** @@ -88,24 +1315,52 @@ namespace etl /// //*************************************************************************** template - ETL_PAIR minmax_element(TIterator begin, - TIterator end) + ETL_OR_STD::pair minmax_element(TIterator begin, + TIterator end) { - typedef typename ETL_STD::iterator_traits::value_type value_t; + typedef typename etlstd::iterator_traits::value_type value_t; - return etl::minmax_element(begin, end, ETL_STD::less()); + return etlstd::minmax_element(begin, end, etlstd::less()); + } +#else + //*************************************************************************** +/// Finds the greatest and the smallest element in the range (begin, end).
+/// +///\ingroup algorithm +//*************************************************************************** + template + std::pair minmax_element(TIterator begin, + TIterator end, + TCompare compare) + { + return std::minmax_element(begin, end, compare); } + + //*************************************************************************** + /// minmax_element + ///\ingroup algorithm + /// + //*************************************************************************** + template + std::pair minmax_element(TIterator begin, + TIterator end) + { + return std::minmax_element(begin, end); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED //*************************************************************************** /// minmax ///\ingroup algorithm /// //*************************************************************************** template - ETL_PAIR minmax(const T& a, - const T& b) + ETL_OR_STD::pair minmax(const T& a, + const T& b) { - return (b < a) ? ETL_PAIR(b, a) : ETL_PAIR(a, b); + return (b < a) ? ETL_OR_STD::pair(b, a) : ETL_OR_STD::pair(a, b); } //*************************************************************************** @@ -114,14 +1369,41 @@ namespace etl /// //*************************************************************************** template - ETL_PAIR minmax(const T& a, - const T& b, - TCompare compare) + typename TCompare> + ETL_OR_STD::pair minmax(const T& a, + const T& b, + TCompare compare) { - return compare(b, a) ? ETL_PAIR(b, a) : ETL_PAIR(a, b); + return compare(b, a) ? ETL_OR_STD::pair(b, a) : ETL_OR_STD::pair(a, b); + } +#else + //*************************************************************************** + /// minmax + ///\ingroup algorithm + /// + //*************************************************************************** + template + std::pair minmax(const T& a, + const T& b) + { + return std::minmax(a, b); } + //*************************************************************************** + /// minmax + ///\ingroup algorithm + /// + //*************************************************************************** + template + std::pair minmax(const T& a, + const T& b, + TCompare compare) + { + return std::minmax(a, b, compare); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED //*************************************************************************** /// is_sorted_until ///\ingroup algorithm @@ -155,10 +1437,10 @@ namespace etl /// //*************************************************************************** template - TIterator is_sorted_until(TIterator begin, - TIterator end, - TCompare compare) + typename TCompare> + TIterator is_sorted_until(TIterator begin, + TIterator end, + TCompare compare) { if (begin != end) { @@ -177,7 +1459,34 @@ namespace etl return end; } +#else + //*************************************************************************** + /// is_sorted_until + ///\ingroup algorithm + /// + //*************************************************************************** + template + TIterator is_sorted_until(TIterator begin, + TIterator end) + { + return std::is_sorted_until(begin, end); + } + //*************************************************************************** + /// is_sorted_until + ///\ingroup algorithm + /// + //*************************************************************************** + template + TIterator is_sorted_until(TIterator begin, + TIterator end, + TCompare compare) + { + return std::is_sorted_until(begin, end, compare); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED //*************************************************************************** /// is_sorted ///\ingroup algorithm @@ -187,7 +1496,7 @@ namespace etl bool is_sorted(TIterator begin, TIterator end) { - return etl::is_sorted_until(begin, end) == end; + return etlstd::is_sorted_until(begin, end) == end; } //*************************************************************************** @@ -196,17 +1505,525 @@ namespace etl /// //*************************************************************************** template + typename TCompare> + bool is_sorted(TIterator begin, + TIterator end, + TCompare compare) + { + return etlstd::is_sorted_until(begin, end, compare) == end; + } +#else + //*************************************************************************** + /// is_sorted + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_sorted(TIterator begin, + TIterator end) + { + return std::is_sorted(begin, end); + } + + //*************************************************************************** + /// is_sorted + ///\ingroup algorithm + /// + //*************************************************************************** + template bool is_sorted(TIterator begin, TIterator end, TCompare compare) { - return etl::is_sorted_until(begin, end, compare) == end; + return std::is_sorted(begin, end, compare); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// find_if_not + ///\ingroup algorithm + /// + //*************************************************************************** + template + TIterator find_if_not(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + while (begin != end) + { + if (!predicate(*begin)) + { + return begin; + } + + ++begin; + } + + return end; + } +#else + //*************************************************************************** + /// find_if_not + ///\ingroup algorithm + /// + //*************************************************************************** + template + TIterator find_if_not(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return std::find_if_not(begin, end, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2) + { + if (begin1 != end1) + { + TIterator2 end2 = begin2; + + etlstd::advance(end2, etlstd::distance(begin1, end1)); + + for (TIterator1 i = begin1; i != end1; ++i) + { + if (i == etlstd::find(begin1, i, *i)) + { + size_t n = etlstd::count(begin2, end2, *i); + + if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + { + return false; + } + } + } + } + + return true; } //*************************************************************************** - /// copy - /// A form of copy where the smallest of the two ranges is used. + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TBinaryPredicate predicate) + { + if (begin1 != end1) + { + TIterator2 end2 = begin2; + + etlstd::advance(end2, etlstd::distance(begin1, end1)); + + for (TIterator1 i = begin1; i != end1; ++i) + { + if (i == etlstd::find_if(begin1, i, etlstd::bind1st(predicate, *i))) + { + size_t n = etlstd::count(begin2, end2, *i); + + if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + { + return false; + } + } + } + } + + return true; + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TIterator2 end2) + { + if (begin1 != end1) + { + for (TIterator1 i = begin1; i != end1; ++i) + { + if (i == etlstd::find(begin1, i, *i)) + { + size_t n = etlstd::count(begin2, end2, *i); + + if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + { + return false; + } + } + } + } + + return true; + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TIterator2 end2, + TBinaryPredicate predicate) + { + if (begin1 != end1) + { + for (TIterator1 i = begin1; i != end1; ++i) + { + if (i == etlstd::find_if(begin1, i, etlstd::bind1st(predicate, *i))) + { + size_t n = etlstd::count(begin2, end2, *i); + + if (n == 0 || size_t(etlstd::count(i, end1, *i)) != n) + { + return false; + } + } + } + } + + return true; + } +#else + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2) + { + return std::is_permutation(begin1, end1, begin2); + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TBinaryPredicate predicate) + { + return std::is_permutation(begin1, end1, begin2, predicate); + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TIterator2 end2) + { + return std::is_permutation(begin1, end1, begin2, end2); + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TIterator2 end2, + TBinaryPredicate predicate) + { + return std::is_permutation(begin1, end1, begin2, end2, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// is_partitioned + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_partitioned(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + while (begin != end) + { + if (!predicate(*begin++)) + { + break; + } + } + + while (begin != end) + { + if (predicate(*begin++)) + { + return false; + } + } + + return true; + } +#else + //*************************************************************************** + /// is_partitioned + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool is_partitioned(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return std::is_partitioned(begin, end, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// partition_point + /// + ///\ingroup algorithm + //*************************************************************************** + template + TIterator partition_point(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + while (begin != end) + { + if (!predicate(*begin)) + { + return begin; + } + + ++begin; + } + + return begin; + } +#else + //*************************************************************************** + /// partition_point + /// + ///\ingroup algorithm + //*************************************************************************** + template + TIterator partition_point(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return std::partition_point(begin, end, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// Copies the elements from the range (begin, end) to two different ranges + /// depending on the value returned by the predicate.
+ /// + ///\ingroup algorithm + //*************************************************************************** + template + ETL_OR_STD::pair partition_copy(TSource begin, + TSource end, + TDestinationTrue destination_true, + TDestinationFalse destination_false, + TUnaryPredicate predicate) + { + while (begin != end) + { + if (predicate(*begin)) + { + *destination_true++ = *begin++; + } + else + { + *destination_false++ = *begin++; + } + } + + return ETL_OR_STD::pair(destination_true, destination_false); + } +#else + //*************************************************************************** + /// Copies the elements from the range (begin, end) to two different ranges + /// depending on the value returned by the predicate.
+ /// + ///\ingroup algorithm + //*************************************************************************** + template + std::pair partition_copy(TSource begin, + TSource end, + TDestinationTrue destination_true, + TDestinationFalse destination_false, + TUnaryPredicate predicate) + { + return std::partition_copy(begin, end, destination_true, destination_false, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// copy_if + ///\ingroup algorithm + /// + //*************************************************************************** + template + TOutputIterator copy_if(TIterator begin, + TIterator end, + TOutputIterator out, + TUnaryPredicate predicate) + { + while (begin != end) + { + if (predicate(*begin)) + { + *out++ = *begin; + } + + ++begin; + } + + return out; + } +#else + //*************************************************************************** + /// copy_if + ///\ingroup algorithm + /// + //*************************************************************************** + template + TOutputIterator copy_if(TIterator begin, + TIterator end, + TOutputIterator out, + TUnaryPredicate predicate) + { + return std::copy_if(begin, end, out, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// all_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool all_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return etlstd::find_if_not(begin, end, predicate) == end; + } +#else + //*************************************************************************** + /// all_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool all_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return std::all_of(begin, end, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// any_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool any_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return etlstd::find_if(begin, end, predicate) != end; + } +#else + //*************************************************************************** + /// any_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool any_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return std::any_of(begin, end, predicate); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// none_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool none_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return etlstd::find_if(begin, end, predicate) == end; + } +#else + //*************************************************************************** + /// none_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + bool none_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return std::none_of(begin, end, predicate); + } +#endif +} + +//***************************************************************************** +// ETL extensions to the STL algorithms. +//***************************************************************************** +namespace etl +{ + //*************************************************************************** + /// copy_s + /// A safer form of copy where the smallest of the two ranges is used. /// There is currently no STL equivalent. /// Specialisation for random access iterators. ///\param i_begin Beginning of the input range. @@ -217,23 +2034,23 @@ namespace etl //*************************************************************************** template - typename etl::enable_if::value && - etl::is_random_iterator::value, TOutputIterator>::type + typename etlstd::enable_if::value && + etl::is_random_iterator::value, TOutputIterator>::type copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end) { - size_t s_size = ETL_STD::distance(i_begin, i_end); - size_t d_size = ETL_STD::distance(o_begin, o_end); + size_t s_size = etlstd::distance(i_begin, i_end); + size_t d_size = etlstd::distance(o_begin, o_end); size_t size = (s_size < d_size) ? s_size : d_size; - return ETL_STD::copy(i_begin, i_begin + size, o_begin); + return etlstd::copy(i_begin, i_begin + size, o_begin); } //*************************************************************************** /// copy - /// A form of copy where the smallest of the two ranges is used. + /// A safer form of copy where the smallest of the two ranges is used. /// There is currently no STL equivalent. /// Specialisation for non random access iterators. ///\param i_begin Beginning of the input range. @@ -244,8 +2061,8 @@ namespace etl //*************************************************************************** template - typename etl::enable_if::value || - !etl::is_random_iterator::value, TOutputIterator>::type + typename etlstd::enable_if::value || + !etl::is_random_iterator::value, TOutputIterator>::type copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, @@ -259,46 +2076,9 @@ namespace etl return o_begin; } - //*************************************************************************** - /// copy_n (Random input iterators) - ///\ingroup algorithm - /// - //*************************************************************************** - template - typename etl::enable_if::value, TOutputIterator>::type - copy_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin) - { - return ETL_STD::copy(i_begin, i_begin + n, o_begin); - } - - //*************************************************************************** - /// copy_n (Non-random input iterators) - ///\ingroup algorithm - /// - //*************************************************************************** - template - typename etl::enable_if::value, TOutputIterator>::type - copy_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin) - { - while (n-- > 0) - { - *o_begin++ = *i_begin++; - } - - return o_begin; - } - //*************************************************************************** /// copy_n - /// A form of copy_n where the smallest of the two ranges is used. + /// A safer form of copy_n where the smallest of the two ranges is used. ///\ingroup algorithm //*************************************************************************** template - //*************************************************************************** - template - TOutputIterator copy_if(TIterator begin, - TIterator end, - TOutputIterator out, - TUnaryPredicate predicate) - { - while (begin != end) - { - if (predicate(*begin)) - { - *out++ = *begin; - } - - ++begin; - } - - return out; - } - - //*************************************************************************** - /// copy_if - /// A form of copy_if where it terminates when the first end iterator is reached. + /// A safer form of copy_if where it terminates when the first end iterator is reached. /// There is currently no STL equivelent. ///\ingroup algorithm //*************************************************************************** @@ -375,10 +2129,10 @@ namespace etl typename TOutputIterator, typename TUnaryPredicate> TOutputIterator copy_if(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end, - TUnaryPredicate predicate) + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end, + TUnaryPredicate predicate) { while ((i_begin != i_end) && (o_begin != o_end)) { @@ -427,11 +2181,11 @@ namespace etl //*************************************************************************** template - TIterator binary_find(TIterator begin, - TIterator end, - const TValue& value) + TIterator binary_find(TIterator begin, + TIterator end, + const TValue& value) { - TIterator it = ETL_STD::lower_bound(begin, end, value); + TIterator it = etlstd::lower_bound(begin, end, value); if ((it == end) || (*it != value)) { @@ -450,13 +2204,13 @@ namespace etl typename TValue, typename TBinaryPredicate, typename TBinaryEquality> - TIterator binary_find(TIterator begin, - TIterator end, - const TValue& value, - TBinaryPredicate predicate, - TBinaryEquality equality) + TIterator binary_find(TIterator begin, + TIterator end, + const TValue& value, + TBinaryPredicate predicate, + TBinaryEquality equality) { - TIterator it = ETL_STD::lower_bound(begin, end, value, predicate); + TIterator it = etlstd::lower_bound(begin, end, value, predicate); if ((it == end) || !equality(*it, value)) { @@ -466,299 +2220,6 @@ namespace etl return it; } - //*************************************************************************** - /// find_if_not - ///\ingroup algorithm - /// - //*************************************************************************** - template - TIterator find_if_not(TIterator begin, - TIterator end, - TUnaryPredicate predicate) - { - while (begin != end) - { - if (!predicate(*begin)) - { - return begin; - } - - ++begin; - } - - return end; - } - - //*************************************************************************** - /// all_of - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool all_of(TIterator begin, - TIterator end, - TUnaryPredicate predicate) - { - return etl::find_if_not(begin, end, predicate) == end; - } - - //*************************************************************************** - /// any_of - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool any_of(TIterator begin, - TIterator end, - TUnaryPredicate predicate) - { - return ETL_STD::find_if(begin, end, predicate) != end; - } - - //*************************************************************************** - /// none_of - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool none_of(TIterator begin, - TIterator end, - TUnaryPredicate predicate) - { - return ETL_STD::find_if(begin, end, predicate) == end; - } - - //*************************************************************************** - /// is_permutation - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool is_permutation(TIterator1 begin1, - TIterator1 end1, - TIterator2 begin2) - { - if (begin1 != end1) - { - TIterator2 end2 = begin2; - - ETL_STD::advance(end2, ETL_STD::distance(begin1, end1)); - - for (TIterator1 i = begin1; i != end1; ++i) - { - if (i == ETL_STD::find(begin1, i, *i)) - { - size_t n = ETL_STD::count(begin2, end2, *i); - - if (n == 0 || size_t(ETL_STD::count(i, end1, *i)) != n) - { - return false; - } - } - } - } - - return true; - } - - //*************************************************************************** - /// is_permutation - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool is_permutation(TIterator1 begin1, - TIterator1 end1, - TIterator2 begin2, - TIterator2 end2) - { - if (begin1 != end1) - { - for (TIterator1 i = begin1; i != end1; ++i) - { - if (i == ETL_STD::find(begin1, i, *i)) - { - size_t n = ETL_STD::count(begin2, end2, *i); - - if (n == 0 || size_t(ETL_STD::count(i, end1, *i)) != n) - { - return false; - } - } - } - } - - return true; - } - - //*************************************************************************** - /// is_permutation - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool is_permutation(TIterator1 begin1, - TIterator1 end1, - TIterator2 begin2, - TBinaryPredicate predicate) - { - if (begin1 != end1) - { - TIterator2 end2 = begin2; - - ETL_STD::advance(end2, ETL_STD::distance(begin1, end1)); - - for (TIterator1 i = begin1; i != end1; ++i) - { -#if ETL_CPP11_SUPPORTED && !defined(ETL_NO_STL) - if (i == std::find_if(begin1, i, std::bind(predicate, *i, std::placeholders::_1))) -#else - if (i == ETL_STD::find_if(begin1, i, ETL_STD::bind1st(predicate, *i))) -#endif - { - size_t n = ETL_STD::count(begin2, end2, *i); - - if (n == 0 || size_t(ETL_STD::count(i, end1, *i)) != n) - { - return false; - } - } - } - } - - return true; - } - - //*************************************************************************** - /// is_permutation - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool is_permutation(TIterator1 begin1, - TIterator1 end1, - TIterator2 begin2, - TIterator2 end2, - TBinaryPredicate predicate) - { - if (begin1 != end1) - { - for (TIterator1 i = begin1; i != end1; ++i) - { -#if ETL_CPP11_SUPPORTED && !defined(ETL_NO_STL) - if (i == std::find_if(begin1, i, std::bind(predicate, *i, std::placeholders::_1))) -#else - if (i == ETL_STD::find_if(begin1, i, ETL_STD::bind1st(predicate, *i))) -#endif - { - size_t n = ETL_STD::count(begin2, end2, *i); - - if (n == 0 || size_t(ETL_STD::count(i, end1, *i)) != n) - { - return false; - } - } - } - } - - return true; - } - - //*************************************************************************** - /// is_partitioned - ///\ingroup algorithm - /// - //*************************************************************************** - template - bool is_partitioned(TIterator begin, - TIterator end, - TUnaryPredicate predicate) - { - while (begin != end) - { - if (!predicate(*begin++)) - { - break; - } - } - - while (begin != end) - { - if (predicate(*begin++)) - { - return false; - } - } - - return true; - } - - //*************************************************************************** - /// partition_point - /// - ///\ingroup algorithm - //*************************************************************************** - template - TIterator partition_point(TIterator begin, - TIterator end, - TUnaryPredicate predicate) - { - while (begin != end) - { - if (!predicate(*begin)) - { - return begin; - } - - ++begin; - } - - return begin; - } - - //*************************************************************************** - /// Copies the elements from the range (begin, end) to two different ranges - /// depending on the value returned by the predicate.
- /// - ///\ingroup algorithm - //*************************************************************************** - template - ETL_PAIR partition_copy(TSource begin, - TSource end, - TDestinationTrue destination_true, - TDestinationFalse destination_false, - TUnaryPredicate predicate) - { - while (begin != end) - { - if (predicate(*begin)) - { - *destination_true++ = *begin++; - } - else - { - *destination_false++ = *begin++; - } - } - - return ETL_PAIR(destination_true, destination_false); - } - //*************************************************************************** /// Like std::for_each but applies a predicate before calling the function. ///\ingroup algorithm @@ -830,24 +2291,26 @@ namespace etl } //*************************************************************************** - /// A form of std::transform where the transform returns when the first range - /// end is reached. + /// A safer form of std::transform where the transform returns when the first + /// range end is reached. /// There is currently no STL equivalent. ///\ingroup algorithm //*************************************************************************** template - void transform(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end, - TUnaryFunction function) + TOutputIterator transform(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end, + TUnaryFunction function) { while ((i_begin != i_end) && (o_begin != o_end)) { *o_begin++ = function(*i_begin++); } + + return o_begin; } //*************************************************************************** @@ -860,13 +2323,15 @@ namespace etl typename TSize, typename TOutputIterator, typename TUnaryFunction> - typename etl::enable_if::value, void>::type - transform_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin, - TUnaryFunction function) + void transform_n(TInputIterator i_begin, + TSize n, + TOutputIterator o_begin, + TUnaryFunction function) { - ETL_STD::transform(i_begin, i_begin + n, o_begin, function); + TInputIterator i_end(i_begin); + etlstd::advance(i_end, n); + + etlstd::transform(i_begin, i_end, o_begin, function); } //*************************************************************************** @@ -880,64 +2345,16 @@ namespace etl typename TSize, typename TOutputIterator, typename TBinaryFunction> - typename etl::enable_if::value && - etl::is_random_iterator::value, void>::type - transform_n(TInputIterator1 i_begin1, - TInputIterator2 i_begin2, - TSize n, - TOutputIterator o_begin, - TBinaryFunction function) + void transform_n(TInputIterator1 i_begin1, + TInputIterator2 i_begin2, + TSize n, + TOutputIterator o_begin, + TBinaryFunction function) { - ETL_STD::transform(i_begin1, i_begin1 + n, i_begin2, o_begin, function); - } + TInputIterator i_end1(i_begin1); + etlstd::advance(i_end1, n); - //*************************************************************************** - /// Transform 'n' items. - /// Non-random iterators. - /// There is currently no STL equivalent. - ///\ingroup algorithm - //*************************************************************************** - template - typename etl::enable_if::value, void>::type - transform_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin, - TUnaryFunction function) - { - while (n > 0) - { - *o_begin++ = function(*i_begin++); - --n; - } - } - - //*************************************************************************** - /// Transform 'n' items from two ranges. - /// Non-random iterators. - /// There is currently no STL equivalent. - ///\ingroup algorithm - //*************************************************************************** - template - typename etl::enable_if::value || - !etl::is_random_iterator::value, void>::type - transform_n(TInputIterator1 i_begin1, - TInputIterator2 i_begin2, - TSize n, - TOutputIterator o_begin, - TBinaryFunction function) - { - while (n > 0) - { - *o_begin++ = function(*i_begin1++, *i_begin2++); - --n; - } + etlstd::transform(i_begin1, i_end1, i_begin2, o_begin, function); } //*************************************************************************** @@ -1064,13 +2481,13 @@ namespace etl template - ETL_PAIR partition_transform(TSource begin, - TSource end, - TDestinationTrue destination_true, - TDestinationFalse destination_false, - TUnaryFunctionTrue function_true, - TUnaryFunctionFalse function_false, - TUnaryPredicate predicate) + ETL_OR_STD::pair partition_transform(TSource begin, + TSource end, + TDestinationTrue destination_true, + TDestinationFalse destination_false, + TUnaryFunctionTrue function_true, + TUnaryFunctionFalse function_false, + TUnaryPredicate predicate) { while (begin != end) { @@ -1084,7 +2501,7 @@ namespace etl } } - return ETL_PAIR(destination_true, destination_false); + return ETL_OR_STD::pair(destination_true, destination_false); } //*************************************************************************** @@ -1099,7 +2516,7 @@ namespace etl typename TBinaryFunctionTrue, typename TBinaryFunctionFalse, typename TBinaryPredicate> - ETL_PAIR partition_transform(TSource1 begin1, + ETL_OR_STD::pair partition_transform(TSource1 begin1, TSource1 end1, TSource2 begin2, TDestinationTrue destination_true, @@ -1120,7 +2537,7 @@ namespace etl } } - return ETL_PAIR(destination_true, destination_false); + return ETL_OR_STD::pair(destination_true, destination_false); } //*************************************************************************** @@ -1136,9 +2553,9 @@ namespace etl return; } - typedef typename ETL_STD::iterator_traits::difference_type difference_t; + typedef typename etlstd::iterator_traits::difference_type difference_t; - difference_t n = ETL_STD::distance(first, last); + difference_t n = etlstd::distance(first, last); for (difference_t i = n / 2; i > 0; i /= 2) { @@ -1149,12 +2566,12 @@ namespace etl TIterator itr1 = first; TIterator itr2 = first; - ETL_STD::advance(itr1, k); - ETL_STD::advance(itr2, k + i); + etlstd::advance(itr1, k); + etlstd::advance(itr2, k + i); if (compare(*itr2, *itr1)) { - ETL_STD::iter_swap(itr1, itr2); + etlstd::iter_swap(itr1, itr2); } } } @@ -1168,7 +2585,7 @@ namespace etl template void shell_sort(TIterator first, TIterator last) { - etl::shell_sort(first, last, ETL_STD::less::value_type>()); + etl::shell_sort(first, last, etlstd::less::value_type>()); } //*************************************************************************** @@ -1181,7 +2598,7 @@ namespace etl { for (TIterator itr = first; itr != last; ++itr) { - ETL_STD::rotate(ETL_STD::upper_bound(first, itr, *itr, compare), itr, etl::next(itr)); + etlstd::rotate(etlstd::upper_bound(first, itr, *itr, compare), itr, etlstd::next(itr)); } } @@ -1192,7 +2609,7 @@ namespace etl template void insertion_sort(TIterator first, TIterator last) { - etl::insertion_sort(first, last, ETL_STD::less::value_type>()); + etl::insertion_sort(first, last, etlstd::less::value_type>()); } //*************************************************************************** @@ -1213,7 +2630,7 @@ namespace etl template void sort(TIterator first, TIterator last) { - etl::shell_sort(first, last, ETL_STD::less::value_type>()); + etl::shell_sort(first, last, etlstd::less::value_type>()); } //*************************************************************************** @@ -1236,10 +2653,9 @@ namespace etl template void stable_sort(TIterator first, TIterator last) { - etl::insertion_sort(first, last, ETL_STD::less::value_type>()); + etl::insertion_sort(first, last, etlstd::less::value_type>()); } -#if ETL_CPP11_SUPPORTED //*************************************************************************** /// Returns the maximum value. //*************************************************************************** @@ -1363,7 +2779,6 @@ namespace etl { 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 b2e53866..0a0f2d91 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((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::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((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); const T* t = *this; return *t; } @@ -134,7 +134,7 @@ namespace etl template operator T* () { - ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); return reinterpret_cast(data); } @@ -142,7 +142,7 @@ namespace etl template operator const T* () const { - ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::alignment_of::value) == 0)), "Incompatible alignment"); return reinterpret_cast(data); } @@ -150,7 +150,7 @@ namespace etl template T& get_reference() { - ETL_STATIC_ASSERT((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::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((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::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((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::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((etl::is_same:: value || ((ALIGNMENT % etl::alignment_of::value) == 0)), "Incompatible alignment"); + ETL_STATIC_ASSERT((etlstd::is_same:: value || ((ALIGNMENT % etlstd::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 748bfef4..a9205464 100644 --- a/include/etl/array.h +++ b/include/etl/array.h @@ -35,9 +35,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #include "exception.h" #include "type_traits.h" @@ -107,8 +107,8 @@ namespace etl typedef const T* const_pointer; typedef T* iterator; typedef const T* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* // Element access @@ -342,7 +342,7 @@ namespace etl //************************************************************************* void fill(parameter_t value) { - ETL_STD::fill(begin(), end(), value); + etlstd::fill(begin(), end(), value); } //************************************************************************* @@ -351,9 +351,15 @@ namespace etl //************************************************************************* void swap(array& other) { +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + for (size_t i = 0; i < SIZE; ++i) { - ETL_STD::swap(_buffer[i], other._buffer[i]); + swap(_buffer[i], other._buffer[i]); } } @@ -367,7 +373,7 @@ namespace etl template void assign(TIterator first, const TIterator last) { - etl::copy(first, last, begin(), end()); + etlstd::copy(first, last, begin(), end()); } //************************************************************************* @@ -381,10 +387,10 @@ namespace etl void assign(TIterator first, const TIterator last, parameter_t value) { // Copy from the range. - iterator p = etl::copy(first, last, begin(), end()); + iterator p = etlstd::copy(first, last, begin(), end()); // Default initialise any that are left. - ETL_STD::fill(p, end(), value); + etlstd::fill(p, end(), value); } //************************************************************************* @@ -406,7 +412,7 @@ namespace etl { iterator p = const_cast(position); - ETL_STD::copy_backward(p, end() - 1, end()); + etlstd::copy_backward(p, end() - 1, end()); *p = value; return p; @@ -436,18 +442,18 @@ namespace etl iterator p = const_cast(position); iterator result(p); - size_t source_size = ETL_STD::distance(first, last); - size_t destination_space = ETL_STD::distance(position, cend()); + size_t source_size = etlstd::distance(first, last); + size_t destination_space = etlstd::distance(position, cend()); // Do we need to move anything? if (source_size < destination_space) { - size_t length = SIZE - (ETL_STD::distance(begin(), p) + source_size); - ETL_STD::copy_backward(p, p + length, end()); + size_t length = SIZE - (etlstd::distance(begin(), p) + source_size); + etlstd::copy_backward(p, p + length, end()); } // Copy from the range. - etl::copy(first, last, p, end()); + etlstd::copy(first, last, p, end()); return result; } @@ -470,7 +476,7 @@ namespace etl iterator erase(const_iterator position) { iterator p = const_cast(position); - ETL_STD::copy(p + 1, end(), p); + etlstd::copy(p + 1, end(), p); return p; } @@ -495,7 +501,7 @@ namespace etl iterator erase(const_iterator first, const_iterator last) { iterator p = const_cast(first); - ETL_STD::copy(last, cend(), p); + etlstd::copy(last, cend(), p); return p; } @@ -518,7 +524,7 @@ namespace etl { iterator p = const_cast(position); - ETL_STD::copy(p + 1, end(), p); + etlstd::copy(p + 1, end(), p); back() = value; return p; @@ -544,8 +550,8 @@ namespace etl { iterator p = const_cast(first); - p = ETL_STD::copy(last, cend(), p); - ETL_STD::fill(p, end(), value); + p = etlstd::copy(last, cend(), p); + etlstd::fill(p, end(), value); return const_cast(first); } @@ -574,7 +580,7 @@ namespace etl template bool operator ==(const etl::array& lhs, const etl::array& rhs) { - return ETL_STD::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()); + return etlstd::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()); } //************************************************************************* @@ -598,7 +604,7 @@ namespace etl template bool operator <(const etl::array& lhs, const etl::array& rhs) { - return ETL_STD::lexicographical_compare(lhs.cbegin(), + return etlstd::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 1187e531..48242b41 100644 --- a/include/etl/array_view.h +++ b/include/etl/array_view.h @@ -40,7 +40,7 @@ SOFTWARE. #include "hash.h" #include "algorithm.h" -#include "stl/algorithm.h" +#include "algorithm.h" ///\defgroup array array /// A wrapper for arrays @@ -108,8 +108,8 @@ namespace etl typedef const T* const_pointer; typedef T* iterator; typedef const T* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* /// Default constructor. @@ -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_) + ETL_STD::distance(begin_, end_)) + mend(etl::addressof(*begin_) + etlstd::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_) + ETL_STD::distance(begin_, end_); + mend = etl::addressof(*begin_) + etlstd::distance(begin_, end_); } //************************************************************************* @@ -411,8 +411,14 @@ namespace etl //************************************************************************* void swap(array_view& other) { - ETL_STD::swap(mbegin, other.mbegin); - ETL_STD::swap(mend, other.mend); +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + + swap(mbegin, other.mbegin); + swap(mend, other.mend); } //************************************************************************* @@ -437,7 +443,7 @@ namespace etl friend bool operator == (const array_view& lhs, const array_view& rhs) { return (lhs.size() == rhs.size()) && - ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -453,7 +459,7 @@ namespace etl //************************************************************************* friend bool operator < (const array_view& lhs, const array_view& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etlstd::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 ab64120c..2f784563 100644 --- a/include/etl/array_wrapper.h +++ b/include/etl/array_wrapper.h @@ -93,8 +93,8 @@ namespace etl typedef const T* const_pointer; typedef T* iterator; typedef const T* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef typename etl::parameter_type::type parameter_t; @@ -310,19 +310,25 @@ namespace etl //************************************************************************* void fill(parameter_t value) { - ETL_STD::fill(begin(), end(), value); + etlstd::fill(begin(), end(), value); } //************************************************************************* /// Swaps the contents of arrays. //************************************************************************* template - typename etl::enable_if::value, void>::type + typename etlstd::enable_if::value, void>::type swap(etl::array_wrapper& other) { +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + for (size_t i = 0; i < SIZE; ++i) { - ETL_STD::swap(ARRAY_[i], other.begin()[i]); + swap(ARRAY_[i], other.begin()[i]); } } }; @@ -334,7 +340,7 @@ namespace etl bool operator == (const etl::array_wrapper& lhs, const etl::array_wrapper& rhs) { - return (SIZEL == SIZER) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (SIZEL == SIZER) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -354,7 +360,7 @@ namespace etl bool operator < (const etl::array_wrapper& lhs, const etl::array_wrapper& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etlstd::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 e2d51cd9..70ba31e7 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(etl::is_integral::value, "Only integral types are supported"); + ETL_STATIC_ASSERT(etlstd::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 50e0be01..bf32ba5c 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(etl::is_integral::value, "Only integral types are supported"); +// ETL_STATIC_ASSERT(etlstd::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 bacb384c..04a7fc0c 100644 --- a/include/etl/basic_string.h +++ b/include/etl/basic_string.h @@ -37,9 +37,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #include "char_traits.h" #include "container.h" @@ -282,11 +282,11 @@ namespace etl typedef const T* const_pointer; typedef T* iterator; typedef const T* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the string. @@ -418,12 +418,12 @@ namespace etl is_truncated = true; } - new_size = ETL_STD::min(new_size, CAPACITY); + new_size = etlstd::min(new_size, CAPACITY); // Size up? if (new_size > current_size) { - ETL_STD::fill(p_buffer + current_size, p_buffer + new_size, value); + etlstd::fill(p_buffer + current_size, p_buffer + new_size, value); } current_size = new_size; @@ -596,7 +596,7 @@ namespace etl is_truncated = (length_ > CAPACITY); - length_ = ETL_STD::min(length_, CAPACITY); + length_ = etlstd::min(length_, CAPACITY); etl::copy_n(other, length_, begin()); @@ -615,7 +615,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(string_iterator)); #endif @@ -643,9 +643,9 @@ namespace etl is_truncated = (n > CAPACITY); - n = ETL_STD::min(n, CAPACITY); + n = etlstd::min(n, CAPACITY); - ETL_STD::fill_n(begin(), n, value); + etlstd::fill_n(begin(), n, value); current_size = n; p_buffer[current_size] = 0; } @@ -780,7 +780,7 @@ namespace etl { // Insert in the middle. ++current_size; - ETL_STD::copy_backward(insert_position, end() - 1, end()); + etlstd::copy_backward(insert_position, end() - 1, end()); *insert_position = value; } else @@ -796,7 +796,7 @@ namespace etl if (position != end()) { // Insert in the middle. - ETL_STD::copy_backward(insert_position, end() - 1, end()); + etlstd::copy_backward(insert_position, end() - 1, end()); *insert_position = value; } @@ -823,7 +823,7 @@ namespace etl // Quick hack, as iterators are pointers. iterator insert_position = const_cast(position); - const size_t start = ETL_STD::distance(cbegin(), position); + const size_t start = etlstd::distance(cbegin(), position); // No effect. if (start >= CAPACITY) @@ -841,7 +841,7 @@ namespace etl } current_size = CAPACITY; - ETL_STD::fill(insert_position, end(), value); + etlstd::fill(insert_position, end(), value); } else { @@ -850,7 +850,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 = ETL_STD::min(max_shift_characters, remaining_characters); + const size_t characters_to_shift = etlstd::min(max_shift_characters, remaining_characters); // Will the string truncate? if ((start + shift_amount + remaining_characters) > CAPACITY) @@ -863,8 +863,8 @@ namespace etl current_size += shift_amount; } - ETL_STD::copy_backward(insert_position, insert_position + characters_to_shift, begin() + to_position + characters_to_shift); - ETL_STD::fill(insert_position, insert_position + shift_amount, value); + 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); } p_buffer[current_size] = 0; @@ -885,8 +885,8 @@ namespace etl return; } - const size_t start = ETL_STD::distance(begin(), position); - const size_t n = ETL_STD::distance(first, last); + const size_t start = etlstd::distance(begin(), position); + const size_t n = etlstd::distance(first, last); // No effect. if (start >= CAPACITY) @@ -917,7 +917,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 = ETL_STD::min(max_shift_characters, remaining_characters); + const size_t characters_to_shift = etlstd::min(max_shift_characters, remaining_characters); // Will the string truncate? if ((start + shift_amount + remaining_characters) > CAPACITY) @@ -930,7 +930,7 @@ namespace etl current_size += shift_amount; } - ETL_STD::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift); + etlstd::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift); while (first != last) { @@ -1037,7 +1037,7 @@ namespace etl etl::ibasic_string& erase(size_t position, size_t length_ = npos) { // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::min(length_, size() - position); erase(begin() + position, begin() + position + length_); @@ -1051,7 +1051,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - ETL_STD::copy(i_element + 1, end(), i_element); + etlstd::copy(i_element + 1, end(), i_element); p_buffer[--current_size] = 0; return i_element; @@ -1067,8 +1067,8 @@ namespace etl //********************************************************************* iterator erase(iterator first, iterator last) { - ETL_STD::copy(last, end(), first); - size_t n_delete = ETL_STD::distance(first, last); + etlstd::copy(last, end(), first); + size_t n_delete = etlstd::distance(first, last); current_size -= n_delete; p_buffer[current_size] = 0; @@ -1098,7 +1098,7 @@ namespace etl is_truncated = true; } - size_t endpos = ETL_STD::min(pos + len, size()); + size_t endpos = etlstd::min(pos + len, size()); for (size_t i = pos; i < endpos; ++i) { @@ -1120,7 +1120,7 @@ namespace etl return npos; } - const_iterator iposition = ETL_STD::search(begin() + pos, end(), str.begin(), str.end()); + const_iterator iposition = etlstd::search(begin() + pos, end(), str.begin(), str.end()); if (iposition == end()) { @@ -1128,7 +1128,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etlstd::distance(begin(), iposition); } } @@ -1146,7 +1146,7 @@ namespace etl } #endif - const_iterator iposition = ETL_STD::search(begin() + pos, end(), s, s + etl::strlen(s)); + const_iterator iposition = etlstd::search(begin() + pos, end(), s, s + etl::strlen(s)); if (iposition == end()) { @@ -1154,7 +1154,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etlstd::distance(begin(), iposition); } } @@ -1173,7 +1173,7 @@ namespace etl } #endif - const_iterator iposition = ETL_STD::search(begin() + pos, end(), s, s + n); + const_iterator iposition = etlstd::search(begin() + pos, end(), s, s + n); if (iposition == end()) { @@ -1181,7 +1181,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etlstd::distance(begin(), iposition); } } @@ -1192,11 +1192,11 @@ namespace etl //********************************************************************* size_t find(T c, size_t position = 0) const { - const_iterator i = ETL_STD::find(begin() + position, end(), c); + const_iterator i = etlstd::find(begin() + position, end(), c); if (i != end()) { - return ETL_STD::distance(begin(), i); + return etlstd::distance(begin(), i); } else { @@ -1223,7 +1223,7 @@ namespace etl position = size() - position; - const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), str.rbegin(), str.rend()); + const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), str.rbegin(), str.rend()); if (iposition == rend()) { @@ -1231,7 +1231,7 @@ namespace etl } else { - return size() - str.size() - ETL_STD::distance(rbegin(), iposition); + return size() - str.size() - etlstd::distance(rbegin(), iposition); } } @@ -1259,7 +1259,7 @@ namespace etl const_reverse_iterator srbegin(s + len); const_reverse_iterator srend(s); - const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), srbegin, srend); + const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), srbegin, srend); if (iposition == rend()) { @@ -1267,7 +1267,7 @@ namespace etl } else { - return size() - len - ETL_STD::distance(rbegin(), iposition); + return size() - len - etlstd::distance(rbegin(), iposition); } } @@ -1293,7 +1293,7 @@ namespace etl const_reverse_iterator srbegin(s + length_); const_reverse_iterator srend(s); - const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), srbegin, srend); + const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), srbegin, srend); if (iposition == rend()) { @@ -1301,7 +1301,7 @@ namespace etl } else { - return size() - length_ - ETL_STD::distance(rbegin(), iposition); + return size() - length_ - etlstd::distance(rbegin(), iposition); } } @@ -1319,11 +1319,11 @@ namespace etl position = size() - position; - const_reverse_iterator i = ETL_STD::find(rbegin() + position, rend(), c); + const_reverse_iterator i = etlstd::find(rbegin() + position, rend(), c); if (i != rend()) { - return size() - ETL_STD::distance(rbegin(), i) - 1; + return size() - etlstd::distance(rbegin(), i) - 1; } else { @@ -1342,7 +1342,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1388,8 +1388,8 @@ namespace etl ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds)); // Limit the lengths. - length_ = ETL_STD::min(length_, size() - position); - sublength = ETL_STD::min(sublength, str.size() - subposition); + length_ = etlstd::min(length_, size() - position); + sublength = etlstd::min(sublength, str.size() - subposition); // Erase the bit we want to replace. erase(position, length_); @@ -1413,7 +1413,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1450,7 +1450,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1487,7 +1487,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1554,7 +1554,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::min(length_, size() - position); return compare(p_buffer + position, p_buffer + position + length_, @@ -1571,8 +1571,8 @@ namespace etl ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds)); // Limit the lengths. - length_ = ETL_STD::min(length_, size() - position); - sublength = ETL_STD::min(sublength, str.size() - subposition); + length_ = etlstd::min(length_, size() - position); + sublength = etlstd::min(sublength, str.size() - subposition); return compare(p_buffer + position, p_buffer + position + length_, @@ -1712,7 +1712,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etlstd::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1745,7 +1745,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etlstd::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1869,7 +1869,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etlstd::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1907,7 +1907,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etlstd::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -2106,7 +2106,7 @@ namespace etl template bool operator ==(const etl::ibasic_string& lhs, const etl::ibasic_string& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2119,7 +2119,7 @@ namespace etl template bool operator ==(const etl::ibasic_string& lhs, const T* rhs) { - return (lhs.size() == etl::strlen(rhs)) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs); + return (lhs.size() == etl::strlen(rhs)) && etlstd::equal(lhs.begin(), lhs.end(), rhs); } //*************************************************************************** @@ -2132,7 +2132,7 @@ namespace etl template bool operator ==(const T* lhs, const etl::ibasic_string& rhs) { - return (rhs.size() == etl::strlen(lhs)) && ETL_STD::equal(rhs.begin(), rhs.end(), lhs); + return (rhs.size() == etl::strlen(lhs)) && etlstd::equal(rhs.begin(), rhs.end(), lhs); } @@ -2185,7 +2185,7 @@ namespace etl template bool operator <(const etl::ibasic_string& lhs, const etl::ibasic_string& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** @@ -2198,7 +2198,7 @@ namespace etl template bool operator <(const etl::ibasic_string& lhs, const T* rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs)); + return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs)); } //*************************************************************************** @@ -2211,7 +2211,7 @@ namespace etl template bool operator <(const T* lhs, const etl::ibasic_string& rhs) { - return ETL_STD::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end()); + return etlstd::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end()); } diff --git a/include/etl/binary.h b/include/etl/binary.h index 104f75e6..ff12ef7e 100644 --- a/include/etl/binary.h +++ b/include/etl/binary.h @@ -45,7 +45,7 @@ SOFTWARE. #include "exception.h" #include "error_handler.h" -#include "stl/limits.h" +#include "limits.h" #undef ETL_FILE #define ETL_FILE "50" @@ -110,7 +110,7 @@ namespace etl template T rotate_left(T value) { - ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Not an integral type"); + ETL_STATIC_ASSERT(etlstd::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(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_STD::numeric_limits::digits, "NBITS too large for return type"); + 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"); struct S { @@ -257,11 +257,11 @@ namespace etl template TReturn sign_extend(TValue value) { - 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_STD::numeric_limits::digits, "NBITS too large for return type"); - ETL_STATIC_ASSERT(SHIFT <= ETL_STD::numeric_limits::digits, "SHIFT too large"); + 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"); struct S { @@ -279,11 +279,11 @@ namespace etl template TReturn sign_extend(TValue value, const size_t NBITS) { - 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(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_ASSERT((NBITS <= ETL_STD::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); + ETL_ASSERT((NBITS <= etlstd::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(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(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_ASSERT((NBITS <= ETL_STD::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); + ETL_ASSERT((NBITS <= etlstd::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 etl::enable_if::value, bool>::type + typename etlstd::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 etl::enable_if::value, bool>::type + typename etlstd::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 36a2c0b0..44acb860 100644 --- a/include/etl/bit_stream.h +++ b/include/etl/bit_stream.h @@ -35,9 +35,8 @@ SOFTWARE. #include "etl/endianness.h" #include "etl/integral_limits.h" #include "etl/binary.h" - -#include "etl/stl/algorithm.h" -#include "etl/stl/iterator.h" +#include "etl/algorithm.h" +#include "etl/iterator.h" #include "private/minmax_push.h" @@ -68,7 +67,7 @@ namespace etl //*************************************************************************** bit_stream(char* begin_, char* end_) : pdata(reinterpret_cast(begin_)), - length(ETL_STD::distance(begin_, end_)) + length(etlstd::distance(begin_, end_)) { restart(); } @@ -78,7 +77,7 @@ namespace etl //*************************************************************************** bit_stream(unsigned char* begin_, unsigned char* end_) : pdata(begin_), - length(ETL_STD::distance(begin_, end_)) + length(etlstd::distance(begin_, end_)) { restart(); } @@ -128,7 +127,7 @@ namespace etl //*************************************************************************** void set_stream(char* begin_, char* end_) { - set_stream(begin_, ETL_STD::distance(begin_, end_)); + set_stream(begin_, etlstd::distance(begin_, end_)); } //*************************************************************************** @@ -136,7 +135,7 @@ namespace etl //*************************************************************************** void set_stream(unsigned char* begin_, unsigned char* end_) { - set_stream(begin_, ETL_STD::distance(begin_, end_)); + set_stream(begin_, etlstd::distance(begin_, end_)); } //*************************************************************************** @@ -181,7 +180,7 @@ namespace etl /// For integral types //*************************************************************************** template - typename etl::enable_if::value, bool>::type + typename etlstd::enable_if::value, bool>::type put(T value, uint_least8_t width = CHAR_BIT * sizeof(T)) { return put_integral(static_cast(value), width); @@ -207,7 +206,7 @@ namespace etl /// For floating point types //*************************************************************************** template - typename etl::enable_if::value, bool>::type + typename etlstd::enable_if::value, bool>::type put(T value) { bool success = true; @@ -250,7 +249,7 @@ namespace etl /// For integral types //*************************************************************************** template - typename etl::enable_if::value, bool>::type + typename etlstd::enable_if::value, bool>::type get(T& value, uint_least8_t width = CHAR_BIT * sizeof(T)) { bool success = false; @@ -266,7 +265,7 @@ namespace etl // Get the bits from the stream. while (width != 0) { - unsigned char mask_width = static_cast(ETL_STD::min(width, bits_in_byte)); + unsigned char mask_width = static_cast(etlstd::min(width, bits_in_byte)); unsigned char chunk = get_chunk(mask_width); width -= mask_width; @@ -278,7 +277,7 @@ namespace etl } // Sign extend if signed type and not already full bit width. - if (etl::is_signed::value && (bits != (CHAR_BIT * sizeof(T)))) + if (etlstd::is_signed::value && (bits != (CHAR_BIT * sizeof(T)))) { typedef typename etl::make_signed::type ST; value = etl::sign_extend(value, bits); @@ -291,7 +290,7 @@ namespace etl /// For floating point types //*************************************************************************** template - typename etl::enable_if::value, bool>::type + typename etlstd::enable_if::value, bool>::type get(T& value) { bool success = false; @@ -379,7 +378,7 @@ namespace etl // Send the bits to the stream. while (width != 0) { - unsigned char mask_width = static_cast(ETL_STD::min(width, bits_in_byte)); + unsigned char mask_width = static_cast(etlstd::min(width, bits_in_byte)); width -= mask_width; uint32_t mask = ((uint32_t(1U) << mask_width) - 1U) << width; @@ -412,7 +411,7 @@ namespace etl // Send the bits to the stream. while (width != 0) { - unsigned char mask_width = static_cast(ETL_STD::min(width, bits_in_byte)); + unsigned char mask_width = static_cast(etlstd::min(width, bits_in_byte)); width -= mask_width; uint64_t mask = ((uint64_t(1U) << mask_width) - 1U) << width; @@ -495,11 +494,11 @@ namespace etl // Network to host. if (etl::endianness::value() == etl::endian::little) { - ETL_STD::reverse_copy(data, data + sizeof(T), temp); + etlstd::reverse_copy(data, data + sizeof(T), temp); } else { - ETL_STD::copy(data, data + sizeof(T), temp); + etlstd::copy(data, data + sizeof(T), temp); } value = *reinterpret_cast(temp); @@ -516,11 +515,11 @@ namespace etl // Host to network. if (etl::endianness::value() == etl::endian::little) { - ETL_STD::reverse_copy(pf, pf + sizeof(T), data); + etlstd::reverse_copy(pf, pf + sizeof(T), data); } else { - ETL_STD::copy(pf, pf + sizeof(T), data); + etlstd::copy(pf, pf + sizeof(T), data); } } diff --git a/include/etl/bitset.h b/include/etl/bitset.h index 89fdd9b9..f68a16e4 100644 --- a/include/etl/bitset.h +++ b/include/etl/bitset.h @@ -37,8 +37,8 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" +#include "algorithm.h" +#include "iterator.h" #include "integral_limits.h" #include "algorithm.h" @@ -312,7 +312,7 @@ namespace etl { reset(); - size_t i = ETL_STD::min(NBITS, etl::strlen(text)); + size_t i = etlstd::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -329,7 +329,7 @@ namespace etl { reset(); - size_t i = ETL_STD::min(NBITS, etl::strlen(text)); + size_t i = etlstd::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -346,7 +346,7 @@ namespace etl { reset(); - size_t i = ETL_STD::min(NBITS, etl::strlen(text)); + size_t i = etlstd::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -363,7 +363,7 @@ namespace etl { reset(); - size_t i = ETL_STD::min(NBITS, etl::strlen(text)); + size_t i = etlstd::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -380,7 +380,7 @@ namespace etl { reset(); - size_t i = ETL_STD::min(NBITS, etl::strlen(text)); + size_t i = etlstd::min(NBITS, etl::strlen(text)); while (i > 0) { @@ -394,7 +394,7 @@ namespace etl /// Put to a value. //************************************************************************* template - typename etl::enable_if::value, T>::type + typename etlstd::enable_if::value, T>::type value() const { T v = T(0); @@ -746,7 +746,7 @@ namespace etl //************************************************************************* void swap(ibitset& other) { - ETL_STD::swap_ranges(pdata, pdata + SIZE, other.pdata); + etl::swap_ranges(pdata, pdata + SIZE, other.pdata); } protected: @@ -818,7 +818,7 @@ namespace etl //************************************************************************* static bool is_equal(const ibitset& lhs, const ibitset&rhs) { - return ETL_STD::equal(lhs.pdata, lhs.pdata + lhs.SIZE, rhs.pdata); + return etlstd::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 etl::enable_if::value, T>::type + typename etlstd::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 0ec97c38..dc498d15 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 (!etl::is_same::value) + if (!etlstd::is_same::value) { flags.set(get_hash(key)); } - if (!etl::is_same::value) + if (!etlstd::is_same::value) { flags.set(get_hash(key)); } @@ -127,13 +127,13 @@ namespace etl bool exists3 = true; // Do we have a second hash? - if (!etl::is_same::value) + if (!etlstd::is_same::value) { exists2 = flags[get_hash(key)]; } // Do we have a third hash? - if (!etl::is_same::value) + if (!etlstd::is_same::value) { exists3 = flags[get_hash(key)]; } diff --git a/include/etl/char_traits.h b/include/etl/char_traits.h index d0004d9b..cdbfe298 100644 --- a/include/etl/char_traits.h +++ b/include/etl/char_traits.h @@ -31,12 +31,11 @@ SOFTWARE. #ifndef ETL_CHAR_TRAITS_INCLUDED #define ETL_CHAR_TRAITS_INCLUDED -#include "platform.h" -#include "stdint.h" -#include "algorithm.h" +#include -#include "stl/algorithm.h" -#include "stl/iterator.h" +#include "platform.h" +#include "algorithm.h" +#include "iterator.h" //***************************************************************************** ///\defgroup char_traits char_traits @@ -141,7 +140,7 @@ namespace etl { if (p != 0) { - ETL_STD::fill_n(p, n, c); + etlstd::fill_n(p, n, c); } return p; @@ -156,9 +155,9 @@ namespace etl } else { - etl::copy_n(ETL_STD::reverse_iterator(src + count), + etl::copy_n(ETL_OR_STD::reverse_iterator(src + count), count, - ETL_STD::reverse_iterator(dest + count)); + ETL_OR_STD::reverse_iterator(dest + count)); } return dest; diff --git a/include/etl/compare.h b/include/etl/compare.h index 3fbb3e9f..fc23c418 100644 --- a/include/etl/compare.h +++ b/include/etl/compare.h @@ -33,8 +33,7 @@ SOFTWARE. #include "platform.h" #include "parameter_type.h" - -#include "stl/functional.h" +#include "functional.h" //***************************************************************************** ///\defgroup compare compare @@ -48,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 dfadbb53..572a6286 100644 --- a/include/etl/container.h +++ b/include/etl/container.h @@ -34,8 +34,7 @@ SOFTWARE. #include #include "platform.h" - -#include "stl/iterator.h" +#include "iterator.h" ///\defgroup container container ///\ingroup utilities @@ -177,9 +176,9 @@ namespace etl ///\ingroup container //***************************************************************************** template - ETL_CONSTEXPR ETL_STD::reverse_iterator rbegin(const TValue(&data)[ARRAY_SIZE]) + ETL_OR_STD::reverse_iterator rbegin(const TValue(&data)[ARRAY_SIZE]) { - return ETL_STD::reverse_iterator(&data[ARRAY_SIZE]); + return ETL_OR_STD::reverse_iterator(&data[ARRAY_SIZE]); } //***************************************************************************** @@ -187,9 +186,9 @@ namespace etl ///\ingroup container //***************************************************************************** template - ETL_CONSTEXPR ETL_STD::reverse_iterator crbegin(const TValue(&data)[ARRAY_SIZE]) + ETL_CONSTEXPR ETL_OR_STD::reverse_iterator crbegin(const TValue(&data)[ARRAY_SIZE]) { - return ETL_STD::reverse_iterator(&data[ARRAY_SIZE]); + return ETL_OR_STD::reverse_iterator(&data[ARRAY_SIZE]); } //***************************************************************************** @@ -227,9 +226,9 @@ namespace etl ///\ingroup container //***************************************************************************** template - ETL_CONSTEXPR ETL_STD::reverse_iterator rend(const TValue(&data)[ARRAY_SIZE]) + ETL_CONSTEXPR ETL_OR_STD::reverse_iterator rend(const TValue(&data)[ARRAY_SIZE]) { - return ETL_STD::reverse_iterator(&data[0]); + return ETL_OR_STD::reverse_iterator(&data[0]); } //***************************************************************************** @@ -237,31 +236,9 @@ namespace etl ///\ingroup container //***************************************************************************** template - ETL_CONSTEXPR ETL_STD::reverse_iterator crend(const TValue(&data)[ARRAY_SIZE]) + ETL_CONSTEXPR ETL_OR_STD::reverse_iterator crend(const TValue(&data)[ARRAY_SIZE]) { - return ETL_STD::reverse_iterator(&data[0]); - } - - //***************************************************************************** - /// Get the next iterator. - ///\ingroup container - //***************************************************************************** - template - TIterator next(TIterator iterator, ptrdiff_t n = 1) - { - ETL_STD::advance(iterator, n); - return iterator; - } - - //***************************************************************************** - /// Get the previous iterator. - ///\ingroup container - //***************************************************************************** - template - TIterator prev(TIterator iterator, ptrdiff_t n = 1) - { - ETL_STD::advance(iterator, -n); - return iterator; + return ETL_OR_STD::reverse_iterator(&data[0]); } ///************************************************************************** diff --git a/include/etl/cstring.h b/include/etl/cstring.h index 958279ab..9479f394 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_ = ETL_STD::min(length_, this->size() - position); + length_ = etlstd::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 1480152d..eedb774e 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 = etl::is_floating_point::value> + const bool IsIntegral = etlstd::is_integral::value, + const bool IsFloat = etlstd::is_floating_point::value> class cumulative_moving_average; //*************************************************************************** @@ -58,8 +58,8 @@ namespace etl template class cumulative_moving_average { - typedef typename etl::conditional::value, int32_t, uint32_t>::type scale_t; - typedef typename etl::conditional::value, int32_t, uint32_t>::type sample_t; + typedef typename etlstd::conditional::value, int32_t, uint32_t>::type scale_t; + typedef typename etlstd::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 etl::conditional::value, int32_t, uint32_t>::type scale_t; - typedef typename etl::conditional::value, int32_t, uint32_t>::type sample_t; + typedef typename etlstd::conditional::value, int32_t, uint32_t>::type scale_t; + typedef typename etlstd::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 dadcb277..b4173bc6 100644 --- a/include/etl/cyclic_value.h +++ b/include/etl/cyclic_value.h @@ -43,7 +43,7 @@ SOFTWARE. #include "static_assert.h" #include "type_traits.h" -#include "stl/algorithm.h" +#include "algorithm.h" namespace etl { @@ -257,7 +257,13 @@ namespace etl //************************************************************************* void swap(cyclic_value& other) { - ETL_STD::swap(value, other.value); +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + + swap(value, other.value); } //************************************************************************* @@ -298,7 +304,7 @@ namespace etl ///\ingroup cyclic_value //*************************************************************************** template - class cyclic_value::type> + class cyclic_value::type> { public: @@ -531,9 +537,15 @@ namespace etl //************************************************************************* void swap(cyclic_value& other) { - ETL_STD::swap(first_value, other.first_value); - ETL_STD::swap(last_value, other.last_value); - ETL_STD::swap(value, other.value); +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + + swap(first_value, other.first_value); + swap(last_value, other.last_value); + swap(value, other.value); } //************************************************************************* diff --git a/include/etl/deque.h b/include/etl/deque.h index 8f340ec0..94bddb7e 100644 --- a/include/etl/deque.h +++ b/include/etl/deque.h @@ -38,9 +38,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "utility.h" #include "container.h" #include "alignment.h" @@ -239,7 +239,7 @@ namespace etl #endif typedef T* pointer; typedef const T* const_pointer; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 && !etl::is_floating_point::value> + struct is_iterator : public etl::integral_constant::value && !etlstd::is_floating_point::value> { }; @@ -256,7 +256,7 @@ namespace etl //************************************************************************* /// Iterator //************************************************************************* - struct iterator : public etl::iterator + struct iterator : public etl::iterator { friend class ideque; @@ -421,7 +421,13 @@ namespace etl //*************************************************** void swap(iterator& other) { - ETL_STD::swap(index, other.index); +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + + swap(index, other.index); } private: @@ -442,7 +448,7 @@ namespace etl //************************************************************************* /// Const Iterator //************************************************************************* - struct const_iterator : public etl::iterator + struct const_iterator : public etl::iterator { friend class ideque; @@ -603,7 +609,7 @@ namespace etl //*************************************************** void swap(const_iterator& other) { - ETL_STD::swap(index, other.index); + swap(index, other.index); } private: @@ -634,14 +640,14 @@ namespace etl pointer p_buffer; }; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* /// Assigns a range to the deque. //************************************************************************* template - typename etl::enable_if::value, void>::type + typename etlstd::enable_if::value, void>::type assign(TIterator range_begin, TIterator range_end) { initialise(); @@ -893,13 +899,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etlstd::copy(_begin + 1, position, _begin); // Write the new value. *--position = value; @@ -910,7 +916,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etlstd::copy_backward(position, _end - 2, _end - 1); // Write the new value. *position = value; @@ -935,38 +941,38 @@ namespace etl if (insert_position == begin()) { - create_element_front(ETL_STD::move(value)); + create_element_front(etlstd::move(value)); position = _begin; } else if (insert_position == end()) { - create_element_back(ETL_STD::move(value)); + create_element_back(etlstd::move(value)); position = _end - 1; } else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) { // Construct the _begin. - create_element_front(ETL_STD::move(*_begin)); + create_element_front(etlstd::move(*_begin)); // Move the values. - ETL_STD::move(_begin + 1, position, _begin); + etlstd::move(_begin + 1, position, _begin); // Write the new value. - *--position = ETL_STD::move(value); + *--position = etlstd::move(value); } else { // Construct the _end. - create_element_back(ETL_STD::move(*(_end - 1))); + create_element_back(etlstd::move(*(_end - 1))); // Move the values. - ETL_STD::move_backward(position, _end - 2, _end - 1); + etlstd::move_backward(position, _end - 2, _end - 1); // Write the new value. - *position = ETL_STD::move(value); + *position = etlstd::move(value); } } @@ -1008,13 +1014,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etlstd::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1027,7 +1033,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etlstd::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1035,7 +1041,7 @@ namespace etl } } - ::new (p) T(ETL_STD::forward(args)...); + ::new (p) T(etlstd::forward(args)...); return position; } @@ -1075,13 +1081,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etlstd::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1094,7 +1100,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etlstd::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1140,13 +1146,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etlstd::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1159,7 +1165,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etlstd::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1205,13 +1211,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etlstd::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1224,7 +1230,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etlstd::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1270,13 +1276,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etlstd::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1289,7 +1295,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etlstd::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1343,8 +1349,8 @@ namespace etl if (distance(_begin, insert_position) <= difference_type(current_size / 2)) { size_t n_insert = n; - size_t n_move = ETL_STD::distance(begin(), position); - size_t n_create_copy = ETL_STD::min(n_insert, n_move); + size_t n_move = etlstd::distance(begin(), position); + size_t n_create_copy = etlstd::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; @@ -1372,15 +1378,15 @@ namespace etl // Copy new. to = position - n_create_copy; - ETL_STD::fill_n(to, n_copy_new, value); + etlstd::fill_n(to, n_copy_new, value); position = _begin + n_move; } else { size_t n_insert = n; - size_t n_move = ETL_STD::distance(position, end()); - size_t n_create_copy = ETL_STD::min(n_insert, n_move); + size_t n_move = etlstd::distance(position, end()); + size_t n_create_copy = etlstd::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; @@ -1400,10 +1406,10 @@ namespace etl } // Copy old. - ETL_STD::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); + etlstd::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); // Copy new. - ETL_STD::fill_n(position, n_copy_new, value); + etlstd::fill_n(position, n_copy_new, value); } } @@ -1423,7 +1429,7 @@ namespace etl { iterator position; - difference_type n = ETL_STD::distance(range_begin, range_end); + difference_type n = etlstd::distance(range_begin, range_end); ETL_ASSERT((current_size + n) <= CAPACITY, ETL_ERROR(deque_full)); @@ -1451,8 +1457,8 @@ namespace etl if (distance(_begin, insert_position) < difference_type(current_size / 2)) { size_t n_insert = n; - size_t n_move = ETL_STD::distance(begin(), position); - size_t n_create_copy = ETL_STD::min(n_insert, n_move); + size_t n_move = etlstd::distance(begin(), position); + size_t n_create_copy = etlstd::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; @@ -1482,8 +1488,8 @@ namespace etl else { size_t n_insert = n; - size_t n_move = ETL_STD::distance(position, end()); - size_t n_create_copy = ETL_STD::min(n_insert, n_move); + size_t n_move = etlstd::distance(position, end()); + size_t n_create_copy = etlstd::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; @@ -1504,7 +1510,7 @@ namespace etl } // Copy old. - ETL_STD::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); + etlstd::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); // Copy new. item = range_begin; @@ -1541,13 +1547,13 @@ namespace etl // Are we closer to the front? if (distance(_begin, position) < difference_type(current_size / 2)) { - ETL_STD::copy_backward(_begin, position, position + 1); + etlstd::copy_backward(_begin, position, position + 1); destroy_element_front(); ++position; } else { - ETL_STD::copy(position + 1, _end, position); + etlstd::copy(position + 1, _end, position); destroy_element_back(); } } @@ -1568,7 +1574,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 = ETL_STD::distance(range_begin, range_end); + size_t length = etlstd::distance(range_begin, range_end); // At the beginning? if (position == _begin) @@ -1597,7 +1603,7 @@ namespace etl if (distance(_begin, position) < difference_type(current_size / 2)) { // Move the items. - ETL_STD::copy_backward(_begin, position, position + length); + etlstd::copy_backward(_begin, position, position + length); for (size_t i = 0; i < length; ++i) { @@ -1610,7 +1616,7 @@ namespace etl // Must be closer to the back. { // Move the items. - ETL_STD::copy(position + length, _end, position); + etlstd::copy(position + length, _end, position); for (size_t i = 0; i < length; ++i) { @@ -1646,7 +1652,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(deque_full)); #endif - create_element_back(ETL_STD::move(item)); + create_element_back(etlstd::move(item)); } #endif @@ -1662,7 +1668,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(deque_full)); #endif - ::new (&(*_end)) T(ETL_STD::forward(args)...); + ::new (&(*_end)) T(etlstd::forward(args)...); ++_end; ++current_size; ETL_INCREMENT_DEBUG_COUNT @@ -1774,7 +1780,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(deque_full)); #endif - create_element_front(ETL_STD::move(item)); + create_element_front(etlstd::move(item)); } #endif @@ -1791,7 +1797,7 @@ namespace etl #endif --_begin; - ::new (&(*_begin)) T(ETL_STD::forward(args)...); + ::new (&(*_begin)) T(etlstd::forward(args)...); ++current_size; ETL_INCREMENT_DEBUG_COUNT } @@ -1965,7 +1971,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etlstd::move(*itr)); ++itr; } @@ -2117,7 +2123,7 @@ namespace etl void create_element_front(rvalue_reference value) { --_begin; - ::new (&(*_begin)) T(ETL_STD::move(value)); + ::new (&(*_begin)) T(etlstd::move(value)); ++current_size; ETL_INCREMENT_DEBUG_COUNT } @@ -2127,7 +2133,7 @@ namespace etl //********************************************************************* void create_element_back(rvalue_reference value) { - ::new (&(*_end)) T(ETL_STD::move(value)); + ::new (&(*_end)) T(etlstd::move(value)); ++_end; ++current_size; ETL_INCREMENT_DEBUG_COUNT @@ -2233,7 +2239,7 @@ namespace etl typedef T& reference; typedef const T& const_reference; typedef size_t size_type; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; //************************************************************************* /// Default constructor. @@ -2278,7 +2284,7 @@ namespace etl typename etl::ideque::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -2342,7 +2348,7 @@ namespace etl typename etl::ideque::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -2371,7 +2377,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]; }; //*************************************************************************** @@ -2384,7 +2390,7 @@ namespace etl template bool operator ==(const etl::ideque& lhs, const etl::ideque& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2410,10 +2416,10 @@ namespace etl template bool operator <(const etl::ideque& lhs, const etl::ideque& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), - lhs.end(), - rhs.begin(), - rhs.end()); + return etlstd::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 877babb6..8fdaf77e 100644 --- a/include/etl/fixed_iterator.h +++ b/include/etl/fixed_iterator.h @@ -34,7 +34,7 @@ SOFTWARE. #include "platform.h" #include "iterator.h" -#include "stl/iterator.h" +#include "iterator.h" ///\defgroup iterator Iterator types @@ -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 ETL_STD::iterator_traits::value_type> + class fixed_iterator : etl::iterator::iterator_category, typename etlstd::iterator_traits::value_type> { public: @@ -100,7 +100,7 @@ namespace etl //*************************************************************************** /// Dereference operator. //*************************************************************************** - typename ETL_STD::iterator_traits::value_type operator *() + typename etlstd::iterator_traits::value_type operator *() { return *it; } @@ -108,7 +108,7 @@ namespace etl //*************************************************************************** /// Dereference operator. //*************************************************************************** - const typename ETL_STD::iterator_traits::value_type operator *() const + const typename etlstd::iterator_traits::value_type operator *() const { return *it; } @@ -140,7 +140,7 @@ namespace etl //*************************************************************************** /// += operator. //*************************************************************************** - fixed_iterator& operator +=(typename ETL_STD::iterator_traits::difference_type /*offset*/) + fixed_iterator& operator +=(typename etlstd::iterator_traits::difference_type /*offset*/) { return *this; } @@ -148,7 +148,7 @@ namespace etl //*************************************************************************** /// -= operator. //*************************************************************************** - fixed_iterator& operator -=(typename ETL_STD::iterator_traits::difference_type /*offset*/) + fixed_iterator& operator -=(typename etlstd::iterator_traits::difference_type /*offset*/) { return *this; } @@ -181,7 +181,7 @@ namespace etl //***************************************************************************** template etl::fixed_iterator& operator +(etl::fixed_iterator& lhs, - typename ETL_STD::iterator_traits::difference_type /*rhs*/) + typename etlstd::iterator_traits::difference_type /*rhs*/) { return lhs; } @@ -191,7 +191,7 @@ namespace etl //***************************************************************************** template etl::fixed_iterator& operator -(etl::fixed_iterator& lhs, - typename ETL_STD::iterator_traits::difference_type /*rhs*/) + typename etlstd::iterator_traits::difference_type /*rhs*/) { return lhs; } @@ -200,7 +200,7 @@ namespace etl /// - fixed_iterator operator. //***************************************************************************** template - typename ETL_STD::iterator_traits::difference_type operator -(etl::fixed_iterator& lhs, + typename etlstd::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 8375e9a9..1ba17f4b 100644 --- a/include/etl/flat_map.h +++ b/include/etl/flat_map.h @@ -40,7 +40,7 @@ SOFTWARE. #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_NO_STL) #include #endif -#include "stl/utility.h" +#include "utility.h" #undef ETL_FILE #define ETL_FILE "2" @@ -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: @@ -85,9 +85,9 @@ namespace etl typedef typename refmap_t::iterator iterator; typedef typename refmap_t::const_iterator const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; protected: @@ -268,7 +268,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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(ETL_STD::forward(args)...); + ::new ((void*)etl::addressof(pvalue->second)) mapped_type(etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etlstd::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 0069ea92..fcdfd017 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: @@ -86,9 +86,9 @@ namespace etl typedef typename refmap_t::iterator iterator; typedef typename refmap_t::const_iterator const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; protected: @@ -237,7 +237,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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(ETL_STD::forward(args)...); + ::new ((void*)etl::addressof(pvalue->second)) mapped_type(etlstd::forward(args)...); iterator i_element = lower_bound(key); ETL_INCREMENT_DEBUG_COUNT @@ -431,7 +431,7 @@ namespace etl } else { - size_t d = ETL_STD::distance(range.first, range.second); + size_t d = etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etlstd::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 931f61c6..0014d1e2 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: @@ -80,9 +80,9 @@ namespace etl typedef typename refset_t::iterator iterator; typedef typename refset_t::const_iterator const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; protected: @@ -209,7 +209,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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 = ETL_STD::lower_bound(begin(), end(), value, compare); + iterator i_element = etlstd::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(ETL_STD::forward(args)...); + ::new (pvalue) value_type(etlstd::forward(args)...); iterator i_element = lower_bound(*pvalue); @@ -385,7 +385,7 @@ namespace etl } else { - size_t d = ETL_STD::distance(range.first, range.second); + size_t d = etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etlstd::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 9b0e2d76..6884e410 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: @@ -82,9 +82,9 @@ namespace etl typedef typename refset_t::iterator iterator; typedef typename refset_t::const_iterator const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; protected: @@ -211,7 +211,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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(ETL_STD::forward(args)...); + ::new (pvalue) value_type(etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etlstd::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 76e03ac8..7cabec02 100644 --- a/include/etl/forward_list.h +++ b/include/etl/forward_list.h @@ -37,10 +37,10 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" #include "pool.h" #include "container.h" @@ -404,7 +404,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -492,7 +492,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -572,7 +572,7 @@ namespace etl const node_t* p_node; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 = ETL_STD::distance(first, last); + difference_type d = etlstd::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(ETL_STD::move(value)); + data_node_t& data_node = allocate_data_node(etlstd::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(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etlstd::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(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etlstd::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 = ETL_STD::distance(first, last); + difference_type d = etlstd::distance(first, last); ETL_ASSERT((d + size()) <= MAX_SIZE, ETL_ERROR(forward_list_full)); #endif @@ -1141,7 +1141,7 @@ namespace etl //************************************************************************* void unique() { - unique(ETL_STD::equal_to()); + unique(etlstd::equal_to()); } //************************************************************************* @@ -1182,7 +1182,7 @@ namespace etl //************************************************************************* void sort() { - sort(ETL_STD::less()); + sort(etlstd::less()); } //************************************************************************* @@ -1386,7 +1386,7 @@ namespace etl //************************************************************************* iforward_list& operator = (iforward_list&& rhs) { - move_container(ETL_STD::move(rhs)); + move_container(etlstd::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(ETL_STD::move(value)); + ::new (&(p_node->value)) T(etlstd::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(ETL_STD::move(*first++)); + data_node_t& data_node = this->allocate_data_node(etlstd::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(ETL_STD::move(other)); + this->move_container(etlstd::move(other)); } #endif @@ -1686,7 +1686,7 @@ namespace etl forward_list& operator = (forward_list&& rhs) { - this->move_container(ETL_STD::move(rhs)); + this->move_container(etlstd::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(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -1831,7 +1831,7 @@ namespace etl //************************************************************************* forward_list& operator = (forward_list&& rhs) { - this->move_container(ETL_STD::move(rhs)); + this->move_container(etlstd::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()) && - ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -1887,10 +1887,7 @@ namespace etl template bool operator <(const etl::iforward_list& lhs, const etl::iforward_list& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), - lhs.end(), - rhs.begin(), - rhs.end()); + return etlstd::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 a1ed9028..7873d4e2 100644 --- a/include/etl/frame_check_sequence.h +++ b/include/etl/frame_check_sequence.h @@ -34,7 +34,7 @@ SOFTWARE. #include "type_traits.h" #include "binary.h" -#include "stl/iterator.h" +#include "iterator.h" ETL_STATIC_ASSERT(ETL_8BIT_SUPPORT, "This file does not currently support targets with no 8bit type"); @@ -56,7 +56,7 @@ namespace etl typedef TPolicy policy_type; typedef typename policy_type::value_type value_type; - ETL_STATIC_ASSERT(etl::is_unsigned::value, "Signed frame check type not supported"); + ETL_STATIC_ASSERT(etlstd::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 ETL_STD::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etlstd::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 ETL_STD::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Type not supported"); while (begin != end) { diff --git a/include/etl/functional.h b/include/etl/functional.h index 68300759..46f1f5ac 100644 --- a/include/etl/functional.h +++ b/include/etl/functional.h @@ -39,7 +39,7 @@ SOFTWARE. ///\defgroup reference_wrapper reference_wrapper ///\ingroup functional -namespace etl +namespace etlstd { //*************************************************************************** /// A definition of reference_wrapper for those that don't have C++ 0x11 support. @@ -105,6 +105,130 @@ namespace etl { return reference_wrapper(t.get()); } + + //*************************************************************************** + template + struct less + { + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const + { + return lhs < rhs; + } + }; + + //*************************************************************************** + template + struct greater + { + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const + { + return lhs > rhs; + } + }; + + //*************************************************************************** + template + struct equal_to + { + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const + { + return lhs == rhs; + } + }; + + //*************************************************************************** + template + struct not_equal_to + { + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const + { + return lhs != rhs; + } + }; + + //*************************************************************************** + + template + struct unary_function + { + typedef TArgumentType argument_type; + typedef TResultType result_type; + }; + + //*************************************************************************** + + template + struct binary_function + { + typedef TFirstArgumentType first_argument_type; + typedef TSecondArgumentType second_argument_type; + typedef TResultType result_type; + }; + + //*************************************************************************** + + template + class binder1st : public etlstd::unary_function + { + protected: + + TFunction operation; + typename TFunction::first_argument_type value; + + public: + + binder1st(const TFunction& f, const typename TFunction::first_argument_type& v) + : operation(f), value(v) + { + } + + typename TFunction::result_type operator()(typename TFunction::second_argument_type& x) const + { + return operation(value, x); + } + + typename TFunction::result_type operator()(const typename TFunction::second_argument_type& x) const + { + return operation(value, x); + } + }; + + template + binder1st bind1st(const F& f, const T& x) + { + return binder1st(f, x); + } + + //*************************************************************************** + + template + class binder2nd : public etlstd::unary_function + { + protected: + TFunction operation; + typename TFunction::second_argument_type value; + public: + binder2nd(const TFunction& f, const typename TFunction::second_argument_type& v) + : operation(f), value(v) + { + } + + typename TFunction::result_type operator()(typename TFunction::first_argument_type& x) const + { + return operation(x, value); + } + + typename TFunction::result_type operator()(const typename TFunction::first_argument_type& x) const + { + return operation(x, value); + } + }; + + template + binder2nd bind2nd(const F& f, const T& x) + { + return binder2nd(f, x); + } } #endif diff --git a/include/etl/ihash.h b/include/etl/ihash.h index 18d11bca..22160f91 100644 --- a/include/etl/ihash.h +++ b/include/etl/ihash.h @@ -35,7 +35,7 @@ SOFTWARE. #include "platform.h" -#include "stl/utility.h" +#include "utility.h" #include "exception.h" #include "error_handler.h" diff --git a/include/etl/indirect_vector.h b/include/etl/indirect_vector.h index 238030be..68e820bc 100644 --- a/include/etl/indirect_vector.h +++ b/include/etl/indirect_vector.h @@ -35,9 +35,8 @@ SOFTWARE. #include "vector.h" #include "pool.h" #include "iterator.h" - -#include "stl/iterator.h" -#include "stl/functional.h" +#include "iterator.h" +#include "functional.h" #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_NO_STL) #include @@ -183,7 +182,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -329,7 +328,7 @@ namespace etl //************************************************************************* /// const_iterator. //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -459,8 +458,8 @@ namespace etl indirect_const_iterator lookup_itr; }; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; protected: @@ -717,10 +716,10 @@ namespace etl template void assign(TIterator first, TIterator last) { - ETL_STATIC_ASSERT((etl::is_same::type, typename etl::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); + ETL_STATIC_ASSERT((etlstd::is_same::type, typename etlstd::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::distance(first, last); ETL_ASSERT(static_cast(d) <= capacity(), ETL_ERROR(vector_full)); #endif @@ -786,7 +785,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(size() != capacity(), ETL_ERROR(vector_full)); #endif - T* p = storage.create(ETL_STD::move(value)); + T* p = storage.create(etlstd::move(value)); lookup.push_back(p); } #endif @@ -800,7 +799,7 @@ namespace etl template void emplace_back(Args && ... args) { - T* p = storage.create(ETL_STD::forward(args)...); + T* p = storage.create(etlstd::forward(args)...); lookup.push_back(p); } #else @@ -892,7 +891,7 @@ namespace etl { ETL_ASSERT(size() + 1 <= capacity(), ETL_ERROR(vector_full)); - T* p = storage.create(T(ETL_STD::move(value))); + T* p = storage.create(T(etlstd::move(value))); position = iterator(lookup.insert(position.lookup_itr, p)); return position; @@ -908,7 +907,7 @@ namespace etl { ETL_ASSERT(!full(), ETL_ERROR(vector_full)); - T* p = storage.create(T(ETL_STD::forward(args)...)); + T* p = storage.create(T(etlstd::forward(args)...)); position = iterator(lookup.insert(position.lookup_itr, p)); return position; @@ -991,7 +990,7 @@ namespace etl template void insert(iterator position, TIterator first, TIterator last) { - size_t count = size_t(ETL_STD::distance(first, last)); + size_t count = size_t(etlstd::distance(first, last)); ETL_ASSERT((size() + count) <= capacity(), ETL_ERROR(vector_full)); @@ -1067,7 +1066,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etlstd::move(*itr)); ++itr; } @@ -1172,7 +1171,7 @@ namespace etl while (itr != other.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etlstd::move(*itr)); ++itr; } @@ -1213,7 +1212,7 @@ namespace etl template bool operator ==(const etl::iindirect_vector& lhs, const etl::iindirect_vector& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1239,7 +1238,7 @@ namespace etl template bool operator <(const etl::iindirect_vector& lhs, const etl::iindirect_vector& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** @@ -1376,7 +1375,7 @@ namespace etl indirect_vector(indirect_vector&& other) : etl::iindirect_vector(lookup_vector, storage_pool) { - this->move_container(ETL_STD::move(other)); + this->move_container(etlstd::move(other)); } //************************************************************************* @@ -1384,7 +1383,7 @@ namespace etl //************************************************************************* indirect_vector& operator = (indirect_vector&& rhs) { - this->move_container(ETL_STD::move(rhs)); + this->move_container(etlstd::move(rhs)); return *this; } @@ -1504,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(ETL_STD::move(other)); + this->move_container(etlstd::move(other)); } //************************************************************************* @@ -1512,7 +1511,7 @@ namespace etl //************************************************************************* indirect_vector& operator = (indirect_vector&& rhs) { - this->move_container(ETL_STD::move(rhs)); + this->move_container(etlstd::move(rhs)); return *this; } diff --git a/include/etl/integral_limits.h b/include/etl/integral_limits.h index 2c95c0a3..4d06c57b 100644 --- a/include/etl/integral_limits.h +++ b/include/etl/integral_limits.h @@ -74,7 +74,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -86,7 +86,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -95,10 +95,10 @@ namespace etl template <> struct integral_limits { - 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 char min = (etlstd::is_signed::value) ? SCHAR_MIN : 0; + static const char max = (etlstd::is_signed::value) ? SCHAR_MAX : char(UCHAR_MAX); static const int bits = CHAR_BIT; - static const bool is_signed = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -110,7 +110,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -122,7 +122,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -134,7 +134,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -146,7 +146,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -158,7 +158,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -170,7 +170,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; #ifndef LLONG_MAX @@ -194,7 +194,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; //*************************************************************************** @@ -206,7 +206,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 = etl::is_signed::value; + static const bool is_signed = etlstd::is_signed::value; }; } diff --git a/include/etl/intrusive_forward_list.h b/include/etl/intrusive_forward_list.h index 879865f5..253abba2 100644 --- a/include/etl/intrusive_forward_list.h +++ b/include/etl/intrusive_forward_list.h @@ -33,9 +33,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #include "private/minmax_push.h" @@ -153,7 +153,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - intmax_t d = ETL_STD::distance(first, last); + intmax_t d = etlstd::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(intrusive_forward_list_iterator_exception)); #endif @@ -328,7 +328,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -418,7 +418,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -495,7 +495,7 @@ namespace etl const value_type* p_value; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; //************************************************************************* /// Constructor. @@ -651,7 +651,7 @@ namespace etl { if (first != end() && (first != last)) { - this->current_size -= ETL_STD::distance(first, last) - 1; + this->current_size -= etlstd::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(ETL_STD::less()); + sort(etlstd::less()); } //************************************************************************* @@ -958,7 +958,7 @@ namespace etl { if (&other != this) { - size_t n = ETL_STD::distance(begin_, end_) - 1; + size_t n = etlstd::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, ETL_STD::less()); + merge(other, etlstd::less()); } //************************************************************************* diff --git a/include/etl/intrusive_links.h b/include/etl/intrusive_links.h index d018f4e8..1a652f56 100644 --- a/include/etl/intrusive_links.h +++ b/include/etl/intrusive_links.h @@ -39,8 +39,8 @@ SOFTWARE. #include "exception.h" #include "error_handler.h" -#include "stl/utility.h" -#include "stl/algorithm.h" +#include "utility.h" +#include "algorithm.h" #undef ETL_FILE #define ETL_FILE "22" @@ -110,7 +110,7 @@ namespace etl // Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink& lhs, TLink& rhs) { lhs.etl_next = &rhs; @@ -118,7 +118,7 @@ namespace etl // Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::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 etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink* lhs, TLink* rhs) { if (lhs != nullptr) @@ -138,7 +138,7 @@ namespace etl // Pointer, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink* lhs, TLink* rhs) { if (lhs != nullptr) @@ -154,7 +154,7 @@ namespace etl // Reference, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink& lhs, TLink* rhs) { lhs.etl_next = rhs; @@ -162,7 +162,7 @@ namespace etl // Reference, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink& lhs, TLink* rhs) { if (rhs != nullptr) @@ -175,7 +175,7 @@ namespace etl // Pointer, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink* lhs, TLink& rhs) { if (lhs != nullptr) @@ -186,7 +186,7 @@ namespace etl // Pointer, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::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 etl::enable_if >::value, void>::type + typename etlstd::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 etl::enable_if >::value, void>::type + typename etlstd::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 etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type unlink_after(TLink& node) { if (node.etl_next != nullptr) @@ -235,7 +235,7 @@ namespace etl // Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type unlink_after(TLink& before, TLink& last) { before.etl_next = last.etl_next; @@ -265,7 +265,13 @@ namespace etl void reverse() { - ETL_STD::swap(etl_previous, etl_next); +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + + swap(etl_previous, etl_next); } bidirectional_link* etl_previous; @@ -289,7 +295,7 @@ namespace etl // Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink& lhs, TLink& rhs) { lhs.etl_next = &rhs; @@ -298,7 +304,7 @@ namespace etl // Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink& lhs, TLink& rhs) { rhs.etl_next = lhs.etl_next; @@ -314,7 +320,7 @@ namespace etl // Pointer, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink* lhs, TLink* rhs) { if (lhs != nullptr) @@ -330,7 +336,7 @@ namespace etl // Pointer, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink* lhs, TLink* rhs) { if (rhs != nullptr) @@ -356,7 +362,7 @@ namespace etl // Reference, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink& lhs, TLink* rhs) { lhs.etl_next = rhs; @@ -369,7 +375,7 @@ namespace etl // Reference, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink& lhs, TLink* rhs) { if (rhs != nullptr) @@ -388,7 +394,7 @@ namespace etl // Pointer, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link(TLink* lhs, TLink& rhs) { if (lhs != nullptr) @@ -401,7 +407,7 @@ namespace etl // Pointer, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink* lhs, TLink& rhs) { if (lhs != nullptr) @@ -424,7 +430,7 @@ namespace etl // Reference, Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink& lhs, TLink& first, TLink& last) { last.etl_next = lhs.etl_next; @@ -440,7 +446,7 @@ namespace etl // Pointer, Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_splice(TLink* lhs, TLink& first, TLink& last) { if (lhs != nullptr) @@ -467,7 +473,7 @@ namespace etl // Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type unlink(TLink& node) { node.unlink(); @@ -475,7 +481,7 @@ namespace etl // Reference Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type unlink(TLink& first, TLink& last) { if (&first == &last) @@ -526,7 +532,7 @@ namespace etl // Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_left(TLink& parent, TLink& leaf) { parent.etl_left = &leaf; @@ -534,7 +540,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_right(TLink& parent, TLink& leaf) { parent.etl_right = &leaf; @@ -543,7 +549,7 @@ namespace etl // Pointer, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_left(TLink* parent, TLink* leaf) { if (parent != nullptr) @@ -558,7 +564,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_right(TLink* parent, TLink* leaf) { if (parent != nullptr) @@ -574,7 +580,7 @@ namespace etl // Reference, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_left(TLink& parent, TLink* leaf) { parent.etl_left = leaf; @@ -586,7 +592,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_right(TLink& parent, TLink* leaf) { parent.etl_right = leaf; @@ -599,7 +605,7 @@ namespace etl // Pointer, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_left(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -611,7 +617,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_right(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -624,7 +630,7 @@ namespace etl // Reference, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_left(TLink& parent, TLink& leaf) { parent.etl_right = leaf.etl_left; @@ -640,7 +646,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_right(TLink& parent, TLink& leaf) { parent.etl_left = leaf.etl_right; @@ -657,7 +663,7 @@ namespace etl // Pointer, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_left(TLink* parent, TLink* leaf) { if ((parent != nullptr) && (leaf != nullptr)) @@ -667,7 +673,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_right(TLink* parent, TLink* leaf) { if ((parent != nullptr) && (leaf != nullptr)) @@ -678,7 +684,7 @@ namespace etl // Reference, Pointer template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_left(TLink& parent, TLink* leaf) { if (leaf != nullptr) @@ -688,7 +694,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_right(TLink& parent, TLink* leaf) { if (leaf != nullptr) @@ -699,7 +705,7 @@ namespace etl // Pointer, Reference template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_left(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -709,7 +715,7 @@ namespace etl } template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate_right(TLink* parent, TLink& leaf) { if (parent != nullptr) @@ -721,7 +727,7 @@ namespace etl // Reference, Reference /// Automatically detects whether a left or right rotate is expected. template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate(TLink& parent, TLink& leaf) { if (parent.etl_left == &leaf) @@ -737,7 +743,7 @@ namespace etl // Pointer, Pointer /// Automatically detects whether a left or right rotate is expected. template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate(TLink* parent, TLink* leaf) { if ((parent != nullptr) && (leaf != nullptr)) @@ -756,7 +762,7 @@ namespace etl // Reference, Pointer /// Automatically detects whether a left or right rotate is expected. template - typename etl::enable_if >::value, void>::type + typename etlstd::enable_if >::value, void>::type link_rotate(TLink& parent, TLink* leaf) { if (leaf != nullptr) @@ -775,7 +781,7 @@ namespace etl // Pointer, Reference /// Automatically detects whether a left or right rotate is expected. template - typename etl::enable_if >::value, void>::type + typename etlstd::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 059bb121..ddc691ce 100644 --- a/include/etl/intrusive_list.h +++ b/include/etl/intrusive_list.h @@ -47,9 +47,9 @@ SOFTWARE. #include "algorithm.h" #include "iterator.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #undef ETL_FILE #define ETL_FILE "21" @@ -133,7 +133,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - intmax_t d = ETL_STD::distance(first, last); + intmax_t d = etlstd::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(intrusive_list_iterator_exception)); #endif @@ -383,7 +383,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -488,7 +488,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -580,7 +580,7 @@ namespace etl const value_type* p_value; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 -= ETL_STD::distance(first, last); + this->current_size -= etlstd::distance(first, last); if (p_last == &this->terminal_link) { @@ -781,7 +781,7 @@ namespace etl //************************************************************************* void sort() { - sort(ETL_STD::less()); + sort(etlstd::less()); } //************************************************************************* @@ -1013,7 +1013,7 @@ namespace etl { if (&other != this) { - size_t n = ETL_STD::distance(begin_, end_); + size_t n = etlstd::distance(begin_, end_); this->current_size += n; other.current_size -= n; } @@ -1036,7 +1036,7 @@ namespace etl //************************************************************************* void merge(list_type& other) { - merge(other, ETL_STD::less()); + merge(other, etlstd::less()); } //************************************************************************* diff --git a/include/etl/io_port.h b/include/etl/io_port.h index 713c0047..09366c34 100644 --- a/include/etl/io_port.h +++ b/include/etl/io_port.h @@ -41,7 +41,7 @@ SOFTWARE. #include "nullptr.h" #include "iterator.h" -#include "stl/iterator.h" +#include "iterator.h" namespace etl { @@ -49,7 +49,7 @@ namespace etl /// Read write port. //*************************************************************************** template - class io_port_rw : public etl::iterator + class io_port_rw : public etl::iterator { public: @@ -129,7 +129,7 @@ namespace etl /// Read only port. //*************************************************************************** template - class io_port_ro : public etl::iterator + class io_port_ro : public etl::iterator { public: @@ -193,7 +193,7 @@ namespace etl /// Write only port. //*************************************************************************** template - class io_port_wo : public etl::iterator + class io_port_wo : public etl::iterator { public: @@ -257,7 +257,7 @@ namespace etl /// Write only port with shadow register. //*************************************************************************** template - class io_port_wos : public etl::iterator + class io_port_wos : public etl::iterator { public: @@ -336,7 +336,7 @@ namespace etl /// Specialisation for dynamic addresses. //*************************************************************************** template - class io_port_rw : public etl::iterator + class io_port_rw : public etl::iterator { public: @@ -447,7 +447,7 @@ namespace etl /// Specialisation for dynamic addresses. //*************************************************************************** template - class io_port_ro : public etl::iterator + class io_port_ro : public etl::iterator { public: @@ -536,7 +536,7 @@ namespace etl /// Specialisation for dynamic addresses. //*************************************************************************** template - class io_port_wo : public etl::iterator + class io_port_wo : public etl::iterator { public: @@ -631,7 +631,7 @@ namespace etl /// Specialisation for dynamic addresses. //*************************************************************************** template - class io_port_wos : public etl::iterator + class io_port_wos : public etl::iterator { public: @@ -640,7 +640,7 @@ namespace etl typedef volatile T& reference; typedef volatile const T& const_reference; - class iterator : public etl::iterator + class iterator : public etl::iterator { typedef io_port_wos iop_t; diff --git a/include/etl/iterator.h b/include/etl/iterator.h index d4ff0321..4f7665c2 100644 --- a/include/etl/iterator.h +++ b/include/etl/iterator.h @@ -32,16 +32,387 @@ SOFTWARE. #define ETL_ITERATOR_INCLUDED #include "platform.h" - -#include "stl/iterator.h" - #include "type_traits.h" +#if !defined(ETL_NO_STL) + #include +#endif + ///\defgroup iterator iterator ///\ingroup utilities -namespace etl +namespace etlstd { + //*************************************************************************** + // iterator tags + struct input_iterator_tag {}; + struct output_iterator_tag {}; + struct forward_iterator_tag : public input_iterator_tag {}; + struct bidirectional_iterator_tag : public forward_iterator_tag {}; + struct random_access_iterator_tag : public bidirectional_iterator_tag {}; + + //*************************************************************************** + // iterator_traits + template + struct iterator_traits + { + typedef typename TIterator::iterator_category iterator_category; + typedef typename TIterator::value_type value_type; + typedef typename TIterator::difference_type difference_type; + typedef typename TIterator::pointer pointer; + typedef typename TIterator::reference reference; + }; + + template + struct iterator_traits + { + typedef ETL_OR_STD::random_access_iterator_tag iterator_category; + typedef T value_type; + typedef ptrdiff_t difference_type; + typedef T* pointer; + typedef T& reference; + }; + + template + struct iterator_traits + { + typedef ETL_OR_STD::random_access_iterator_tag iterator_category; + typedef T value_type; + typedef ptrdiff_t difference_type; + typedef const T* pointer; + typedef const T& reference; + }; + + //*************************************************************************** + // advance +#if defined(ETL_NO_STL) + + template + ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::output_iterator_tag) + { + while (n--) + { + ++itr; + } + } + + template + ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::forward_iterator_tag) + { + while (n--) + { + ++itr; + } + } + + template + ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::bidirectional_iterator_tag) + { + if (n > 0) + { + while (n--) + { + ++itr; + } + } + else + { + while (n++) + { + --itr; + } + } + } + + template + ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::random_access_iterator_tag) + { + itr += n; + } + + template + ETL_CONSTEXPR17 void advance(TIterator& itr, TDistance n) + { + typedef typename etlstd::iterator_traits::iterator_category tag; + + advance_helper(itr, n, tag()); + } + +#else + + template + ETL_CONSTEXPR17 void advance(TIterator& itr, TDistance n) + { + std::advance(itr, n); + } + +#endif + + //*************************************************************************** + // 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) + { + typename etlstd::iterator_traits::difference_type d = 0; + + while (first != last) + { + ++d; + ++first; + } + + return d; + } + + template + ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::forward_iterator_tag) + { + typename etlstd::iterator_traits::difference_type d = 0; + + while (first != last) + { + ++d; + ++first; + } + + return d; + } + + template + ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::bidirectional_iterator_tag) + { + typename etlstd::iterator_traits::difference_type d = 0; + + while (first != last) + { + ++d; + ++first; + } + + return d; + } + + template + ETL_CONSTEXPR17 typename etlstd::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) + { + typedef typename etlstd::iterator_traits::iterator_category tag; + + return distance_helper(first, last, tag()); + } + +#else + + template + ETL_CONSTEXPR17 typename std::iterator_traits::difference_type distance(TIterator first, TIterator last) + { + return std::distance(first, last); + } + +#endif + + //*************************************************************************** + // Previous + template + ETL_CONSTEXPR17 TIterator prev(TIterator itr, typename etlstd::iterator_traits::difference_type n = 1) + { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + etlstd::advance(itr, -n); +#else + std::advance(itr, -n); +#endif + return itr; + } + + //*************************************************************************** + // Next + template + ETL_CONSTEXPR17 TIterator next(TIterator itr, typename etlstd::iterator_traits::difference_type n = 1) + { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + etlstd::advance(itr, n); +#else + std::advance(itr, n); +#endif + return itr; + } + + //*************************************************************************** + // reverse_iterator + template + class reverse_iterator + { + public: + + typedef typename iterator_traits::iterator_category iterator_category; + typedef typename iterator_traits::value_type value_type; + typedef typename iterator_traits::difference_type difference_type; + typedef typename iterator_traits::pointer pointer; + typedef typename iterator_traits::reference reference; + + typedef TIterator iterator_type; + + ETL_CONSTEXPR17 reverse_iterator() + : current() + { + } + + ETL_CONSTEXPR17 explicit reverse_iterator(TIterator itr) + : current(itr) + { + } + + template + ETL_CONSTEXPR17 reverse_iterator(const reverse_iterator& other) + : current(other.base()) + { + } + + template + ETL_CONSTEXPR17 reverse_iterator& operator=(const reverse_iterator& other) + { + current = other.base(); + + return (*this); + } + + ETL_CONSTEXPR17 TIterator base() const + { + return current; + } + + ETL_NODISCARD ETL_CONSTEXPR17 reference operator*() const + { + TIterator temp = current; + + return *(--temp); + } + + ETL_NODISCARD ETL_CONSTEXPR17 pointer operator->() const + { + TIterator temp = current; + + return &(*--temp); + } + + ETL_CONSTEXPR17 reverse_iterator& operator++() + { + --current; + + return *this; + } + + ETL_CONSTEXPR17 reverse_iterator operator++(int) + { + reverse_iterator temp = *this; + --current; + + return temp; + } + + ETL_CONSTEXPR17 reverse_iterator& operator--() + { + ++current; + + return (*this); + } + + ETL_CONSTEXPR17 reverse_iterator operator--(int) + { + reverse_iterator temp = *this; + ++current; + + return temp; + } + + ETL_CONSTEXPR17 reverse_iterator& operator+=(const difference_type offset) + { + current -= offset; + + return (*this); + } + + ETL_CONSTEXPR17 reverse_iterator& operator-=(const difference_type offset) + { + current += offset; + + return (*this); + } + + ETL_NODISCARD ETL_CONSTEXPR17 reverse_iterator operator+(const difference_type offset) const + { + return reverse_iterator(current - offset); + } + + ETL_NODISCARD ETL_CONSTEXPR17 reverse_iterator operator-(const difference_type offset) const + { + return (reverse_iterator(current + offset)); + } + + ETL_NODISCARD ETL_CONSTEXPR17 reference operator[](const difference_type offset) const + { + return (*(*this + offset)); + } + + protected: + + TIterator current; + }; + + template + inline ETL_CONSTEXPR17 bool operator ==(const reverse_iterator& lhs, const reverse_iterator& rhs) + { + return lhs.base() == rhs.base(); + } + + template + inline ETL_CONSTEXPR17 bool operator !=(const reverse_iterator& lhs, const reverse_iterator& rhs) + { + return !(lhs == rhs); + } + + template + inline ETL_CONSTEXPR17 bool operator <(const reverse_iterator& lhs, const reverse_iterator& rhs) + { + return rhs.base() < lhs.base(); + } + + template + inline ETL_CONSTEXPR17 bool operator >(const reverse_iterator& lhs, const reverse_iterator& rhs) + { + return rhs < lhs; + } + + template + inline ETL_CONSTEXPR17 bool operator <=(const reverse_iterator& lhs, const reverse_iterator& rhs) + { + return !(rhs < lhs); + } + + template + inline ETL_CONSTEXPR17 bool operator >=(const reverse_iterator& lhs, const reverse_iterator& rhs) + { + return !(lhs < rhs); + } + + template + inline ETL_CONSTEXPR17 typename reverse_iterator::difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs) + { + return rhs.base() - lhs.base(); + } + + template + inline ETL_CONSTEXPR17 reverse_iterator operator +(TDifference n, const reverse_iterator& itr) + { + return itr.operator +(n); + } + //*************************************************************************** /// iterator //*************************************************************************** @@ -55,78 +426,81 @@ namespace etl typedef TCategory iterator_category; }; +} + +namespace etl +{ //*************************************************************************** - // Helper templates. - //*************************************************************************** +// Helper templates. +//*************************************************************************** template struct is_input_iterator { - static const bool value = etl::is_same::iterator_category, ETL_INPUT_ITERATOR_TAG>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::input_iterator_tag>::value; }; template struct is_output_iterator { - static const bool value = etl::is_same::iterator_category, ETL_OUTPUT_ITERATOR_TAG>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::output_iterator_tag>::value; }; template struct is_forward_iterator { - static const bool value = etl::is_same::iterator_category, ETL_FORWARD_ITERATOR_TAG>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::forward_iterator_tag>::value; }; template struct is_bidirectional_iterator { - static const bool value = etl::is_same::iterator_category, ETL_BIDIRECTIONAL_ITERATOR_TAG>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value; }; template struct is_random_iterator { - static const bool value = etl::is_same::iterator_category, ETL_RANDOM_ACCESS_ITERATOR_TAG>::value; + static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value; }; template struct is_input_iterator_concept { - static const bool value = etl::is_input_iterator::value || - etl::is_forward_iterator::value || - etl::is_bidirectional_iterator::value || - etl::is_random_iterator::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_input_iterator::value || + etl::is_forward_iterator::value || + etl::is_bidirectional_iterator::value || + etl::is_random_iterator::value; }; template struct is_output_iterator_concept { - static const bool value = etl::is_output_iterator::value || - etl::is_forward_iterator::value || - etl::is_bidirectional_iterator::value || - etl::is_random_iterator::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_output_iterator::value || + etl::is_forward_iterator::value || + etl::is_bidirectional_iterator::value || + etl::is_random_iterator::value; }; template struct is_forward_iterator_concept { - static const bool value = etl::is_forward_iterator::value || - etl::is_bidirectional_iterator::value || - etl::is_random_iterator::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_forward_iterator::value || + etl::is_bidirectional_iterator::value || + etl::is_random_iterator::value; }; template struct is_bidirectional_iterator_concept { - static const bool value = etl::is_bidirectional_iterator::value || - etl::is_random_iterator::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_bidirectional_iterator::value || + etl::is_random_iterator::value; }; template struct is_random_iterator_concept { - static const bool value = etl::is_random_iterator::value; + static ETL_CONST_OR_CONSTEXPR bool value = etl::is_random_iterator::value; }; - } #endif diff --git a/include/etl/jenkins.h b/include/etl/jenkins.h index 8c075a22..ef96c0c1 100644 --- a/include/etl/jenkins.h +++ b/include/etl/jenkins.h @@ -40,7 +40,7 @@ SOFTWARE. #include "ihash.h" #include "frame_check_sequence.h" -#include "stl/iterator.h" +#include "iterator.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 diff --git a/include/etl/largest.h b/include/etl/largest.h index 556db65b..0ebdc414 100644 --- a/include/etl/largest.h +++ b/include/etl/largest.h @@ -82,15 +82,15 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - using type = typename etl::conditional<(etl::size_of() > etl::size_of()), // Boolean - T1, // TrueType - largest_other> // FalseType - ::type; // The largest type of the two. + using type = typename etlstd::conditional<(etl::size_of::value > etl::size_of::value), // Boolean + T1, // TrueType + largest_other> // FalseType + ::type; // The largest type of the two. // The size of the largest type. enum { - size = etl::size_of() + size = etl::size_of::value }; }; @@ -106,7 +106,7 @@ namespace etl enum { - size = etl::size_of() + size = etl::size_of::value }; }; #else @@ -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 etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean + typedef typename etlstd::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 etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean + using type = typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::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 = etl::alignment_of::value + value = etlstd::alignment_of::value }; }; @@ -192,7 +192,7 @@ namespace etl enum { - value = etl::alignment_of::value + value = etlstd::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 etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean + typedef typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::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 = etl::alignment_of::value + value = etlstd::alignment_of::value }; }; @@ -236,7 +236,7 @@ namespace etl enum { - value = etl::alignment_of::value + value = etlstd::alignment_of::value }; }; #endif @@ -249,7 +249,7 @@ namespace etl template struct larger_int_type { - ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::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 0dd78c85..bfe55b50 100644 --- a/include/etl/largest_generator.h +++ b/include/etl/largest_generator.h @@ -94,15 +94,15 @@ namespace etl // Set 'type' to be the largest of the first parameter and any of the others. // This is recursive. - using type = typename etl::conditional<(etl::size_of() > etl::size_of()), // Boolean - T1, // TrueType - largest_other> // FalseType - ::type; // The largest type of the two. + using type = typename etlstd::conditional<(etl::size_of::value > etl::size_of::value), // Boolean + T1, // TrueType + largest_other> // FalseType + ::type; // The largest type of the two. // The size of the largest type. enum { - size = etl::size_of() + size = etl::size_of::value }; }; @@ -118,7 +118,7 @@ namespace etl enum { - size = etl::size_of() + size = etl::size_of::value }; }; #else @@ -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 etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean") + cog.outl(" typedef typename etlstd::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 etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean + using type = typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::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 = etl::alignment_of::value + value = etlstd::alignment_of::value }; }; @@ -222,7 +222,7 @@ namespace etl enum { - value = etl::alignment_of::value + value = etlstd::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 etl::conditional<(etl::alignment_of::value > etl::alignment_of::value), // Boolean") + cog.outl(" typedef typename etlstd::conditional<(etlstd::alignment_of::value > etlstd::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 = etl::alignment_of::value") + cog.outl(" value = etlstd::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 = etl::alignment_of::value") + cog.outl(" value = etlstd::alignment_of::value") cog.outl(" };") cog.outl("};") ]]]*/ @@ -297,7 +297,7 @@ namespace etl template struct larger_int_type { - ETL_STATIC_ASSERT(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Must be an integral type"); + ETL_STATIC_ASSERT(etlstd::is_integral::value, "Must be an integral type"); typedef typename etl::smallest_int_for_bits::bits + 1>::type type; }; diff --git a/include/etl/stl/alternate/limits.h b/include/etl/limits.h similarity index 92% rename from include/etl/stl/alternate/limits.h rename to include/etl/limits.h index 2b73be81..c8ad62c9 100644 --- a/include/etl/stl/alternate/limits.h +++ b/include/etl/limits.h @@ -28,21 +28,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ******************************************************************************/ -#ifndef ETL_STL_ALTERNATE_LIMITS_INCLUDED -#define ETL_STL_ALTERNATE_LIMITS_INCLUDED +#ifndef ETL_LIMITS_INCLUDED +#define ETL_LIMITS_INCLUDED -#include "../../platform.h" -#include "../../type_traits.h" -#include "../../char_traits.h" -#include "../../integral_limits.h" - -#include "../../private/choose_tag_types.h" -#include "../../private/choose_pair_types.h" +#include "platform.h" +#include "type_traits.h" +#include "char_traits.h" +#include "integral_limits.h" #include #include #include +#if defined(ETL_NO_STL) #define ETL_LOG2(x) (((x) * 301) / 1000) namespace etlstd @@ -82,10 +80,10 @@ namespace etlstd 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)) - (etl::is_signed::value ? 1 : 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 = etl::is_signed::value; + 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; @@ -105,7 +103,7 @@ namespace etlstd 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 = etl::is_unsigned::value; + 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; @@ -257,6 +255,7 @@ namespace etlstd 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; }; //*************************************************************************** @@ -269,6 +268,7 @@ namespace etlstd 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; }; #endif @@ -450,4 +450,33 @@ namespace etlstd }; } +#else + +#include + +namespace etlstd +{ + enum float_round_style + { + round_indeterminate = std::float_round_style::round_indeterminate, + round_toward_zero = std::float_round_style::round_toward_zero, + round_to_nearest = std::float_round_style::round_to_nearest, + round_toward_infinity = std::float_round_style::round_toward_infinity, + round_toward_neg_infinity = std::float_round_style::round_toward_neg_infinity, + }; + + enum float_denorm_style + { + denorm_indeterminate = std::float_denorm_style::denorm_indeterminate, + denorm_absent = std::float_denorm_style::denorm_absent, + denorm_present = std::float_denorm_style::denorm_present + }; + + template + class numeric_limits : public std::numeric_limits + { + }; +} +#endif + #endif diff --git a/include/etl/list.h b/include/etl/list.h index d86b6dce..2147daa8 100644 --- a/include/etl/list.h +++ b/include/etl/list.h @@ -37,9 +37,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #include "container.h" #include "pool.h" @@ -182,7 +182,7 @@ namespace etl //*********************************************************************** inline void reverse() { - ETL_STD::swap(previous, next); + swap(previous, next); } node_t* previous; @@ -482,7 +482,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -583,7 +583,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -676,10 +676,10 @@ namespace etl const node_t* p_node; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* /// Gets the beginning of the list. @@ -810,7 +810,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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 +866,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(list_full)); #endif - insert_node(get_head(), allocate_data_node(ETL_STD::move(value))); + insert_node(get_head(), allocate_data_node(etlstd::move(value))); } #endif @@ -883,7 +883,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(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etlstd::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(get_head(), *p_data_node); } @@ -989,7 +989,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(list_full)); #endif - insert_node(terminal_node, allocate_data_node(ETL_STD::move(value))); + insert_node(terminal_node, allocate_data_node(etlstd::move(value))); } #endif @@ -1006,7 +1006,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(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etlstd::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(terminal_node, *p_data_node); } @@ -1101,7 +1101,7 @@ namespace etl { ETL_ASSERT(!full(), ETL_ERROR(list_full)); - data_node_t& data_node = allocate_data_node(ETL_STD::move(value)); + data_node_t& data_node = allocate_data_node(etlstd::move(value)); insert_node(*position.p_node, data_node); return iterator(data_node); @@ -1119,7 +1119,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(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etlstd::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(*position.p_node, *p_data_node); @@ -1269,7 +1269,7 @@ namespace etl else if (n < size()) { iterator i_start = end(); - ETL_STD::advance(i_start, -difference_type(size() - n)); + etlstd::advance(i_start, -difference_type(size() - n)); erase(i_start, end()); } // Larger? @@ -1334,7 +1334,7 @@ namespace etl //************************************************************************* void unique() { - unique(ETL_STD::equal_to()); + unique(etlstd::equal_to()); } //************************************************************************* @@ -1390,7 +1390,7 @@ namespace etl typename ilist::iterator itr = other.begin(); while (itr != other.end()) { - to = insert(to, ETL_STD::move(*itr++)); + to = insert(to, etlstd::move(*itr++)); } other.erase(other.begin(), other.end()); @@ -1430,7 +1430,7 @@ namespace etl else { // From another list. - insert(to, ETL_STD::move(*from)); + insert(to, etlstd::move(*from)); other.erase(from); } } @@ -1471,7 +1471,7 @@ namespace etl ilist::iterator itr = first; while (itr != last) { - to = insert(to, ETL_STD::move(*itr++)); + to = insert(to, etlstd::move(*itr++)); ++to; } @@ -1485,7 +1485,7 @@ namespace etl //************************************************************************* void merge(ilist& other) { - merge(other, ETL_STD::less()); + merge(other, etlstd::less()); } //************************************************************************* @@ -1542,7 +1542,7 @@ namespace etl //************************************************************************* void merge(ilist&& other) { - merge(ETL_STD::move(other), ETL_STD::less()); + merge(etlstd::move(other), etlstd::less()); } //************************************************************************* @@ -1577,7 +1577,7 @@ namespace etl { while ((other_begin != other_end) && (compare(*other_begin, *this_begin))) { - insert(this_begin, ETL_STD::move(*other_begin)); + insert(this_begin, etlstd::move(*other_begin)); ++other_begin; } } @@ -1588,7 +1588,7 @@ namespace etl { while (other_begin != other_end) { - insert(this_end, ETL_STD::move(*other_begin++)); + insert(this_end, etlstd::move(*other_begin++)); } } @@ -1603,7 +1603,7 @@ namespace etl //************************************************************************* void sort() { - sort(ETL_STD::less()); + sort(etlstd::less()); } //************************************************************************* @@ -1765,7 +1765,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etlstd::move(*itr)); ++itr; } @@ -1917,7 +1917,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(ETL_STD::move(value)); + ::new (&(p_data_node->value)) T(etlstd::move(value)); ETL_INCREMENT_DEBUG_COUNT return *p_data_node; @@ -2033,7 +2033,7 @@ namespace etl typename etl::ilist::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -2089,7 +2089,7 @@ namespace etl typename etl::ilist::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -2191,7 +2191,7 @@ namespace etl typename etl::ilist::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -2214,7 +2214,7 @@ namespace etl //************************************************************************* /// Construct from initializer_list. //************************************************************************* - list(ETL_STD::initializer_list init, etl::ipool& node_pool) + list(std::initializer_list init, etl::ipool& node_pool) : ilist(node_pool, node_pool.max_size(), true) { this->assign(init.begin(), init.end()); @@ -2247,7 +2247,7 @@ namespace etl typename etl::ilist::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -2282,7 +2282,7 @@ namespace etl template bool operator ==(const etl::ilist& lhs, const etl::ilist& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -2307,10 +2307,7 @@ namespace etl template bool operator <(const etl::ilist& lhs, const etl::ilist& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), - lhs.end(), - rhs.begin(), - rhs.end()); + return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/map.h b/include/etl/map.h index 79a11f7e..e1630b26 100755 --- a/include/etl/map.h +++ b/include/etl/map.h @@ -37,9 +37,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #include "container.h" #include "pool.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: @@ -575,7 +575,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -696,7 +696,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -804,10 +804,10 @@ namespace etl friend class const_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* /// Gets the beginning of the map. @@ -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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2155,10 +2155,7 @@ namespace etl template bool operator <(const etl::imap& lhs, const etl::imap& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), - lhs.end(), - rhs.begin(), - rhs.end()); + return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/memory.h b/include/etl/memory.h index 8e6ff921..53623b2b 100644 --- a/include/etl/memory.h +++ b/include/etl/memory.h @@ -35,7 +35,7 @@ SOFTWARE. #include "algorithm.h" #include "type_traits.h" -#include "stl/iterator.h" +#include "iterator.h" #include @@ -43,42 +43,55 @@ SOFTWARE. #include +#if !defined(ETL_NO_STL) + #include +#endif + ///\defgroup memory memory -///\ingroup etl -namespace etl +///\ingroup etlstd + +namespace etlstd { //***************************************************************************** /// Gets the address of an object. + /// https://en.cppreference.com/w/cpp/memory/addressof ///\ingroup memory //***************************************************************************** template T* addressof(T& t) { - return reinterpret_cast(&const_cast(reinterpret_cast(t))); +#if ETL_CPP11_SUPPORTED + return std::addressof(t); +#else + return reinterpret_cast(&const_cast(reinterpret_cast(t))); +#endif } +#if defined(ETL_NO_STL) //***************************************************************************** /// Fills uninitialised memory range with a value. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value) { - ETL_STD::fill(o_begin, o_end, value); + etlstd::fill(o_begin, o_end, value); return o_end; } //***************************************************************************** /// Fills uninitialised memory range with a value. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value) { - typedef typename ETL_STD::iterator_traits::value_type value_type; + typedef typename etlstd::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -92,15 +105,16 @@ namespace etl //***************************************************************************** /// Fills uninitialised memory range with a value. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) { - count += int32_t(ETL_STD::distance(o_begin, o_end)); + count += int32_t(etlstd::distance(o_begin, o_end)); - ETL_STD::fill(o_begin, o_end, value); + etlstd::fill(o_begin, o_end, value); return o_end; } @@ -108,62 +122,126 @@ namespace etl //***************************************************************************** /// Fills uninitialised memory range with a value. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) { - count += int32_t(ETL_STD::distance(o_begin, o_end)); + count += int32_t(etlstd::distance(o_begin, o_end)); - etl::uninitialized_fill(o_begin, o_end, value); + etlstd::uninitialized_fill(o_begin, o_end, value); + + return o_end; + } +#else + //***************************************************************************** + /// Fills uninitialised memory range with a value. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value) + { + std::uninitialized_fill(o_begin, o_end, value); return o_end; } + //***************************************************************************** + /// Fills uninitialised memory range with a value. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_fill(TOutputIterator o_begin, TOutputIterator o_end, const T& value, TCounter& count) + { + count += int32_t(etlstd::distance(o_begin, o_end)); + + std::uninitialized_fill(o_begin, o_end, value); + + return o_end; + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED //***************************************************************************** /// Fills uninitialised memory with N values. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill_n ///\ingroup memory //***************************************************************************** template - TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T& value) + TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T& value) { - return etl::uninitialized_fill(o_begin, o_begin + n, value); + return etlstd::uninitialized_fill(o_begin, o_begin + n, value); } //***************************************************************************** /// Fills uninitialised memory with N values. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill_n ///\ingroup memory //***************************************************************************** template - TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T& value, TCounter& count) + TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T& value, TCounter& count) { count += n; - return etl::uninitialized_fill(o_begin, o_begin + n, value); + return etlstd::uninitialized_fill(o_begin, o_begin + n, value); + } +#else + //***************************************************************************** + /// Fills uninitialised memory with N values. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill_n + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T& value) + { + return std::uninitialized_fill_n(o_begin, n, value); + } + + //***************************************************************************** + /// Fills uninitialised memory with N values. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_fill_n + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T& value, TCounter& count) + { + count += n; + + return std::uninitialized_fill_n(o_begin, n, value); + } +#endif + +#if defined(ETL_NO_STL) + //***************************************************************************** + /// Copies a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::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); } //***************************************************************************** /// Copies a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin) { - return ETL_STD::copy(i_begin, i_end, o_begin); - } - - //***************************************************************************** - /// Copies a range of objects to uninitialised memory. - ///\ingroup memory - //***************************************************************************** - template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin) - { - typedef typename ETL_STD::iterator_traits::value_type value_type; + typedef typename etlstd::iterator_traits::value_type value_type; TOutputIterator o_end = o_begin; @@ -180,14 +258,15 @@ namespace etl //***************************************************************************** /// Copies a range of objects to uninitialised memory. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter& count) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter& count) { - TOutputIterator o_end = ETL_STD::copy(i_begin, i_end, o_begin); - count += int32_t(ETL_STD::distance(o_begin, o_end)); + TOutputIterator o_end = etlstd::copy(i_begin, i_end, o_begin); + count += int32_t(etlstd::distance(o_begin, o_end)); return o_end; } @@ -195,105 +274,120 @@ namespace etl //***************************************************************************** /// Copies a range of objects to uninitialised memory. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter& count) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter& count) { - TOutputIterator o_end = etl::uninitialized_copy(i_begin, i_end, o_begin); + TOutputIterator o_end = etlstd::uninitialized_copy(i_begin, i_end, o_begin); - count += int32_t(ETL_STD::distance(o_begin, o_end)); + count += int32_t(etlstd::distance(o_begin, o_end)); return o_end; } +#else + //***************************************************************************** + /// Copies a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin) + { + return std::uninitialized_copy(i_begin, i_end, o_begin); + } + //***************************************************************************** + /// Copies a range of objects to uninitialised memory. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter& count) + { + return std::uninitialized_copy(i_begin, i_end, o_begin); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED //***************************************************************************** /// Copies N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy_n ///\ingroup memory //***************************************************************************** template - TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin) + TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin) { - return etl::uninitialized_copy(i_begin, i_begin + n, o_begin); + return etlstd::uninitialized_copy(i_begin, i_begin + n, o_begin); } //***************************************************************************** /// Copies N objects to uninitialised memory. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy_n ///\ingroup memory //***************************************************************************** template - TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TCounter& count) + TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TCounter& count) { count += n; - return etl::uninitialized_copy(i_begin, i_begin + n, o_begin); + return etlstd::uninitialized_copy(i_begin, i_begin + n, o_begin); + } +#else + //***************************************************************************** + /// Copies N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy_n + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin) + { + return std::uninitialized_copy_n(i_begin, n, o_begin); } //***************************************************************************** - /// Default contruct an item at address p. + /// Copies N objects to uninitialised memory. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_copy_n ///\ingroup memory //***************************************************************************** - template - typename etl::enable_if::value, void>::type - create_default_at(T* /*p*/) + template + TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TCounter& count) { - } + count += n; - //***************************************************************************** - /// Default contruct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - typename etl::enable_if::value, void>::type - create_default_at(T* /*p*/, TCounter& count) - { - ++count; - } + return std::uninitialized_copy_n(i_begin, n, o_begin); +} +#endif +#if defined(ETL_NO_STL) || !ETL_CPP17_SUPPORTED //***************************************************************************** - /// Default contruct an item at address p. + /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct ///\ingroup memory //***************************************************************************** - template - typename etl::enable_if::value, void>::type - create_default_at(T* p) + template + typename etlstd::enable_if::value_type>::value, void>::type + uninitialized_default_construct(TOutputIterator /*o_begin*/, TOutputIterator /*o_end*/) { - ::new (p) T; - } - - //***************************************************************************** - /// Default contruct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - typename etl::enable_if::value, void>::type - create_default_at(T* p, TCounter& count) - { - ::new (p) T; - ++count; + // Do nothing } //***************************************************************************** /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - uninitialized_default_construct(TOutputIterator /*o_begin*/, TOutputIterator /*o_end*/) + typename etlstd::enable_if::value_type>::value, void>::type + uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end) { - } - //***************************************************************************** - /// Default initialises a range of objects to uninitialised memory. - ///\ingroup memory - //***************************************************************************** - template - typename etl::enable_if::value_type>::value, void>::type - uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end) - { - typedef typename ETL_STD::iterator_traits::value_type value_type; + typedef typename etlstd::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -304,66 +398,99 @@ namespace etl //***************************************************************************** /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct /// Debug counter version. ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) + typename etlstd::enable_if::value_type>::value, void>::type + uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count = int32_t(ETL_STD::distance(o_begin, o_end)); + count = int32_t(etlstd::distance(o_begin, o_end)); } //***************************************************************************** /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct /// Debug counter version. ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) + typename etlstd::enable_if::value_type>::value, void>::type + uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count += int32_t(ETL_STD::distance(o_begin, o_end)); + count += int32_t(etlstd::distance(o_begin, o_end)); - etl::uninitialized_default_construct(o_begin, o_end); + etlstd::uninitialized_default_construct(o_begin, o_end); + } +#else + //***************************************************************************** + /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::enable_if::value_type>::value, void>::type + uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end) + { + std::uninitialized_default_construct(o_begin, o_end); + } + + //***************************************************************************** + /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct + /// Debug counter version. + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::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)); + + std::uninitialized_default_construct(o_begin, o_end); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP17_SUPPORTED + //***************************************************************************** + /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) + { + TOutputIterator o_end = o_begin + n; + return o_end; } //***************************************************************************** /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) + typename etlstd::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); + return o_end; } //***************************************************************************** /// Default initialises N objects to uninitialised memory. - ///\ingroup memory - //***************************************************************************** - template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) - { - TOutputIterator o_end = o_begin + n; - - etl::uninitialized_default_construct(o_begin, o_end); - - return o_end; - } - - //***************************************************************************** - /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n /// Debug counter version. ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { TOutputIterator o_end = o_begin + n; @@ -374,193 +501,77 @@ namespace etl //***************************************************************************** /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n /// Debug counter version. ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { TOutputIterator o_end = o_begin + n; - etl::uninitialized_default_construct(o_begin, o_end); + etlstd::uninitialized_default_construct(o_begin, o_end); count += n; return o_end; } - +#else //***************************************************************************** - /// Value construct an item at address p. + /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n ///\ingroup memory //***************************************************************************** - template - void create_value_at(T* p) + template + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) { - ::new (p) T(); + return std::uninitialized_default_construct_n(o_begin, n); } - //***************************************************************************** - /// Value construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - void create_value_at(T* p, TCounter& count) - { - ::new (p) T(); - ++count; - } //***************************************************************************** - /// Copy construct an item at address p. + /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n + /// Debug counter version. ///\ingroup memory //***************************************************************************** - template - void create_copy_at(T* p, const T& value) + template + typename etlstd::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { - ::new (p) T(value); - } + count += n; -#if ETL_CPP11_SUPPORTED - //***************************************************************************** - /// Copy construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - void create_copy_at(T* p, T&& value) - { - ::new (p) T(ETL_STD::move(value)); + return std::uninitialized_default_construct_n(o_begin, n); } #endif +#if defined(ETL_NO_STL) || !ETL_CPP17_SUPPORTED //***************************************************************************** - /// Copy construct an item at address p. + /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct ///\ingroup memory //***************************************************************************** - template - void create_copy_at(T* p, const T& value, TCounter& count) + template + typename etlstd::enable_if::value_type>::value, void>::type + uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) { - ::new (p) T(value); - ++count; - } + typedef typename etlstd::iterator_traits::value_type value_type; - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_default_at(T* p) - { - ::new (p) T(); - return *reinterpret_cast(p); - } - - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_default_at(T* p, TCounter& count) - { - ::new (p) T(); - ++count; - return *reinterpret_cast(p); - } - - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_copy_at(T* p, const T& other) - { - ::new (p) T(other); - return *reinterpret_cast(p); - } - -#if ETL_CPP11_SUPPORTED - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_copy_at(T* p, T&& other) - { - ::new (p) T(ETL_STD::move(other)); - return *reinterpret_cast(p); - } -#endif - - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_copy_at(T* p, const T& other, TCounter& count) - { - ::new (p) T(other); - ++count; - return *reinterpret_cast(p); - } - - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_value_at(T* p, const TParameter& value) - { - ::new (p) T(value); - return *reinterpret_cast(p); - } - -#if ETL_CPP11_SUPPORTED - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_value_at(T* p, TParameter&& value) - { - ::new (p) T(ETL_STD::move(value)); - return *reinterpret_cast(p); - } -#endif - - //***************************************************************************** - /// Construct an item at address p. - ///\ingroup memory - //***************************************************************************** - template - T& make_value_at(T* p, const TParameter& value, TCounter& count) - { - ::new (p) T(value); - ++count; - return *reinterpret_cast(p); + etlstd::fill(o_begin, o_end, value_type()); } //***************************************************************************** /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) + typename etlstd::enable_if::value_type>::value, void>::type + uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) { - typedef typename ETL_STD::iterator_traits::value_type value_type; - - ETL_STD::fill(o_begin, o_end, value_type()); - } - - //***************************************************************************** - /// Default initialises a range of objects to uninitialised memory. - ///\ingroup memory - //***************************************************************************** - template - typename etl::enable_if::value_type>::value, void>::type - uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) - { - typedef typename ETL_STD::iterator_traits::value_type value_type; + typedef typename etlstd::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -571,19 +582,49 @@ namespace etl //***************************************************************************** /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct /// Debug counter version. ///\ingroup memory //***************************************************************************** template void uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) { - count += int32_t(ETL_STD::distance(o_begin, o_end)); + count += int32_t(etlstd::distance(o_begin, o_end)); - etl::uninitialized_value_construct(o_begin, o_end); + etlstd::uninitialized_value_construct(o_begin, o_end); + } +#else + //***************************************************************************** + /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct + ///\ingroup memory + //***************************************************************************** + template + void uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) + { + std::uninitialized_value_construct(o_begin, o_end); } + //***************************************************************************** + /// Default initialises a range of objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct + /// Debug counter version. + ///\ingroup memory + //***************************************************************************** + template + void uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end, TCounter& count) + { + count += int32_t(etlstd::distance(o_begin, o_end)); + + std::uninitialized_value_construct(o_begin, o_end); + } + +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP17_SUPPORTED //***************************************************************************** /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct_n ///\ingroup memory //***************************************************************************** template @@ -591,13 +632,14 @@ namespace etl { TOutputIterator o_end = o_begin + n; - etl::uninitialized_value_construct(o_begin, o_end); + etlstd::uninitialized_value_construct(o_begin, o_end); return o_end; } //***************************************************************************** /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct_n /// Debug counter version. ///\ingroup memory //***************************************************************************** @@ -606,30 +648,59 @@ namespace etl { TOutputIterator o_end = o_begin + n; - etl::uninitialized_value_construct(o_begin, o_end); + etlstd::uninitialized_value_construct(o_begin, o_end); count += n; return o_end; } +#else + //***************************************************************************** + /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct_n + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_value_construct_n(TOutputIterator o_begin, TSize n) + { + return std::uninitialized_value_construct_n(o_begin, n); + } + //***************************************************************************** + /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct_n + /// Debug counter version. + ///\ingroup memory + //***************************************************************************** + template + TOutputIterator uninitialized_value_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) + { + count += n; + + return std::uninitialized_value_construct_n(o_begin, n); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP17_SUPPORTED //***************************************************************************** /// Destroys an item at address p. + /// https://en.cppreference.com/w/cpp/memory/destroy_at ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value, void>::type - destroy_at(T* /*p*/) + typename etlstd::enable_if::value, void>::type + destroy_at(T* /*p*/) { } //***************************************************************************** /// Destroys an item at address p. + /// https://en.cppreference.com/w/cpp/memory/destroy_at ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value, void>::type - destroy_at(T* p) + typename etlstd::enable_if::value, void>::type + destroy_at(T* p) { p->~T(); } @@ -637,11 +708,12 @@ namespace etl //***************************************************************************** /// Destroys an item at address p. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy_at ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value, void>::type - destroy_at(T* /*p*/, TCounter& count) + typename etlstd::enable_if::value, void>::type + destroy_at(T* /*p*/, TCounter& count) { --count; } @@ -649,37 +721,66 @@ namespace etl //***************************************************************************** /// Destroys an item at address p. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy_at ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value, void>::type - destroy_at(T* p, TCounter& count) + typename etlstd::enable_if::value, void>::type + destroy_at(T* p, TCounter& count) { p->~T(); --count; } +#else + //***************************************************************************** + /// Destroys an item at address p. + /// https://en.cppreference.com/w/cpp/memory/destroy_at + ///\ingroup memory + //***************************************************************************** + template + void destroy_at(T* p) + { + std::destroy_at(p); + } + //***************************************************************************** + /// Destroys an item at address p. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy_at + ///\ingroup memory + //***************************************************************************** + template + void destroy_at(T* /*p*/, TCounter& count) + { + --count; + std::destroy_at(p); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP17_SUPPORTED //***************************************************************************** /// Destroys a range of items. + /// https://en.cppreference.com/w/cpp/memory/destroy ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - destroy(TIterator /*i_begin*/, TIterator /*i_end*/) + typename etlstd::enable_if::value_type>::value, void>::type + destroy(TIterator /*i_begin*/, TIterator /*i_end*/) { } //***************************************************************************** /// Destroys a range of items. + /// https://en.cppreference.com/w/cpp/memory/destroy ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - destroy(TIterator i_begin, TIterator i_end) + typename etlstd::enable_if::value_type>::value, void>::type + destroy(TIterator i_begin, TIterator i_end) { while (i_begin != i_end) { - etl::destroy_at(etl::addressof(*i_begin)); + etlstd::destroy_at(etl::addressof(*i_begin)); ++i_begin; } } @@ -687,51 +788,82 @@ namespace etl //***************************************************************************** /// Destroys a range of items. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - destroy(TIterator i_begin, TIterator i_end, TCounter& count) + typename etlstd::enable_if::value_type>::value, void>::type + destroy(TIterator i_begin, TIterator i_end, TCounter& count) { - count -= int32_t(ETL_STD::distance(i_begin, i_end)); + count -= int32_t(etlstd::distance(i_begin, i_end)); } //***************************************************************************** /// Destroys a range of items. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, void>::type - destroy(TIterator i_begin, TIterator i_end, TCounter& count) + typename etlstd::enable_if::value_type>::value, void>::type + destroy(TIterator i_begin, TIterator i_end, TCounter& count) { - count -= int32_t(ETL_STD::distance(i_begin, i_end)); + count -= int32_t(etlstd::distance(i_begin, i_end)); while (i_begin != i_end) { - etl::destroy_at(etl::addressof(*i_begin)); + etlstd::destroy_at(etl::addressof(*i_begin)); ++i_begin; } } +#else + //***************************************************************************** + /// Destroys a range of items. + /// https://en.cppreference.com/w/cpp/memory/destroy + ///\ingroup memory + //***************************************************************************** + template + void destroy(TIterator i_begin, TIterator i_end) + { + std::destroy(i_begin, i_end); + } + //***************************************************************************** + /// Destroys a range of items. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy + ///\ingroup memory + //***************************************************************************** + template + void destroy(TIterator i_begin, TIterator i_end, TCounter& count) + { + count -= int32_t(etlstd::distance(i_begin, i_end)); + + std::destroy(i_begin, i_end); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP17_SUPPORTED //***************************************************************************** /// Destroys a number of items. + /// https://en.cppreference.com/w/cpp/memory/destroy_n ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TIterator>::type - destroy_n(TIterator i_begin, TSize n) + typename etlstd::enable_if::value_type>::value, TIterator>::type + destroy_n(TIterator i_begin, TSize n) { return i_begin + n; } //***************************************************************************** /// Destroys a number of items. + /// https://en.cppreference.com/w/cpp/memory/destroy_n ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TIterator>::type - destroy_n(TIterator i_begin, TSize n) + typename etlstd::enable_if::value_type>::value, TIterator>::type + destroy_n(TIterator i_begin, TSize n) { while (n > 0) { @@ -746,11 +878,12 @@ namespace etl //***************************************************************************** /// Destroys a number of items. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy_n ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TIterator>::type - destroy_n(TIterator i_begin, TSize n, TCounter& count) + typename etlstd::enable_if::value_type>::value, TIterator>::type + destroy_n(TIterator i_begin, TSize n, TCounter& count) { count -= n; return i_begin + n; @@ -759,11 +892,12 @@ namespace etl //***************************************************************************** /// Destroys a number of items. /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy_n ///\ingroup memory //***************************************************************************** template - typename etl::enable_if::value_type>::value, TIterator>::type - destroy_n(TIterator i_begin, TSize n, TCounter& count) + typename etlstd::enable_if::value_type>::value, TIterator>::type + destroy_n(TIterator i_begin, TSize n, TCounter& count) { count -= n; @@ -776,45 +910,37 @@ namespace etl return i_begin; } - +#else //***************************************************************************** - /// Copy constructs a derived class to an address. - ///\tparam T The derived type. + /// Destroys a number of items. + /// https://en.cppreference.com/w/cpp/memory/destroy_n ///\ingroup memory //***************************************************************************** - template - struct create_copy + template + TIterator destroy_n(TIterator i_begin, TSize n) { - void create_copy_at(void* p) - { - new (p) T(static_cast(*this)); - } + return std::destroy_n(i_begin, n); + } - template - void create_copy_at(void* p, TCounter& count) - { - new (p) T(static_cast(*this)); - ++count; - } + //***************************************************************************** + /// Destroys a number of items. + /// Debug counter version. + /// https://en.cppreference.com/w/cpp/memory/destroy_n + ///\ingroup memory + //***************************************************************************** + template + TIterator destroy_n(TIterator i_begin, TSize n, TCounter& count) + { + count -= n; - T& make_copy_at(void* p) - { - new (p) T(static_cast(*this)); - return *reinterpret_cast(p); - } - - template - T& make_copy_at(void* p, TCounter& count) - { - new (p) T(static_cast(*this)); - ++count; - return *reinterpret_cast(p); - } - }; + return std::destroy_n(i_begin, n); + } +#endif //***************************************************************************** /// Default deleter. ///\tparam T The pointed to type type. + /// https://en.cppreference.com/w/cpp/memory/default_delete ///\ingroup memory //***************************************************************************** template @@ -829,6 +955,7 @@ namespace etl //***************************************************************************** /// Default deleter for arrays. ///\tparam T The pointed to type type. + /// https://en.cppreference.com/w/cpp/memory/default_delete ///\ingroup memory //***************************************************************************** template @@ -844,126 +971,127 @@ namespace etl //***************************************************************************** /// Unique pointer. ///\tparam T The pointed to type type. + /// https://en.cppreference.com/w/cpp/memory/unique_ptr ///\ingroup memory //***************************************************************************** - template > + template > class unique_ptr { public: - typedef T element_type; - typedef T* pointer; - typedef T& reference; + typedef T element_type; + typedef T* pointer; + typedef T& reference; - ETL_CONSTEXPR unique_ptr() - : p(nullptr) - { - } + ETL_CONSTEXPR unique_ptr() + : p(nullptr) + { + } - ETL_CONSTEXPR explicit unique_ptr (pointer p_) - : p(p_) - { - } + ETL_CONSTEXPR explicit unique_ptr(pointer p_) + : p(p_) + { + } #if ETL_CPP11_SUPPORTED - unique_ptr (unique_ptr&& p_) - : p(p_.release()) - { - } + unique_ptr(unique_ptr&& p_) + : p(p_.release()) + { + } #endif - ~unique_ptr() - { - deleter(p); - } + ~unique_ptr() + { + deleter(p); + } - ETL_CONSTEXPR pointer get() const - { - return p; - } + ETL_CONSTEXPR pointer get() const + { + return p; + } - TDeleter& get_deleter() - { - return deleter; - } + TDeleter& get_deleter() + { + return deleter; + } - const TDeleter& get_deleter() const - { - return deleter; - } + const TDeleter& get_deleter() const + { + return deleter; + } - pointer release() - { - pointer value = p; - p = nullptr; + pointer release() + { + pointer value = p; + p = nullptr; - return value; - } + return value; + } - void reset(pointer p_ = pointer()) - { - assert(p_ != p); + void reset(pointer p_ = pointer()) + { + assert(p_ != p); - pointer value = p; - p = p_; - deleter(value); - } + pointer value = p; + p = p_; + deleter(value); + } - void swap(unique_ptr& value) - { - ETL_STD::swap(p, value.p); - } + void swap(unique_ptr& value) + { + swap(p, value.p); + } - ETL_CONSTEXPR operator bool() const - { - return (p != nullptr); - } + ETL_CONSTEXPR operator bool() const + { + return (p != nullptr); + } - unique_ptr& operator =(pointer p_) - { - reset(p_); + unique_ptr& operator =(pointer p_) + { + reset(p_); - return *this; - } + return *this; + } #if ETL_CPP11_SUPPORTED - unique_ptr& operator =(unique_ptr&& p_) - { - reset(p_.release()); + unique_ptr& operator =(unique_ptr&& p_) + { + reset(p_.release()); - return *this; - } + return *this; + } #endif - ETL_CONSTEXPR reference operator *() const - { - return *get(); - } + ETL_CONSTEXPR reference operator *() const + { + return *get(); + } - ETL_CONSTEXPR pointer operator ->() const - { - return get(); - } + ETL_CONSTEXPR pointer operator ->() const + { + return get(); + } - ETL_CONSTEXPR reference operator [](size_t i) const - { - return get()[i]; - } + ETL_CONSTEXPR reference operator [](size_t i) const + { + return get()[i]; + } - ETL_CONSTEXPR bool operator== (const pointer p_) const - { - return p == p_; - } + ETL_CONSTEXPR bool operator== (const pointer p_) const + { + return p == p_; + } - ETL_CONSTEXPR bool operator== (const unique_ptr& p_) const - { - return p == p_.p; - } + ETL_CONSTEXPR bool operator== (const unique_ptr& p_) const + { + return p == p_.p; + } - ETL_CONSTEXPR bool operator< (const unique_ptr& p_) const - { - return p < p_.p; - } + ETL_CONSTEXPR bool operator< (const unique_ptr& p_) const + { + return p < p_.p; + } private: @@ -979,6 +1107,7 @@ namespace etl //***************************************************************************** /// Unique pointer for arrays. ///\tparam T The pointed to type type. + /// https://en.cppreference.com/w/cpp/memory/unique_ptr ///\ingroup memory //***************************************************************************** template @@ -1045,7 +1174,7 @@ namespace etl void swap(unique_ptr& v) { - ETL_STD::swap(p, v.p); + swap(p, v.p); } ETL_CONSTEXPR operator bool() const @@ -1109,6 +1238,237 @@ namespace etl pointer p; }; +} + +namespace etl +{ + //***************************************************************************** + /// Default contruct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::enable_if::value, void>::type + create_default_at(T* /*p*/) + { + } + + //***************************************************************************** + /// Default contruct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::enable_if::value, void>::type + create_default_at(T* /*p*/, TCounter& count) + { + ++count; + } + + //***************************************************************************** + /// Default contruct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::enable_if::value, void>::type + create_default_at(T* p) + { + ::new (p) T; + } + + //***************************************************************************** + /// Default contruct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + typename etlstd::enable_if::value, void>::type + create_default_at(T* p, TCounter& count) + { + ::new (p) T; + ++count; + } + + //***************************************************************************** + /// Value construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + void create_value_at(T* p) + { + ::new (p) T(); + } + + //***************************************************************************** + /// Value construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + void create_value_at(T* p, TCounter& count) + { + ::new (p) T(); + ++count; + } + + //***************************************************************************** + /// Copy construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + void create_copy_at(T* p, const T& value) + { + ::new (p) T(value); + } + +#if ETL_CPP11_SUPPORTED + //***************************************************************************** + /// Copy construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + void create_copy_at(T* p, T&& value) + { + ::new (p) T(etlstd::move(value)); + } +#endif + + //***************************************************************************** + /// Copy construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + void create_copy_at(T* p, const T& value, TCounter& count) + { + ::new (p) T(value); + ++count; + } + + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_default_at(T* p) + { + ::new (p) T(); + return *reinterpret_cast(p); + } + + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_default_at(T* p, TCounter& count) + { + ::new (p) T(); + ++count; + return *reinterpret_cast(p); + } + + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_copy_at(T* p, const T& other) + { + ::new (p) T(other); + return *reinterpret_cast(p); + } + +#if ETL_CPP11_SUPPORTED + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_copy_at(T* p, T&& other) + { + ::new (p) T(etlstd::move(other)); + return *reinterpret_cast(p); + } +#endif + + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_copy_at(T* p, const T& other, TCounter& count) + { + ::new (p) T(other); + ++count; + return *reinterpret_cast(p); + } + + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_value_at(T* p, const TParameter& value) + { + ::new (p) T(value); + return *reinterpret_cast(p); + } + +#if ETL_CPP11_SUPPORTED + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_value_at(T* p, TParameter&& value) + { + ::new (p) T(etlstd::move(value)); + return *reinterpret_cast(p); + } +#endif + + //***************************************************************************** + /// Construct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + T& make_value_at(T* p, const TParameter& value, TCounter& count) + { + ::new (p) T(value); + ++count; + return *reinterpret_cast(p); + } + + //***************************************************************************** + /// Copy constructs a derived class to an address. + ///\tparam T The derived type. + ///\ingroup memory + //***************************************************************************** + template + struct create_copy + { + void create_copy_at(void* p) + { + new (p) T(static_cast(*this)); + } + + template + void create_copy_at(void* p, TCounter& count) + { + new (p) T(static_cast(*this)); + ++count; + } + + T& make_copy_at(void* p) + { + new (p) T(static_cast(*this)); + return *reinterpret_cast(p); + } + + template + T& make_copy_at(void* p, TCounter& count) + { + new (p) T(static_cast(*this)); + ++count; + return *reinterpret_cast(p); + } + }; //***************************************************************************** /// A low level function that clears an object's memory to zero. @@ -1159,7 +1519,7 @@ namespace etl template void memory_clear_range(volatile T* begin, volatile T* end) { - const size_t n = static_cast(ETL_STD::distance(begin, end)); + const size_t n = static_cast(etlstd::distance(begin, end)); memory_clear_range(begin, n); } @@ -1217,7 +1577,7 @@ namespace etl template void memory_set_range(volatile T* begin, volatile T* end, const char value) { - const size_t n = static_cast(ETL_STD::distance(begin, end)); + const size_t n = static_cast(etlstd::distance(begin, end)); memory_set_range(begin, n, value); } diff --git a/include/etl/message_bus.h b/include/etl/message_bus.h index 2844feea..cda5bef6 100644 --- a/include/etl/message_bus.h +++ b/include/etl/message_bus.h @@ -102,10 +102,10 @@ namespace etl if (ok) { - router_list_t::iterator irouter = ETL_STD::upper_bound(router_list.begin(), - router_list.end(), - router.get_message_router_id(), - compare_router_id()); + router_list_t::iterator irouter = etlstd::upper_bound(router_list.begin(), + router_list.end(), + router.get_message_router_id(), + compare_router_id()); router_list.insert(irouter, &router); } @@ -125,10 +125,10 @@ namespace etl } else { - ETL_PAIR range = ETL_STD::equal_range(router_list.begin(), - router_list.end(), - id, - compare_router_id()); + ETL_PAIR range = etlstd::equal_range(router_list.begin(), + router_list.end(), + id, + compare_router_id()); router_list.erase(range.first, range.second); } @@ -137,9 +137,9 @@ namespace etl //******************************************* void unsubscribe(etl::imessage_router& router) { - router_list_t::iterator irouter = ETL_STD::find(router_list.begin(), - router_list.end(), - &router); + router_list_t::iterator irouter = etlstd::find(router_list.begin(), + router_list.end(), + &router); if (irouter != router_list.end()) { @@ -212,10 +212,10 @@ namespace etl router_list_t::iterator irouter = router_list.begin(); // Find routers with the id. - ETL_PAIR range = ETL_STD::equal_range(router_list.begin(), - router_list.end(), - destination_router_id, - compare_router_id()); + ETL_PAIR range = etlstd::equal_range(router_list.begin(), + router_list.end(), + destination_router_id, + compare_router_id()); // Call all of them. while (range.first != range.second) @@ -230,10 +230,10 @@ namespace etl // Do any message buses. // These are always at the end of the list. - irouter = ETL_STD::lower_bound(router_list.begin(), - router_list.end(), - etl::imessage_bus::MESSAGE_BUS, - compare_router_id()); + irouter = etlstd::lower_bound(router_list.begin(), + router_list.end(), + etl::imessage_bus::MESSAGE_BUS, + compare_router_id()); while (irouter != router_list.end()) { diff --git a/include/etl/multimap.h b/include/etl/multimap.h index 34e11f60..371a1639 100644 --- a/include/etl/multimap.h +++ b/include/etl/multimap.h @@ -37,9 +37,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #include "container.h" #include "pool.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: @@ -733,7 +733,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -853,7 +853,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -960,10 +960,10 @@ namespace etl }; friend class const_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* /// Gets the beginning of the multimap. @@ -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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2044,10 +2044,7 @@ namespace etl template bool operator <(const etl::imultimap& lhs, const etl::imultimap& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), - lhs.end(), - rhs.begin(), - rhs.end()); + return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/multiset.h b/include/etl/multiset.h index 6e03ce4b..958affdc 100644 --- a/include/etl/multiset.h +++ b/include/etl/multiset.h @@ -37,9 +37,9 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #include "parameter_type.h" #include "container.h" @@ -623,7 +623,7 @@ namespace etl /// A templated base for all etl::multiset types. ///\ingroup set //*************************************************************************** - template > + template > class imultiset : public etl::multiset_base { public: @@ -713,7 +713,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -818,7 +818,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -925,10 +925,10 @@ namespace etl }; friend class const_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* /// Gets the beginning of the multiset. @@ -1895,7 +1895,7 @@ namespace etl //************************************************************************* /// A templated multiset implementation that uses a fixed size buffer. //************************************************************************* - template > + template > class multiset : public etl::imultiset { public: @@ -1982,7 +1982,7 @@ namespace etl template bool operator ==(const etl::imultiset& lhs, const etl::imultiset& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && ETL_OR_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2008,7 +2008,7 @@ namespace etl template bool operator <(const etl::imultiset& lhs, const etl::imultiset& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), + return ETL_OR_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); diff --git a/include/etl/murmur3.h b/include/etl/murmur3.h index 5d54f47b..6b869c7b 100644 --- a/include/etl/murmur3.h +++ b/include/etl/murmur3.h @@ -57,7 +57,7 @@ namespace etl { public: - ETL_STATIC_ASSERT((etl::is_same::value || etl::is_same::value), "Only 32 & 64 bit types supported"); + ETL_STATIC_ASSERT((etlstd::is_same::value || etlstd::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 ETL_STD::iterator_traits::value_type) == 1, "Incompatible type"); + ETL_STATIC_ASSERT(sizeof(typename etlstd::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 ETL_STD::iterator_traits::value_type) == 1, "Incompatible type"); + ETL_STATIC_ASSERT(sizeof(typename etlstd::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 7b2a6b33..eecf73a8 100644 --- a/include/etl/negative.h +++ b/include/etl/negative.h @@ -39,7 +39,7 @@ namespace etl // For signed types. //*************************************************************************** template - typename etl::enable_if::value, bool>::type + typename etlstd::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 etl::enable_if::value, T>::type + typename etlstd::enable_if::value, T>::type is_negative(const T) { return false; diff --git a/include/etl/observer.h b/include/etl/observer.h index 9de10a64..9441f07c 100644 --- a/include/etl/observer.h +++ b/include/etl/observer.h @@ -115,9 +115,9 @@ namespace etl void add_observer(TObserver& observer) { // See if we already have it in our list. - typename Observer_List::const_iterator i_observer = ETL_STD::find(observer_list.begin(), - observer_list.end(), - &observer); + typename Observer_List::const_iterator i_observer = etlstd::find(observer_list.begin(), + observer_list.end(), + &observer); // Not there? if (i_observer == observer_list.end()) @@ -138,9 +138,9 @@ namespace etl bool remove_observer(TObserver& observer) { // See if we have it in our list. - typename Observer_List::iterator i_observer = ETL_STD::find(observer_list.begin(), - observer_list.end(), - &observer); + typename Observer_List::iterator i_observer = etlstd::find(observer_list.begin(), + observer_list.end(), + &observer); // Found it? if (i_observer != observer_list.end()) diff --git a/include/etl/optional.h b/include/etl/optional.h index b03636f9..dc2d5b58 100644 --- a/include/etl/optional.h +++ b/include/etl/optional.h @@ -39,7 +39,7 @@ SOFTWARE. #include "exception.h" #include "error_handler.h" -#include "stl/utility.h" +#include "utility.h" namespace etl { @@ -343,7 +343,7 @@ namespace etl storage.template get_reference().~T(); } - ::new (storage.template get_address()) T(ETL_STD::forward(args)...); + ::new (storage.template get_address()) T(ETL_OR_STD::forward(args)...); valid = true; } #else diff --git a/include/etl/packet.h b/include/etl/packet.h index 35390315..b25e55fe 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((etl::is_base_of::value), "Unsupported type"); + ETL_STATIC_ASSERT((etlstd::is_base_of::value), "Unsupported type"); ETL_STATIC_ASSERT(sizeof(T) <= SIZE, "Unsupported size"); - ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Unsupported alignment"); + ETL_STATIC_ASSERT(etlstd::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((etl::is_base_of::value), "Unsupported type"); + ETL_STATIC_ASSERT((etlstd::is_base_of::value), "Unsupported type"); ETL_STATIC_ASSERT(sizeof(T) <= SIZE, "Unsupported size"); - ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Unsupported alignment"); + ETL_STATIC_ASSERT(etlstd::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 019daaea..d0694544 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 etl::conditional::value || is_pointer::value, + typedef typename etlstd::conditional::value || is_pointer::value, T, const T&>::type type; }; diff --git a/include/etl/pearson.h b/include/etl/pearson.h index ab06cfa0..eebcec57 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 ETL_STD::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etlstd::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 ETL_STD::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits::value_type) == 1, "Type not supported"); while (begin != end) { diff --git a/include/etl/platform.h b/include/etl/platform.h index c2e9cd14..5df07d4f 100644 --- a/include/etl/platform.h +++ b/include/etl/platform.h @@ -102,4 +102,9 @@ SOFTWARE. #define ETL_EXPLICIT_STRING_FROM_CHAR #endif +// Sort out names for STL/No STL options. +#include "private/choose_namespace.h" +#include "private/choose_tag_types.h" +#include "private/choose_pair_types.h" + #endif diff --git a/include/etl/pool.h b/include/etl/pool.h index a70d4b6d..232f504a 100644 --- a/include/etl/pool.h +++ b/include/etl/pool.h @@ -35,8 +35,8 @@ SOFTWARE. #include -#include "stl/algorithm.h" -#include "stl/iterator.h" +#include "algorithm.h" +#include "iterator.h" #include "error_handler.h" #include "alignment.h" @@ -224,7 +224,7 @@ namespace etl if (p) { - ::new (p) T(ETL_STD::forward(args)...); + ::new (p) T(etlstd::forward(args)...); } return p; @@ -492,7 +492,7 @@ namespace etl template U* allocate() { - ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); - return ipool::create(ETL_STD::forward(args)...); + return ipool::create(etlstd::forward(args)...); } #endif @@ -583,7 +583,7 @@ namespace etl template void destroy(const void* const p_object) { - ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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(ETL_STD::forward(args)...); + return base_t::template create(etlstd::forward(args)...); } #endif @@ -736,7 +736,7 @@ namespace etl template void destroy(const void* const p_object) { - ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); + ETL_STATIC_ASSERT(etlstd::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 9904c908..5a232a4d 100644 --- a/include/etl/priority_queue.h +++ b/include/etl/priority_queue.h @@ -35,8 +35,8 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "functional.h" #include "container.h" #include "vector.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 ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 - ETL_STD::push_heap(container.begin(), container.end(), compare); + etlstd::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(ETL_STD::forward(args)...); + container.emplace_back(etlstd::forward(args)...); // Make elements in container into heap - ETL_STD::push_heap(container.begin(), container.end(), compare); + etlstd::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 - ETL_STD::push_heap(container.begin(), container.end(), compare); + etlstd::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 - ETL_STD::push_heap(container.begin(), container.end(), compare); + etlstd::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 - ETL_STD::push_heap(container.begin(), container.end(), compare); + etlstd::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 - ETL_STD::push_heap(container.begin(), container.end(), compare); + etlstd::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 = ETL_STD::distance(first, last); + difference_type d = etlstd::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); - ETL_STD::make_heap(container.begin(), container.end(), compare); + etlstd::make_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -285,7 +285,7 @@ namespace etl void pop() { // Move largest element to end - ETL_STD::pop_heap(container.begin(), container.end(), compare); + etlstd::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 = ETL_STD::less > + template , typename TCompare = etlstd::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 935b72ac..c8271715 100644 --- a/include/etl/private/choose_namespace.h +++ b/include/etl/private/choose_namespace.h @@ -28,19 +28,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ******************************************************************************/ -#ifndef ETL_STL_CHOOSE_NAMESPACE_INCLUDED -#define ETL_STL_CHOOSE_NAMESPACE_INCLUDED +#ifndef ETL_CHOOSE_NAMESPACE_INCLUDED +#define ETL_CHOOSE_NAMESPACE_INCLUDED #include "../platform.h" -#if defined(ETL_NO_STL) - #ifndef ETL_STD - #define ETL_STD etlstd /// Namespace for the alternate STL. - #endif +#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 #else - #ifndef ETL_STD - #define ETL_STD std /// Namespace for conventional STL - #endif + // We will use the STL's definitions under the std namespace + #define ETL_OR_STD std #endif #endif diff --git a/include/etl/private/choose_pair_types.h b/include/etl/private/choose_pair_types.h deleted file mode 100644 index 96ba73fe..00000000 --- a/include/etl/private/choose_pair_types.h +++ /dev/null @@ -1,46 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2019 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_CHOOSE_PAIR_TYPES_INCLUDED -#define ETL_STL_CHOOSE_PAIR_TYPES_INCLUDED - -#include "../platform.h" - -// When in the unit tests we have to ensure that the STL and ETL are using the same definitions. -#if defined(ETL_IN_UNIT_TEST) || !defined(ETL_NO_STL) - #include - #define ETL_PAIR std::pair - #define ETL_MAKE_PAIR std::make_pair -#else - #define ETL_PAIR etlstd::pair - #define ETL_MAKE_PAIR etlstd::make_pair -#endif - -#endif diff --git a/include/etl/private/choose_tag_types.h b/include/etl/private/choose_tag_types.h deleted file mode 100644 index 7b536de8..00000000 --- a/include/etl/private/choose_tag_types.h +++ /dev/null @@ -1,52 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2019 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_CHOOSE_TAG_TYPES_INCLUDED -#define ETL_STL_CHOOSE_TAG_TYPES_INCLUDED - -#include "../platform.h" - -// When in the unit tests we have to ensure that the STL and ETL are using the same definitions. -#if defined(ETL_IN_UNIT_TEST) || !defined(ETL_NO_STL) - #include - #define ETL_INPUT_ITERATOR_TAG std::input_iterator_tag - #define ETL_OUTPUT_ITERATOR_TAG std::output_iterator_tag - #define ETL_FORWARD_ITERATOR_TAG std::forward_iterator_tag - #define ETL_BIDIRECTIONAL_ITERATOR_TAG std::bidirectional_iterator_tag - #define ETL_RANDOM_ACCESS_ITERATOR_TAG std::random_access_iterator_tag -#else - #define ETL_INPUT_ITERATOR_TAG etlstd::input_iterator_tag - #define ETL_OUTPUT_ITERATOR_TAG etlstd::output_iterator_tag - #define ETL_FORWARD_ITERATOR_TAG etlstd::forward_iterator_tag - #define ETL_BIDIRECTIONAL_ITERATOR_TAG etlstd::bidirectional_iterator_tag - #define ETL_RANDOM_ACCESS_ITERATOR_TAG etlstd::random_access_iterator_tag -#endif - -#endif diff --git a/include/etl/private/crc16_poly_0x1021_.h b/include/etl/private/crc16_poly_0x1021_.h index 793009d6..85fc83d0 100644 --- a/include/etl/private/crc16_poly_0x1021_.h +++ b/include/etl/private/crc16_poly_0x1021_.h @@ -36,8 +36,7 @@ SOFTWARE. #include "../platform.h" #include "../frame_check_sequence.h" #include "../binary.h" - -#include "../stl/iterator.h" +#include "../iterator.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 diff --git a/include/etl/private/crc16_poly_0x8005.h b/include/etl/private/crc16_poly_0x8005.h index 86f61343..14526ff5 100644 --- a/include/etl/private/crc16_poly_0x8005.h +++ b/include/etl/private/crc16_poly_0x8005.h @@ -36,8 +36,7 @@ SOFTWARE. #include "../platform.h" #include "../frame_check_sequence.h" #include "../binary.h" - -#include "../stl/iterator.h" +#include "../iterator.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 diff --git a/include/etl/private/crc32_poly_0x04c11db7.h b/include/etl/private/crc32_poly_0x04c11db7.h index 142d30e6..801e70e8 100644 --- a/include/etl/private/crc32_poly_0x04c11db7.h +++ b/include/etl/private/crc32_poly_0x04c11db7.h @@ -36,8 +36,7 @@ SOFTWARE. #include "../platform.h" #include "../frame_check_sequence.h" #include "../binary.h" - -#include "../stl/iterator.h" +#include "../iterator.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 diff --git a/include/etl/private/crc32_poly_0x1edc6f41.h b/include/etl/private/crc32_poly_0x1edc6f41.h index 969bdcc6..c389a424 100644 --- a/include/etl/private/crc32_poly_0x1edc6f41.h +++ b/include/etl/private/crc32_poly_0x1edc6f41.h @@ -36,8 +36,7 @@ SOFTWARE. #include "../platform.h" #include "../frame_check_sequence.h" #include "../binary.h" - -#include "../stl/iterator.h" +#include "../iterator.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 diff --git a/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h b/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h index 83f46d48..4c09435b 100644 --- a/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h +++ b/include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h @@ -36,8 +36,7 @@ SOFTWARE. #include "../platform.h" #include "../frame_check_sequence.h" #include "../binary.h" - -#include "../stl/iterator.h" +#include "../iterator.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 diff --git a/include/etl/private/crc8_poly_0x07.h b/include/etl/private/crc8_poly_0x07.h index 558ea003..7615d0e2 100644 --- a/include/etl/private/crc8_poly_0x07.h +++ b/include/etl/private/crc8_poly_0x07.h @@ -36,8 +36,7 @@ SOFTWARE. #include "../platform.h" #include "../frame_check_sequence.h" #include "../binary.h" - -#include "../stl/iterator.h" +#include "../iterator.h" #if defined(ETL_COMPILER_KEIL) #pragma diag_suppress 1300 diff --git a/include/etl/private/ivectorpointer.h b/include/etl/private/ivectorpointer.h index 51e174f4..3497cf2c 100644 --- a/include/etl/private/ivectorpointer.h +++ b/include/etl/private/ivectorpointer.h @@ -56,10 +56,10 @@ namespace etl typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::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(ETL_STD::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) } }; @@ -467,10 +467,10 @@ namespace etl typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::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(ETL_STD::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) } }; diff --git a/include/etl/private/pvoidvector.h b/include/etl/private/pvoidvector.h index 7277b299..172dd41b 100644 --- a/include/etl/private/pvoidvector.h +++ b/include/etl/private/pvoidvector.h @@ -41,8 +41,8 @@ SOFTWARE. #include "../type_traits.h" #include "../error_handler.h" -#include "../stl/functional.h" -#include "../stl/iterator.h" +#include "../functional.h" +#include "../iterator.h" #ifdef ETL_COMPILER_GCC #pragma GCC diagnostic ignored "-Wunused-variable" @@ -67,10 +67,10 @@ namespace etl typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef ETL_STD::iterator_traits::difference_type difference_type; + typedef etlstd::iterator_traits::difference_type difference_type; public: @@ -211,7 +211,7 @@ namespace etl // Size up if necessary. if (p_end < p_new_end) { - ETL_STD::fill(p_end, p_new_end, value); + etlstd::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 = ETL_STD::distance(first, last); + difference_type d = etlstd::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; - ETL_STD::copy_backward(position, end() - 1, end()); + etlstd::copy_backward(position, end() - 1, end()); *position = value; } else @@ -424,8 +424,8 @@ namespace etl { ETL_ASSERT((size() + 1) <= CAPACITY, ETL_ERROR(vector_full)); - ETL_STD::copy_backward(position, p_end, p_end + n); - ETL_STD::fill_n(position, n, value); + etlstd::copy_backward(position, p_end, p_end + n); + etlstd::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 = ETL_STD::distance(first, last); + size_t count = etlstd::distance(first, last); ETL_ASSERT((size() + count) <= CAPACITY, ETL_ERROR(vector_full)); - ETL_STD::copy_backward(position, p_end, p_end + count); - ETL_STD::copy(first, last, position); + etlstd::copy_backward(position, p_end, p_end + count); + etlstd::copy(first, last, position); p_end += count; } @@ -457,7 +457,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - ETL_STD::copy(i_element + 1, end(), i_element); + etlstd::copy(i_element + 1, end(), i_element); --p_end; return i_element; @@ -473,8 +473,8 @@ namespace etl //********************************************************************* iterator erase(iterator first, iterator last) { - ETL_STD::copy(last, end(), first); - size_t n_delete = ETL_STD::distance(first, last); + etlstd::copy(last, end(), first); + size_t n_delete = etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etlstd::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 31452b86..f2102f41 100644 --- a/include/etl/private/to_string_helper.h +++ b/include/etl/private/to_string_helper.h @@ -42,10 +42,9 @@ SOFTWARE. #include "../type_traits.h" #include "../container.h" #include "../absolute.h" - -#include "../stl/algorithm.h" -#include "../stl/iterator.h" -#include "../stl/limits.h" +#include "../algorithm.h" +#include "../iterator.h" +#include "../limits.h" namespace etl { @@ -57,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(ETL_STD::distance(position, str.end())); + uint32_t length = static_cast(etlstd::distance(position, str.end())); if (length < format.get_width()) { @@ -166,7 +165,7 @@ namespace etl } // Reverse the string we appended. - ETL_STD::reverse(start, str.end()); + etlstd::reverse(start, str.end()); } etl::private_to_string::add_alignment(str, start, format); @@ -242,7 +241,7 @@ namespace etl else { // Make sure we format the two halves correctly. - uint32_t max_precision = ETL_STD::numeric_limits::digits10; + uint32_t max_precision = etlstd::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()); @@ -355,10 +354,10 @@ namespace etl /// For signed integrals less than 64 bits. Default format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_signed::value && - !etl::is_same::value && - !etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_signed::value && + !etlstd::is_same::value && + !etlstd::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -372,10 +371,10 @@ namespace etl /// For signed integrals less than 64 bits. Supplied format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_signed::value && - !etl::is_same::value && - !etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_signed::value && + !etlstd::is_same::value && + !etlstd::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); @@ -387,10 +386,10 @@ namespace etl /// For unsigned integrals less then 64 bits. Default format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_unsigned::value && - !etl::is_same::value && - !etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_unsigned::value && + !etlstd::is_same::value && + !etlstd::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -404,10 +403,10 @@ namespace etl /// For unsigned integrals less than 64 bits. Supplied format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_unsigned::value && - !etl::is_same::value && - !etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_unsigned::value && + !etlstd::is_same::value && + !etlstd::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); @@ -419,10 +418,10 @@ namespace etl /// For signed 64 bit integrals. Default format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_signed::value && - !etl::is_same::value && - etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_signed::value && + !etlstd::is_same::value && + etlstd::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -436,10 +435,10 @@ namespace etl /// For signed 64 bit integrals. Supplied format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_signed::value && - !etl::is_same::value && - etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_signed::value && + !etlstd::is_same::value && + etlstd::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); @@ -451,10 +450,10 @@ namespace etl /// For unsigned 64 bit integrals. Default format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_unsigned::value && - !etl::is_same::value && - etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_unsigned::value && + !etlstd::is_same::value && + etlstd::is_same::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -468,10 +467,10 @@ namespace etl /// For unsigned 64 bit integrals. Supplied format spec. //*************************************************************************** template - typename etl::enable_if::value && - etl::is_unsigned::value && - !etl::is_same::value && - etl::is_same::value, const TIString&>::type + typename etlstd::enable_if::value && + etlstd::is_unsigned::value && + !etlstd::is_same::value && + etlstd::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); @@ -483,7 +482,7 @@ namespace etl /// For floating point. Default format spec. //*************************************************************************** template - typename etl::enable_if::value, const TIString&>::type + typename etlstd::enable_if::value, const TIString&>::type to_string(const T value, TIString& str, const bool append = false) { etl::basic_format_spec format; @@ -497,7 +496,7 @@ namespace etl /// For floating point. Supplied format spec. //*************************************************************************** template - typename etl::enable_if::value, const TIString&>::type + typename etlstd::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 143bd5b2..a251690b 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(ETL_STD::forward(args)...); + ::new (&p_buffer[in]) T(etlstd::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 9a52eb53..e71de49f 100644 --- a/include/etl/queue_mpmc_mutex.h +++ b/include/etl/queue_mpmc_mutex.h @@ -46,7 +46,7 @@ SOFTWARE. #include "memory_model.h" #include "integral_limits.h" -#include "stl/utility.h" +#include "utility.h" #undef ETL_FILE #define ETL_FILE "48" @@ -179,7 +179,7 @@ namespace etl { access.lock(); - bool result = emplace_implementation(ETL_STD::forward(args)...); + bool result = emplace_implementation(etlstd::forward(args)...); access.unlock(); @@ -392,7 +392,7 @@ namespace etl { if (current_size != MAX_SIZE) { - ::new (&p_buffer[write_index]) T(ETL_STD::forward(args)...); + ::new (&p_buffer[write_index]) T(etlstd::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 08d36e1d..98f681b8 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(ETL_STD::forward(args)...); + ::new (&p_buffer[write_index]) T(etlstd::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 e2b449d3..87ae3c98 100644 --- a/include/etl/queue_spsc_isr.h +++ b/include/etl/queue_spsc_isr.h @@ -42,7 +42,7 @@ SOFTWARE. #include "memory_model.h" #include "integral_limits.h" -#include "stl/utility.h" +#include "utility.h" #undef ETL_FILE #define ETL_FILE "46" @@ -82,7 +82,7 @@ namespace etl template bool emplace_from_isr(Args&&... args) { - return emplace_implementation(ETL_STD::forward(args)...); + return emplace_implementation(etlstd::forward(args)...); } #endif @@ -207,7 +207,7 @@ namespace etl { if (current_size != MAX_SIZE) { - ::new (&p_buffer[write_index]) T(ETL_STD::forward(args)...); + ::new (&p_buffer[write_index]) T(etlstd::forward(args)...); write_index = get_next_index(write_index, MAX_SIZE); @@ -440,7 +440,7 @@ namespace etl { TAccess::lock(); - bool result = this->emplace_implementation(ETL_STD::forward(args)...); + bool result = this->emplace_implementation(etlstd::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 2f62dee5..52f7e5f5 100644 --- a/include/etl/queue_spsc_locked.h +++ b/include/etl/queue_spsc_locked.h @@ -43,7 +43,7 @@ SOFTWARE. #include "integral_limits.h" #include "function.h" -#include "stl/utility.h" +#include "utility.h" #undef ETL_FILE #define ETL_FILE "46" @@ -83,7 +83,7 @@ namespace etl template bool emplace_from_unlocked(Args&&... args) { - return emplace_implementation(ETL_STD::forward(args)...); + return emplace_implementation(etlstd::forward(args)...); } #endif @@ -208,7 +208,7 @@ namespace etl { if (current_size != MAX_SIZE) { - ::new (&p_buffer[write_index]) T(ETL_STD::forward(args)...); + ::new (&p_buffer[write_index]) T(etlstd::forward(args)...); write_index = get_next_index(write_index, MAX_SIZE); @@ -437,7 +437,7 @@ namespace etl { lock(); - bool result = this->emplace_implementation(ETL_STD::forward(args)...); + bool result = this->emplace_implementation(etlstd::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 4f95009d..9f834854 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: @@ -126,7 +126,7 @@ namespace etl typedef size_t size_type; //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -224,7 +224,7 @@ namespace etl }; //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -317,9 +317,9 @@ namespace etl typename lookup_t::const_iterator ilookup; }; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; protected: @@ -525,10 +525,10 @@ namespace etl template void assign(TIterator first, TIterator last) { - ETL_STATIC_ASSERT((etl::is_same::value_type>::value), "Incompatible data for assign"); + ETL_STATIC_ASSERT((etlstd::is_same::value_type>::value), "Incompatible data for assign"); #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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 ETL_STD::lower_bound(begin(), end(), key, compare); + return etlstd::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -703,7 +703,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(key_parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etlstd::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -713,7 +713,7 @@ namespace etl //********************************************************************* iterator upper_bound(key_parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etlstd::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -723,7 +723,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(key_parameter_t key) const { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etlstd::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -733,9 +733,9 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(key_parameter_t key) { - iterator i_lower = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator i_lower = etlstd::lower_bound(begin(), end(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, end(), key, compare)); + return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, end(), key, compare)); } //********************************************************************* @@ -745,9 +745,9 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(key_parameter_t key) const { - const_iterator i_lower = ETL_STD::lower_bound(cbegin(), cend(), key, compare); + const_iterator i_lower = etlstd::lower_bound(cbegin(), cend(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, cend(), key, compare)); + return ETL_MAKE_PAIR(i_lower, etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etlstd::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 b8c58f68..9af3770f 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: @@ -101,7 +101,7 @@ namespace etl typedef size_t size_type; //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -199,7 +199,7 @@ namespace etl }; //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -292,9 +292,9 @@ namespace etl typename lookup_t::const_iterator ilookup; }; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; protected: @@ -443,7 +443,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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 = ETL_STD::distance(range.first, range.second); + size_t d = etlstd::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -605,7 +605,7 @@ namespace etl { ETL_PAIR range = equal_range(key); - return ETL_STD::distance(range.first, range.second); + return etlstd::distance(range.first, range.second); } //********************************************************************* @@ -615,7 +615,7 @@ namespace etl //********************************************************************* iterator lower_bound(key_parameter_t key) { - return ETL_STD::lower_bound(begin(), end(), key, compare); + return etlstd::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -625,7 +625,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(key_parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etlstd::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -635,7 +635,7 @@ namespace etl //********************************************************************* iterator upper_bound(key_parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etlstd::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -645,7 +645,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(key_parameter_t key) const { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etlstd::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -655,9 +655,9 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(key_parameter_t key) { - iterator i_lower = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator i_lower = etlstd::lower_bound(begin(), end(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, end(), key, compare)); + return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, end(), key, compare)); } //********************************************************************* @@ -667,9 +667,9 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(key_parameter_t key) const { - const_iterator i_lower = ETL_STD::lower_bound(cbegin(), cend(), key, compare); + const_iterator i_lower = etlstd::lower_bound(cbegin(), cend(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, cend(), key, compare)); + return ETL_MAKE_PAIR(i_lower, etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etlstd::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 5832da70..656cfe8e 100644 --- a/include/etl/reference_flat_multiset.h +++ b/include/etl/reference_flat_multiset.h @@ -35,10 +35,10 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" #include "type_traits.h" #include "vector.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: @@ -119,7 +119,7 @@ namespace etl public: //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -217,7 +217,7 @@ namespace etl }; //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -316,9 +316,9 @@ namespace etl public: - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; //********************************************************************* /// 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 = ETL_STD::distance(first, last); + difference_type d = etlstd::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 = ETL_STD::lower_bound(begin(), end(), value, compare); + iterator i_element = etlstd::lower_bound(begin(), end(), value, compare); if (i_element == end()) { @@ -524,7 +524,7 @@ namespace etl } else { - size_t d = ETL_STD::distance(range.first, range.second); + size_t d = etlstd::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 = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator itr = etlstd::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 = ETL_STD::lower_bound(begin(), end(), key, compare); + const_iterator itr = etlstd::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -616,7 +616,7 @@ namespace etl { ETL_PAIR range = equal_range(key); - return ETL_STD::distance(range.first, range.second); + return etlstd::distance(range.first, range.second); } //********************************************************************* @@ -626,7 +626,7 @@ namespace etl //********************************************************************* iterator lower_bound(parameter_t key) { - return ETL_STD::lower_bound(begin(), end(), key, compare); + return etlstd::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -636,7 +636,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etlstd::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -646,7 +646,7 @@ namespace etl //********************************************************************* iterator upper_bound(parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etlstd::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -656,7 +656,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(parameter_t key) const { - return ETL_STD::upper_bound(cbegin(), cend(), key, compare); + return etlstd::upper_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -666,7 +666,7 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(parameter_t key) { - return ETL_STD::equal_range(begin(), end(), key, compare); + return etlstd::equal_range(begin(), end(), key, compare); } //********************************************************************* @@ -676,7 +676,7 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(parameter_t key) const { - return ETL_STD::equal_range(begin(), end(), key, compare); + return etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** diff --git a/include/etl/reference_flat_set.h b/include/etl/reference_flat_set.h index 816255e8..aac9e529 100644 --- a/include/etl/reference_flat_set.h +++ b/include/etl/reference_flat_set.h @@ -35,10 +35,10 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" #include "type_traits.h" #include "pool.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: @@ -120,7 +120,7 @@ namespace etl public: //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -218,7 +218,7 @@ namespace etl }; //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -317,9 +317,9 @@ namespace etl public: - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + 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; //********************************************************************* /// 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 = ETL_STD::distance(first, last); + difference_type d = etlstd::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 = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator itr = etlstd::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 = ETL_STD::lower_bound(begin(), end(), key, compare); + const_iterator itr = etlstd::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -605,7 +605,7 @@ namespace etl //********************************************************************* iterator lower_bound(parameter_t key) { - return ETL_STD::lower_bound(begin(), end(), key, compare); + return etlstd::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -615,7 +615,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etlstd::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -625,7 +625,7 @@ namespace etl //********************************************************************* iterator upper_bound(parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etlstd::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -635,7 +635,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(parameter_t key) const { - return ETL_STD::upper_bound(cbegin(), cend(), key, compare); + return etlstd::upper_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -645,7 +645,7 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(parameter_t key) { - return ETL_STD::equal_range(begin(), end(), key, compare); + return etlstd::equal_range(begin(), end(), key, compare); } //********************************************************************* @@ -655,7 +655,7 @@ namespace etl //********************************************************************* ETL_PAIR equal_range(parameter_t key) const { - return ETL_STD::upper_bound(cbegin(), cend(), key, compare); + return etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** diff --git a/include/etl/scaled_rounding.h b/include/etl/scaled_rounding.h index bef1d15a..c2a27cdb 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 etl::conditional::value, int32_t, uint32_t>::type type; + typedef typename etlstd::conditional::value, int32_t, uint32_t>::type type; }; //***************************************************************************** @@ -67,7 +67,7 @@ namespace etl template T round_ceiling_unscaled(T value) { - ETL_STATIC_ASSERT(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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(etl::is_integral::value, "Type must be an integral"); + ETL_STATIC_ASSERT(etlstd::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 bd54a32f..ade7fc20 100644 --- a/include/etl/scheduler.h +++ b/include/etl/scheduler.h @@ -285,10 +285,10 @@ namespace etl if (!task_list.full()) { - typename task_list_t::iterator itask = ETL_STD::upper_bound(task_list.begin(), - task_list.end(), - task.get_task_priority(), - compare_priority()); + typename task_list_t::iterator itask = etlstd::upper_bound(task_list.begin(), + task_list.end(), + task.get_task_priority(), + compare_priority()); task_list.insert(itask, &task); } diff --git a/include/etl/set.h b/include/etl/set.h index b8d1e399..9304bbf4 100755 --- a/include/etl/set.h +++ b/include/etl/set.h @@ -46,9 +46,9 @@ SOFTWARE. #include "parameter_type.h" #include "iterator.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_NO_STL) #include @@ -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: @@ -549,7 +549,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -654,7 +654,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -761,10 +761,10 @@ namespace etl }; friend class const_iterator; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; //************************************************************************* /// Assignment operator. @@ -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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2063,10 +2063,7 @@ namespace etl template bool operator <(const etl::iset& lhs, const etl::iset& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), - lhs.end(), - rhs.begin(), - rhs.end()); + return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/smallest.h b/include/etl/smallest.h index b0e79020..0301376c 100644 --- a/include/etl/smallest.h +++ b/include/etl/smallest.h @@ -82,15 +82,15 @@ namespace etl // Set 'type' to be the smallest of the first parameter and any of the others. // This is recursive. - using type = typename etl::conditional<(etl::size_of() < etl::size_of()), // Boolean - T1, // TrueType - smallest_other> // FalseType - ::type; // The smallest type of the two. + using type = typename etlstd::conditional<(etl::size_of::value < etl::size_of::value), // Boolean + T1, // TrueType + smallest_other> // FalseType + ::type; // The smallest type of the two. // The size of the smallest type. enum { - size = etl::size_of() + size = etl::size_of::value }; }; @@ -106,7 +106,7 @@ namespace etl enum { - size = etl::size_of() + size = etl::size_of::value }; }; #else diff --git a/include/etl/smallest_generator.h b/include/etl/smallest_generator.h index 3b5c6d2c..54142e44 100644 --- a/include/etl/smallest_generator.h +++ b/include/etl/smallest_generator.h @@ -94,15 +94,15 @@ namespace etl // Set 'type' to be the smallest of the first parameter and any of the others. // This is recursive. - using type = typename etl::conditional<(etl::size_of() < etl::size_of()), // Boolean - T1, // TrueType - smallest_other> // FalseType - ::type; // The smallest type of the two. + using type = typename etlstd::conditional<(etl::size_of::value < etl::size_of::value), // Boolean + T1, // TrueType + smallest_other> // FalseType + ::type; // The smallest type of the two. // The size of the smallest type. enum { - size = etl::size_of() + size = etl::size_of::value }; }; @@ -118,7 +118,7 @@ namespace etl enum { - size = etl::size_of() + size = etl::size_of::value }; }; #else diff --git a/include/etl/sqrt.h b/include/etl/sqrt.h index 9fda08bf..d23da550 100644 --- a/include/etl/sqrt.h +++ b/include/etl/sqrt.h @@ -45,7 +45,7 @@ namespace etl template struct sqrt { - typedef typename etl::conditional<((I * I) > VALUE), + typedef typename etlstd::conditional<((I * I) > VALUE), etl::constant, etl::sqrt >::type type; diff --git a/include/etl/stack.h b/include/etl/stack.h index beba0899..84c99360 100644 --- a/include/etl/stack.h +++ b/include/etl/stack.h @@ -38,7 +38,7 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" +#include "algorithm.h" #include "container.h" #include "alignment.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(ETL_STD::forward(args)...); + ::new (&p_buffer[top_index]) T(etlstd::forward(args)...); } #else //************************************************************************* @@ -408,7 +408,7 @@ namespace etl //************************************************************************* void reverse() { - ETL_STD::reverse(p_buffer, p_buffer + current_size); + etlstd::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 800c7545..09aebb4c 100644 --- a/include/etl/state_chart.h +++ b/include/etl/state_chart.h @@ -235,9 +235,9 @@ namespace etl } else { - return ETL_STD::find_if(state_table.begin(), - state_table.end(), - is_state(state_id)); + return etlstd::find_if(state_table.begin(), + state_table.end(), + is_state(state_id)); } } @@ -280,9 +280,9 @@ namespace etl while (t != transition_table.end()) { // Scan the transition table from the latest position. - t = ETL_STD::find_if(t, - transition_table.end(), - is_transition(event_id, current_state_id)); + t = etlstd::find_if(t, + transition_table.end(), + is_transition(event_id, current_state_id)); // Found an entry? if (t != transition_table.end()) diff --git a/include/etl/stl/algorithm.h b/include/etl/stl/algorithm.h deleted file mode 100644 index 20df7f5b..00000000 --- a/include/etl/stl/algorithm.h +++ /dev/null @@ -1,46 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2018 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_ALGORITHM_INCLUDED -#define ETL_STL_ALGORITHM_INCLUDED - -#include "../platform.h" - -#include "../private/choose_namespace.h" -#include "../private/choose_tag_types.h" -#include "../private/choose_pair_types.h" - -#if defined(ETL_NO_STL) - #include "alternate/algorithm.h" -#else - #include -#endif - -#endif diff --git a/include/etl/stl/alternate/algorithm.h b/include/etl/stl/alternate/algorithm.h deleted file mode 100644 index e9c880f5..00000000 --- a/include/etl/stl/alternate/algorithm.h +++ /dev/null @@ -1,870 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2018 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_ALTERNATE_ALGORITHM_INCLUDED -#define ETL_STL_ALTERNATE_ALGORITHM_INCLUDED - -#include "../../platform.h" -#include "../../type_traits.h" - -#include - -#include "etl/private/choose_tag_types.h" -#include "etl/private/choose_pair_types.h" - -// Local alternate definitions. -#include "iterator.h" -#include "functional.h" -#include "utility.h" - -namespace etlstd -{ - //*************************************************************************** - // swap - template - void swap(T& a, T& b) - { - T c = a; - a = b; - b = c; - } - - //*************************************************************************** - // iter_swap - template - void iter_swap(TIterator1 a, TIterator2 b) - { - typename etlstd::iterator_traits::value_type c = *a; - *a = *b; - *b = c; - } - - //*************************************************************************** - // swap_ranges - template - TIterator2 swap_ranges(T1terator1 first1, - T1terator1 last1, - TIterator2 first2) - { - while (first1 != last1) - { - iter_swap(first1++, first2++); - } - - return first2; - } - - //*************************************************************************** - // advance - template - typename etl::enable_if::iterator_tag, etlstd::random_access_iterator_tag>::value, void>::type - advance(TIterator itr, TDistance distance) - { - while (distance-- != 0) - { - ++itr; - } - } - - template - typename etl::enable_if::iterator_tag, etlstd::random_access_iterator_tag>::value, void>::type - advance(TIterator itr, TDistance distance) - { - return itr += distance; - } - - //*************************************************************************** - // copy - // Pointer - template - 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; - - difference_t count = (se - sb); - - return TIterator2(memmove(db, sb, sizeof(value_t) * count)) + count; - } - - // Other iterator - template - 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) - { - *db++ = *sb++; - } - - return db; - } - - //*************************************************************************** - // reverse_copy - template - TIterator2 reverse_copy(TIterator1 sb, TIterator1 se, TIterator2 db) - { - while (sb != se) - { - *(db++) = *(--se); - } - - return db; - } - - //*************************************************************************** - // copy_n - // Pointer - template - 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; - - return TIterator2(memmove(db, sb, sizeof(value_t) * count)) + count; - } - - // Other iterator - template - 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) - { - *db++ = *sb++; - --count; - } - - return db; - } - - //*************************************************************************** - // copy_backward - // Pointer - template - 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; - - const size_t length = (se - sb); - - return TIterator2(memmove(de - length, sb, sizeof(value_t) * length)); - } - - // Other iterator - template - 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) - { - *(--de) = *(--se); - } - - return de; - } - - //*************************************************************************** - // move - template - TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db) - { - while (sb != se) - { - *db++ = etlstd::move(*sb++); - } - - return db; - } - - //*************************************************************************** - // move_backward - template - TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de) - { - while (sb != se) - { - *(--de) = etlstd::move(*(--se)); - } - - return de; - } - - //*************************************************************************** - // reverse - // Pointers - template - typename etl::enable_if::value, void>::type - reverse(TIterator b, TIterator e) - { - if (b != e) - { - while (b < --e) - { - etlstd::iter_swap(b, e); - ++b; - } - } - } - - // Other - template - typename etl::enable_if::value, void>::type - reverse(TIterator b, TIterator e) - { - while ((b != e) && (b != --e)) - { - etlstd::iter_swap(b++, e); - } - } - - //*************************************************************************** - // lower_bound - template - TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) - { - typedef typename etlstd::iterator_traits::difference_type difference_t; - - difference_t count = etlstd::distance(first, last); - - while (count > 0) - { - TIterator itr = first; - difference_t step = count / 2; - - etlstd::advance(itr, step); - - if (compare(*itr, value)) - { - first = ++itr; - count -= step + 1; - } - else - { - count = step; - } - } - - return first; - } - - template - TIterator lower_bound(TIterator first, TIterator last, const TValue& value) - { - typedef etlstd::less::value_type> compare; - - return etlstd::lower_bound(first, last, value, compare()); - } - - //*************************************************************************** - // upper_bound - template - TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) - { - typedef typename etlstd::iterator_traits::difference_type difference_t; - - difference_t count = etlstd::distance(first, last); - - while (count > 0) - { - TIterator itr = first; - difference_t step = count / 2; - - etlstd::advance(itr, step); - - if (!compare(value, *itr)) - { - first = ++itr; - count -= step + 1; - } - else - { - count = step; - } - } - - return first; - } - - template - TIterator upper_bound(TIterator first, TIterator last, const TValue& value) - { - typedef etlstd::less::value_type> compare; - - return etlstd::upper_bound(first, last, value, compare()); - } - - //*************************************************************************** - // equal_range - template - ETL_PAIR equal_range(TIterator first, TIterator last, const TValue& value, TCompare compare) - { - return ETL_MAKE_PAIR(etlstd::lower_bound(first, last, value, compare), - etlstd::upper_bound(first, last, value, compare)); - } - - template - ETL_PAIR equal_range(TIterator first, TIterator last, const TValue& value) - { - typedef etlstd::less::value_type> compare; - - return ETL_MAKE_PAIR(etlstd::lower_bound(first, last, value, compare()), - etlstd::upper_bound(first, last, value, compare())); - } - - //*************************************************************************** - // find_if - template - TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate) - { - while (first != last) - { - if (predicate(*first)) - { - return first; - } - - ++first; - } - - return last; - } - - //*************************************************************************** - // find - template - TIterator find(TIterator first, TIterator last, const T& value) - { - while (first != last) - { - if (*first == value) - { - return first; - } - - ++first; - } - - return last; - } - - //*************************************************************************** - // fill - template - 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) - { - *first++ = value; - } - } - - template - 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); - } - - //*************************************************************************** - // fill_n - template - 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) - { - *first++ = value; - } - - return first; - } - - template - 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); - } - - //*************************************************************************** - // count - template - typename iterator_traits::difference_type count(TIterator first, TIterator last, const T& value) - { - typename iterator_traits::difference_type n = 0; - - while (first != last) - { - if (*first == value) - { - ++n; - } - - ++first; - } - - return n; - } - - //*************************************************************************** - // count - template - typename iterator_traits::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate) - { - typename iterator_traits::difference_type n = 0; - - while (first != last) - { - if (predicate(*first)) - { - ++n; - } - - ++first; - } - - return n; - } - - //*************************************************************************** - // equal - template - 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) - { - if (*first1++ != *first2++) - { - return false; - } - } - - return true; - } - - template - 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; - - return (memcmp(first1, first2, sizeof(value_t) * (last1 - first1)) == 0); - } - - //*************************************************************************** - // lexicographical_compare - template - bool lexicographical_compare(TIterator1 first1, TIterator1 last1, - TIterator2 first2, TIterator2 last2, - TCompare compare) - { - while ((first1 != last1) && (first2 != last2)) - { - if (compare(*first1, *first2)) - { - return true; - } - - if (compare(*first2, *first1)) - { - return false; - } - - ++first1; - ++first2; - } - - return (first1 == last1) && (first2 != last2); - } - - //*************************************************************************** - // lexicographical_compare - template - bool lexicographical_compare(TIterator1 first1, TIterator1 last1, - TIterator2 first2, TIterator2 last2) - { - typedef etlstd::less::value_type> compare; - - return etlstd::lexicographical_compare(first1, last1, first2, last2, compare()); - } - - //*************************************************************************** - // min - template - const T& min(const T& a, const T& b, TCompare compare) - { - return (compare(a, b)) ? a : b; - } - - template - const T& min(const T& a, const T& b) - { - typedef etlstd::less compare; - - return etlstd::min(a, b, compare()); - } - - //*************************************************************************** - // max - template - const T& max(const T& a, const T& b, TCompare compare) - { - return (compare(a, b)) ? b : a; - } - - template - const T& max(const T& a, const T& b) - { - typedef etlstd::less compare; - - return etlstd::max(a, b, compare()); - } - - //*************************************************************************** - // transform - template - TIteratorOut transform(TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation) - { - while (first1 != last1) - { - *d_first++ = unary_operation(*first1++); - } - - return d_first; - } - - template - TIteratorOut transform(TIteratorIn1 first1, TIteratorIn1 last1, TIteratorIn2 first2, TIteratorOut d_first, TBinaryOperation binary_operation) - { - while (first1 != last1) - { - *d_first++ = binary_operation(*first1++, *first2++); - } - - return d_first; - } - - //*************************************************************************** - // Heap - namespace private_heap - { - // Push Heap Helper - template - void push_heap(TIterator first, TDistance value_index, TDistance top_index, TValue value, TCompare compare) - { - TDistance parent = (value_index - 1) / 2; - - while ((value_index > top_index) && compare(first[parent], value)) - { - first[value_index] = first[parent]; - value_index = parent; - parent = (value_index - 1) / 2; - } - - first[value_index] = value; - } - - // Adjust Heap Helper - template - void adjust_heap(TIterator first, TDistance value_index, TDistance length, TValue value, TCompare compare) - { - TDistance top_index = value_index; - TDistance child2nd = (2 * value_index) + 2; - - while (child2nd < length) - { - if (compare(first[child2nd], first[child2nd - 1])) - { - child2nd--; - } - - first[value_index] = first[child2nd]; - value_index = child2nd; - child2nd = 2 * (child2nd + 1); - } - - if (child2nd == length) - { - first[value_index] = first[child2nd - 1]; - value_index = child2nd - 1; - } - - push_heap(first, value_index, top_index, value, compare); - } - - // Is Heap Helper - template - bool is_heap(const TIterator first, const TDistance n, TCompare compare) - { - TDistance parent = 0; - - for (TDistance child = 1; child < n; ++child) - { - if (compare(first[parent], first[child])) - { - return false; - } - - if ((child & 1) == 0) - { - ++parent; - } - } - - return true; - } - } - - // Pop Heap - 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; - - value_t value = last[-1]; - last[-1] = first[0]; - - private_heap::adjust_heap(first, distance_t(0), distance_t(last - first - 1), value, compare); - } - - // Pop Heap - template - void pop_heap(TIterator first, TIterator last) - { - typedef etlstd::less::value_type> compare; - - etlstd::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; - - private_heap::push_heap(first, difference_t(last - first - 1), difference_t(0), value_t(*(last - 1)), compare); - } - - // Push Heap - template - void push_heap(TIterator first, TIterator last) - { - typedef etlstd::less::value_type> compare; - - etlstd::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; - - if ((last - first) < 2) - { - return; - } - - difference_t length = last - first; - difference_t parent = (length - 2) / 2; - - while (true) - { - private_heap::adjust_heap(first, parent, length, *(first + parent), compare); - - if (parent == 0) - { - return; - } - - --parent; - } - } - - // Make Heap - template - void make_heap(TIterator first, TIterator last) - { - typedef etlstd::less::value_type> compare; - - etlstd::make_heap(first, last, compare()); - } - - // Is Heap - template - bool is_heap(TIterator first, TIterator last) - { - typedef etlstd::less::value_type> compare; - - return private_heap::is_heap(first, last - first, compare()); - } - - // Is Heap - template - bool is_heap(TIterator first, TIterator last, TCompare compare) - { - return private_heap::is_heap(first, last - first, compare); - } - - //*************************************************************************** - // Search - template - TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare) - { - while (true) - { - TIterator1 itr = first; - TIterator2 search_itr = search_first; - - while (true) - { - if (search_itr == search_last) - { - return first; - } - - if (itr == last) - { - return last; - } - - if (!compare(*itr, *search_itr)) - { - break; - } - - ++itr; - ++search_itr; - } - - ++first; - } - } - - // Search - template - TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last) - { - typedef etlstd::equal_to::value_type> compare; - - return etlstd::search(first, last, search_first, search_last, compare()); - } - - //*************************************************************************** - // Rotate - template - TIterator rotate(TIterator first, TIterator middle, TIterator last) - { - TIterator next = middle; - - while (first != next) - { - etlstd::swap(*first++, *next++); - - if (next == last) - { - next = middle; - } - else if (first == middle) - { - middle = next; - } - } - - return first; - } - - //*************************************************************************** - // find_end - // Predicate - template - TIterator1 find_end(TIterator1 b, TIterator1 e, - TIterator2 sb, TIterator2 se, - TPredicate predicate) - { - if (sb == se) - { - return e; - } - - TIterator1 result = e; - - while (true) - { - TIterator1 new_result = etlstd::search(b, e, sb, se, predicate); - - if (new_result == e) - { - break; - } - else - { - result = new_result; - b = result; - ++b; - } - } - return result; - } - - // Default - template - TIterator1 find_end(TIterator1 b, TIterator1 e, - TIterator2 sb, TIterator2 se) - { - typedef etlstd::equal_to::value_type> predicate; - - return find_end(b, e, sb, se, predicate()); - } -} - -#endif - - diff --git a/include/etl/stl/alternate/functional.h b/include/etl/stl/alternate/functional.h deleted file mode 100644 index 7ff28b5f..00000000 --- a/include/etl/stl/alternate/functional.h +++ /dev/null @@ -1,137 +0,0 @@ - -#ifndef ETL_STL_ALTERNATE_FUNCTIONAL_INCLUDED -#define ETL_STL_ALTERNATE_FUNCTIONAL_INCLUDED - -#include "../../platform.h" - -#include "../../private/choose_tag_types.h" -#include "../../private/choose_pair_types.h" - -namespace etlstd -{ - //*************************************************************************** - template - struct less - { - ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const - { - return lhs < rhs; - } - }; - - //*************************************************************************** - template - struct greater - { - ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const - { - return lhs > rhs; - } - }; - - //*************************************************************************** - template - struct equal_to - { - ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const - { - return lhs == rhs; - } - }; - - //*************************************************************************** - template - struct not_equal_to - { - ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const - { - return lhs != rhs; - } - }; - - //*************************************************************************** - - template - struct unary_function - { - typedef TArgumentType argument_type; - typedef TResultType result_type; - }; - - //*************************************************************************** - - template - struct binary_function - { - typedef TFirstArgumentType first_argument_type; - typedef TSecondArgumentType second_argument_type; - typedef TResultType result_type; - }; - - //*************************************************************************** - - template - class binder1st : public etlstd::unary_function - { - protected: - - TFunction operation; - typename TFunction::first_argument_type value; - - public: - - binder1st(const TFunction& f, const typename TFunction::first_argument_type& v) - : operation (f), value(v) - { - } - - typename TFunction::result_type operator()(typename TFunction::second_argument_type& x) const - { - return operation(value, x); - } - - typename TFunction::result_type operator()(const typename TFunction::second_argument_type& x) const - { - return operation(value, x); - } - }; - - template - binder1st bind1st(const F& f, const T& x) - { - return binder1st(f, x); - } - - //*************************************************************************** - - template - class binder2nd : public etlstd::unary_function - { - protected: - TFunction operation; - typename TFunction::second_argument_type value; - public: - binder2nd(const TFunction& f, const typename TFunction::second_argument_type& v) - : operation (f), value(v) - { - } - - typename TFunction::result_type operator()(typename TFunction::first_argument_type& x) const - { - return operation(x, value); - } - - typename TFunction::result_type operator()(const typename TFunction::first_argument_type& x) const - { - return operation(x, value); - } - }; - - template - binder2nd bind2nd(const F& f, const T& x) - { - return binder2nd(f, x); - } -} - -#endif diff --git a/include/etl/stl/alternate/iterator.h b/include/etl/stl/alternate/iterator.h deleted file mode 100644 index 0e7583c3..00000000 --- a/include/etl/stl/alternate/iterator.h +++ /dev/null @@ -1,394 +0,0 @@ - -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2018 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_ALTERNATE_ITERATOR_INCLUDED -#define ETL_STL_ALTERNATE_ITERATOR_INCLUDED - -#include "../../platform.h" -#include "../../type_traits.h" - -#include - -#include "../../private/choose_tag_types.h" -#include "../../private/choose_pair_types.h" - -namespace etlstd -{ - //*************************************************************************** - // iterator tags - struct input_iterator_tag {}; - struct output_iterator_tag {}; - struct forward_iterator_tag : public input_iterator_tag {}; - struct bidirectional_iterator_tag : public forward_iterator_tag {}; - struct random_access_iterator_tag : public bidirectional_iterator_tag {}; - - //*************************************************************************** - // iterator_traits - template - struct iterator_traits - { - typedef typename TIterator::iterator_category iterator_category; - typedef typename TIterator::value_type value_type; - typedef typename TIterator::difference_type difference_type; - typedef typename TIterator::pointer pointer; - typedef typename TIterator::reference reference; - }; - - template - struct iterator_traits - { - typedef ETL_RANDOM_ACCESS_ITERATOR_TAG iterator_category; - typedef T value_type; - typedef ptrdiff_t difference_type; - typedef T* pointer; - typedef T& reference; - }; - - template - struct iterator_traits - { - typedef ETL_RANDOM_ACCESS_ITERATOR_TAG iterator_category; - typedef T value_type; - typedef ptrdiff_t difference_type; - typedef const T* pointer; - typedef const T& reference; - }; - - //*************************************************************************** - // advance - template - ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_INPUT_ITERATOR_TAG) - { - while (n--) - { - ++itr; - } - } - - template - ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OUTPUT_ITERATOR_TAG) - { - while (n--) - { - ++itr; - } - } - - template - ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_FORWARD_ITERATOR_TAG) - { - while (n--) - { - ++itr; - } - } - - template - ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_BIDIRECTIONAL_ITERATOR_TAG) - { - if (n > 0) - { - while (n--) - { - ++itr; - } - } - else - { - while (n++) - { - --itr; - } - } - } - - template - ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_RANDOM_ACCESS_ITERATOR_TAG) - { - itr += n; - } - - template - ETL_CONSTEXPR17 void advance(TIterator& itr, TDistance n) - { - typedef typename etlstd::iterator_traits::iterator_category tag; - - advance_helper(itr, n, tag()); - } - - //*************************************************************************** - // distance - template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_INPUT_ITERATOR_TAG) - { - typename etlstd::iterator_traits::difference_type d = 0; - - while (first != last) - { - ++d; - ++first; - } - - return d; - } - - template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_FORWARD_ITERATOR_TAG) - { - typename etlstd::iterator_traits::difference_type d = 0; - - while (first != last) - { - ++d; - ++first; - } - - return d; - } - - template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_BIDIRECTIONAL_ITERATOR_TAG) - { - typename etlstd::iterator_traits::difference_type d = 0; - - while (first != last) - { - ++d; - ++first; - } - - return d; - } - - template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_RANDOM_ACCESS_ITERATOR_TAG) - { - return last - first; - } - - template - ETL_CONSTEXPR17 typename etlstd::iterator_traits::difference_type distance(TIterator first, TIterator last) - { - typedef typename etlstd::iterator_traits::iterator_category tag; - - return distance_helper(first, last, tag()); - } - - //*************************************************************************** - // reverse_iterator - template - class reverse_iterator - { - public: - - typedef typename iterator_traits::iterator_category iterator_category; - typedef typename iterator_traits::value_type value_type; - typedef typename iterator_traits::difference_type difference_type; - typedef typename iterator_traits::pointer pointer; - typedef typename iterator_traits::reference reference; - - typedef TIterator iterator_type; - - ETL_CONSTEXPR17 reverse_iterator() - : current() - { - } - - ETL_CONSTEXPR17 explicit reverse_iterator(TIterator itr) - : current(itr) - { - } - - template - ETL_CONSTEXPR17 reverse_iterator(const reverse_iterator& other) - : current(other.base()) - { - } - - template - ETL_CONSTEXPR17 reverse_iterator& operator=(const reverse_iterator& other) - { - current = other.base(); - - return (*this); - } - - ETL_CONSTEXPR17 TIterator base() const - { - return current; - } - - ETL_NODISCARD ETL_CONSTEXPR17 reference operator*() const - { - TIterator temp = current; - - return *(--temp); - } - - ETL_NODISCARD ETL_CONSTEXPR17 pointer operator->() const - { - TIterator temp = current; - - return &(*--temp); - } - - ETL_CONSTEXPR17 reverse_iterator& operator++() - { - --current; - - return *this; - } - - ETL_CONSTEXPR17 reverse_iterator operator++(int) - { - reverse_iterator temp = *this; - --current; - - return temp; - } - - ETL_CONSTEXPR17 reverse_iterator& operator--() - { - ++current; - - return (*this); - } - - ETL_CONSTEXPR17 reverse_iterator operator--(int) - { - reverse_iterator temp = *this; - ++current; - - return temp; - } - - ETL_CONSTEXPR17 reverse_iterator& operator+=(const difference_type offset) - { - current -= offset; - - return (*this); - } - - ETL_CONSTEXPR17 reverse_iterator& operator-=(const difference_type offset) - { - current += offset; - - return (*this); - } - - ETL_NODISCARD ETL_CONSTEXPR17 reverse_iterator operator+(const difference_type offset) const - { - return reverse_iterator(current - offset); - } - - ETL_NODISCARD ETL_CONSTEXPR17 reverse_iterator operator-(const difference_type offset) const - { - return (reverse_iterator(current + offset)); - } - - ETL_NODISCARD ETL_CONSTEXPR17 reference operator[](const difference_type offset) const - { - return (*(*this + offset)); - } - - protected: - - TIterator current; - }; - - template - inline ETL_CONSTEXPR17 bool operator ==(const reverse_iterator& lhs, const reverse_iterator& rhs) - { - return lhs.base() == rhs.base(); - } - - template - inline ETL_CONSTEXPR17 bool operator !=(const reverse_iterator& lhs, const reverse_iterator& rhs) - { - return !(lhs == rhs); - } - - template - inline ETL_CONSTEXPR17 bool operator <(const reverse_iterator& lhs, const reverse_iterator& rhs) - { - return rhs.base() < lhs.base(); - } - - template - inline ETL_CONSTEXPR17 bool operator >(const reverse_iterator& lhs, const reverse_iterator& rhs) - { - return rhs < lhs; - } - - template - inline ETL_CONSTEXPR17 bool operator <=(const reverse_iterator& lhs, const reverse_iterator& rhs) - { - return !(rhs < lhs); - } - - template - inline ETL_CONSTEXPR17 bool operator >=(const reverse_iterator& lhs, const reverse_iterator& rhs) - { - return !(lhs < rhs); - } - - template - inline ETL_CONSTEXPR17 typename reverse_iterator::difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs) - { - return rhs.base() - lhs.base(); - } - - template - inline ETL_CONSTEXPR17 reverse_iterator operator +(TDifference n, const reverse_iterator& itr) - { - return itr.operator +(n); - } - - //*************************************************************************** - // Previous - template - ETL_CONSTEXPR17 TIterator prev(TIterator itr, typename etlstd::iterator_traits::difference_type n = 1) - { - etlstd::advance(itr, -n); - return itr; - } - - //*************************************************************************** - // Next - template - ETL_CONSTEXPR17 TIterator next(TIterator itr, typename etlstd::iterator_traits::difference_type n = 1) - { - etlstd::advance(itr, n); - return itr; - } -} - -#endif diff --git a/include/etl/stl/alternate/utility.h b/include/etl/stl/alternate/utility.h deleted file mode 100644 index ac0bfc00..00000000 --- a/include/etl/stl/alternate/utility.h +++ /dev/null @@ -1,163 +0,0 @@ - ///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2018 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_ALTERNATE_UTILITY_INCLUDED -#define ETL_STL_ALTERNATE_UTILITY_INCLUDED - -#include "../../platform.h" -#include "../../type_traits.h" - -#include "../../private/choose_tag_types.h" -#include "../../private/choose_pair_types.h" - -namespace etlstd -{ - //****************************************************************************** - template - struct pair - { - typedef T1 first_type; - typedef T2 second_type; - - T1 first; - T2 second; - - pair() - : first(T1()), - second(T2()) - { - } - - pair(const T1& a, const T2& b) - : first(a), - second(b) - { - } - - template - pair(const pair& other) - : first(other.first), - second(other.second) - { - } - - pair(const pair& other) - : first(other.first), - second(other.second) - { - } - - void swap(pair& other) - { - T1 temp1 = first; - T2 temp2 = second; - first = other.first; - second = other.second; - other.first = temp1; - other.second = temp2; - } - }; - - //****************************************************************************** - template - inline pair make_pair(T1 a, T2 b) - { - return pair(a, b); - } - - //****************************************************************************** - template - inline void swap(pair& a, pair& b) - { - a.swap(b); - } - - //****************************************************************************** - template - inline bool operator ==(const pair& a, const pair& b) - { - return (a.first == b.first) && (a.second == b.second); - } - - template - inline bool operator !=(const pair& a, const pair& b) - { - return !(a == b); - } - - template - inline bool operator <(const pair& a, const pair& b) - { - return (a.first < b.first) || - (!(b.first < a.first) && (a.second < b.second)); - } - - template - inline bool operator >(const pair& a, const pair& b) - { - return (b < a); - } - - template - inline bool operator <=(const pair& a, const pair& b) - { - return !(b < a); - } - - template - inline bool operator >=(const pair& a, const pair& b) - { - return !(a < b); - } - -#if ETL_CPP11_SUPPORTED - //****************************************************************************** - template - constexpr typename etl::remove_reference::type&& move(T&& t) noexcept - { - return static_cast::type&&>(t); - } - - //****************************************************************************** - template - constexpr T&& forward(typename etl::remove_reference::type& t) noexcept - { - return static_cast(t); - } - - template - constexpr T&& forward(typename etl::remove_reference::type&& t) noexcept - { - return static_cast(t); - } -#endif -} - -#endif diff --git a/include/etl/stl/functional.h b/include/etl/stl/functional.h deleted file mode 100644 index 89052b39..00000000 --- a/include/etl/stl/functional.h +++ /dev/null @@ -1,17 +0,0 @@ - -#ifndef ETL_STL_FUNCTIONAL_INCLUDED -#define ETL_STL_FUNCTIONAL_INCLUDED - -#include "../platform.h" - -#include "../private/choose_namespace.h" -#include "../private/choose_tag_types.h" -#include "../private/choose_pair_types.h" - -#if defined(ETL_NO_STL) - #include "alternate/functional.h" -#else - #include -#endif - -#endif diff --git a/include/etl/stl/iterator.h b/include/etl/stl/iterator.h deleted file mode 100644 index 60e157ec..00000000 --- a/include/etl/stl/iterator.h +++ /dev/null @@ -1,47 +0,0 @@ - -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2018 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_ITERATOR_INCLUDED -#define ETL_STL_ITERATOR_INCLUDED - -#include "../platform.h" - -#include "../private/choose_namespace.h" -#include "../private/choose_tag_types.h" -#include "../private/choose_pair_types.h" - -#if defined(ETL_NO_STL) - #include "alternate/iterator.h" -#else - #include -#endif - -#endif diff --git a/include/etl/stl/limits.h b/include/etl/stl/limits.h deleted file mode 100644 index 477f5244..00000000 --- a/include/etl/stl/limits.h +++ /dev/null @@ -1,46 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2018 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_LIMITS_INCLUDED -#define ETL_STL_LIMITS_INCLUDED - -#include "../platform.h" - -#include "../private/choose_namespace.h" -#include "../private/choose_tag_types.h" -#include "../private/choose_pair_types.h" - -#if defined(ETL_NO_STL) - #include "alternate/limits.h" -#else - #include -#endif - -#endif diff --git a/include/etl/stl/utility.h b/include/etl/stl/utility.h deleted file mode 100644 index eb8e99b8..00000000 --- a/include/etl/stl/utility.h +++ /dev/null @@ -1,46 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2018 jwellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#ifndef ETL_STL_UTILITY_INCLUDED -#define ETL_STL_UTILITY_INCLUDED - -#include "../platform.h" - -#include "../private/choose_namespace.h" -#include "../private/choose_tag_types.h" -#include "../private/choose_pair_types.h" - -#if defined(ETL_NO_STL) - #include "alternate/utility.h" -#else - #include -#endif - -#endif diff --git a/include/etl/string_view.h b/include/etl/string_view.h index 8bc8bc60..40acb1b6 100644 --- a/include/etl/string_view.h +++ b/include/etl/string_view.h @@ -109,7 +109,7 @@ namespace etl typedef const T& const_reference; typedef const T* const_pointer; typedef const T* const_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; enum { @@ -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> - void assign(TIterator begin_, TIterator end_) + typename TDummy = typename etlstd::enable_if::value, void>::type> + void assign(TIterator begin_, TIterator end_) { mbegin = etl::addressof(*begin_); - mend = etl::addressof(*begin_) + ETL_STD::distance(begin_, end_); + mend = etl::addressof(*begin_) + etlstd::distance(begin_, end_); } //************************************************************************* @@ -321,8 +321,8 @@ namespace etl //************************************************************************* template ::value, void>::type> - void assign(TIterator begin_, TSize size_) + typename TDummy = typename etlstd::enable_if::value, void>::type> + void assign(TIterator begin_, TSize size_) { mbegin = etl::addressof(*begin_); mend = etl::addressof(*begin_) + size_; @@ -351,8 +351,14 @@ namespace etl //************************************************************************* void swap(basic_string_view& other) { - ETL_STD::swap(mbegin, other.mbegin); - ETL_STD::swap(mend, other.mend); +#if defined(ETL_NO_STL) + using etlstd::swap; +#else + using std::swap; +#endif + + swap(mbegin, other.mbegin); + swap(mend, other.mend); } //************************************************************************* @@ -364,9 +370,9 @@ namespace etl if (position < size()) { - n = ETL_STD::min(count, size() - position); + n = etlstd::min(count, size() - position); - ETL_STD::copy(mbegin + position, mbegin + position + n, destination); + etlstd::copy(mbegin + position, mbegin + position + n, destination); } return n; @@ -381,7 +387,7 @@ namespace etl if (position < size()) { - size_t n = ETL_STD::min(count, size() - position); + size_t n = etlstd::min(count, size() - position); view = basic_string_view(mbegin + position, mbegin + position + n); } @@ -495,7 +501,7 @@ namespace etl return npos; } - const_iterator iposition = ETL_STD::search(begin() + position, end(), view.begin(), view.end()); + const_iterator iposition = etlstd::search(begin() + position, end(), view.begin(), view.end()); if (iposition == end()) { @@ -503,7 +509,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etlstd::distance(begin(), iposition); } } @@ -532,9 +538,9 @@ namespace etl return npos; } - position = ETL_STD::min(position, size()); + position = etlstd::min(position, size()); - const_iterator iposition = ETL_STD::find_end(begin(), + const_iterator iposition = etlstd::find_end(begin(), begin() + position, view.begin(), view.end()); @@ -545,7 +551,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etlstd::distance(begin(), iposition); } } @@ -615,7 +621,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etlstd::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -711,7 +717,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etlstd::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -762,7 +768,7 @@ namespace etl friend bool operator == (const etl::basic_string_view& lhs, const etl::basic_string_view& rhs) { return (lhs.size() == rhs.size()) && - ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + etlstd::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -778,7 +784,7 @@ namespace etl //************************************************************************* friend bool operator < (const etl::basic_string_view& lhs, const etl::basic_string_view& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etlstd::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 c95bfe41..4a583a24 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 etl::conditional>::type>::type>::type>::type> + typename etlstd::conditional >::type>::type>::type>::type> ::type>::type>::type>::type> ::type>::type>::type>::type> ::type>::type>::type>::type type; - ETL_STATIC_ASSERT(!(etl::is_same, type>::value), "Invalid id"); + ETL_STATIC_ASSERT(!(etlstd::is_same, type>::value), "Invalid id"); }; //************************************ @@ -137,22 +137,22 @@ namespace etl enum { value = - (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) 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) UNKNOWN }; @@ -202,26 +202,26 @@ namespace etl struct type_from_type { typedef - 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> + 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, + etl::null_type<0> >::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type>::type>::type>::type>::type>::type type; - ETL_STATIC_ASSERT(!(etl::is_same, type>::value), "Invalid type"); + ETL_STATIC_ASSERT(!(etlstd::is_same, type>::value), "Invalid type"); }; }; } diff --git a/include/etl/type_lookup_generator.h b/include/etl/type_lookup_generator.h index 1e5a785f..8a814ca5 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 etl::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(!(etl::is_same, type>::value), \"Invalid id\");") + cog.outl(" ETL_STATIC_ASSERT(!(etlstd::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) etl::is_same::value ? T%s::ID :" % (n, n)) + cog.outl(" (unsigned int) etlstd::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 etl::conditional::value, typename T%s::type2," %(n, n)) + cog.outl(" typename etlstd::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(!(etl::is_same, type>::value), \"Invalid type\");") + cog.outl(" ETL_STATIC_ASSERT(!(etlstd::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 894b642d..94b70004 100644 --- a/include/etl/type_select.h +++ b/include/etl/type_select.h @@ -73,22 +73,22 @@ namespace etl template struct select { - typedef typename etl::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 etl::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 etl::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 etl::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 etl::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 etl::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type>::type type; @@ -331,16 +331,16 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type>::type type; @@ -367,15 +367,15 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type>::type>::type>::type>::type>::type> ::type type; @@ -401,14 +401,14 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type>::type>::type>::type>::type>::type type; @@ -432,13 +432,13 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type>::type>::type>::type>::type type; @@ -461,12 +461,12 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type>::type>::type>::type type; @@ -488,11 +488,11 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type>::type>::type type; @@ -513,10 +513,10 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type>::type type; @@ -536,9 +536,9 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type>::type type; @@ -557,8 +557,8 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type>::type type; @@ -576,7 +576,7 @@ namespace etl template struct select { - typedef typename etl::conditional > ::type type; diff --git a/include/etl/type_select_generator.h b/include/etl/type_select_generator.h index 70880f9c..7b3f1fc2 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 etl::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 etl::conditional >") cog.out(" ") for n in range(1, s) : diff --git a/include/etl/type_traits.h b/include/etl/type_traits.h index ebd296b8..d4dac3c6 100644 --- a/include/etl/type_traits.h +++ b/include/etl/type_traits.h @@ -60,18 +60,20 @@ SOFTWARE. #include "nullptr.h" #include "static_assert.h" -#if (ETL_CPP11_SUPPORTED) && !defined(ETL_NO_STL) - #include -#endif - ///\defgroup type_traits type_traits -/// A set of type traits definitions for compilers that do not support the standard header. +/// A set of type traits definitions. +/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined. /// \ingroup utilities -namespace etl +#if defined(ETL_NO_STL) + +//***************************************************************************** +// Traits are defined by the ETL +//***************************************************************************** +namespace etlstd { + //*************************************************************************** /// integral_constant - ///\ingroup type_traits template struct integral_constant { @@ -82,27 +84,31 @@ namespace etl operator value_type() const { - return value; + return value; } }; /// integral_constant specialisations - ///\ingroup type_traits typedef integral_constant false_type; typedef integral_constant true_type; +#if ETL_CPP17_SUPPORTED + template + using bool_constant = integral_constant; +#endif + + //*************************************************************************** /// remove_reference - ///\ingroup type_traits template struct remove_reference { typedef T type; }; template struct remove_reference { typedef T type; }; - /// add_reference - ///\ingroup type_traits - template struct add_reference { typedef T& type; }; - template struct add_reference { typedef T& type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_reference_t = typename remove_reference::type; +#endif + //*************************************************************************** /// remove_pointer - ///\ingroup type_traits template struct remove_pointer { typedef T type; }; template struct remove_pointer { typedef T type; }; template struct remove_pointer { typedef const T type; }; @@ -113,58 +119,108 @@ namespace etl template struct remove_pointer { typedef volatile T type; }; template struct remove_pointer { typedef const volatile T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_pointer_t = typename remove_pointer::type; +#endif + + //*************************************************************************** /// add_pointer - ///\ingroup type_traits template struct add_pointer { typedef typename remove_reference::type* type; }; +#if ETL_CPP14_SUPPORTED + template + using add_pointer_t = typename add_pointer::type; +#endif + + //*************************************************************************** /// is_const - ///\ingroup type_traits template struct is_const : false_type {}; template struct is_const : true_type {}; template struct is_const : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_const_v = is_const::value; +#endif + + //*************************************************************************** /// remove_const - ///\ingroup type_traits template struct remove_const { typedef T type; }; template struct remove_const { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_const_t = typename remove_const::type; +#endif + + //*************************************************************************** /// add_const - ///\ingroup type_traits template struct add_const { typedef const T type; }; template struct add_const { typedef const T type; }; +#if ETL_CPP14_SUPPORTED + template + using add_const_t = typename add_const::type; +#endif + + //*************************************************************************** /// is_volatile - ///\ingroup type_traits template struct is_volatile : false_type {}; template struct is_volatile : true_type {}; template struct is_volatile : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_volatile_v = is_volatile::value; +#endif + + //*************************************************************************** /// remove_volatile - ///\ingroup type_traits template struct remove_volatile { typedef T type; }; template struct remove_volatile { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_volatile_t = typename remove_volatile::type; +#endif + + //*************************************************************************** /// add_volatile - ///\ingroup type_traits template struct add_volatile { typedef volatile T type; }; template struct add_volatile { typedef volatile T type; }; +#if ETL_CPP14_SUPPORTED + template + using add_volatile_t = typename add_volatile::type; +#endif + + //*************************************************************************** /// remove_cv - ///\ingroup type_traits template struct remove_cv { typedef typename remove_volatile::type>::type type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_cv_t = typename remove_cv::type; +#endif + + //*************************************************************************** /// add_cv - ///\ingroup type_traits template struct add_cv { typedef typename add_volatile::type>::type type; }; +#if ETL_CPP14_SUPPORTED + template + using add_cv_t = typename add_cv::type; +#endif + + //*************************************************************************** /// is_integral - ///\ingroup type_traits template struct is_integral : false_type {}; template <> struct is_integral : true_type {}; template <> struct is_integral : true_type {}; @@ -183,30 +239,40 @@ namespace etl template struct is_integral : is_integral {}; template struct is_integral : is_integral {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_integral_v = is_integral::value; +#endif + + //*************************************************************************** /// is_signed - ///\ingroup type_traits template struct is_signed : false_type {}; template <> struct is_signed : integral_constant {}; - template <> struct is_signed : public etl::integral_constant(wchar_t(-1) < wchar_t(0))> {}; + template <> struct is_signed : public etlstd::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 {}; template <> struct is_signed : true_type {}; template <> struct is_signed : true_type {}; - template <> struct is_signed : true_type{}; - template <> struct is_signed : true_type{}; - template <> struct is_signed : true_type{}; + template <> struct is_signed : true_type {}; + template <> struct is_signed : true_type {}; + template <> struct is_signed : true_type {}; template struct is_signed : is_signed {}; template struct is_signed : is_signed {}; template struct is_signed : is_signed {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_signed_v = is_signed::value; +#endif + + //*************************************************************************** /// is_unsigned - ///\ingroup type_traits template struct is_unsigned : false_type {}; template <> struct is_unsigned : true_type {}; template <> struct is_unsigned : integral_constant 0)> {}; template <> struct is_unsigned : true_type {}; - template <> struct is_unsigned : public etl::integral_constant wchar_t(0))> {}; + template <> struct is_unsigned : public etlstd::integral_constant wchar_t(0))> {}; template <> struct is_unsigned : true_type {}; template <> struct is_unsigned : true_type {}; template <> struct is_unsigned : true_type {}; @@ -215,8 +281,13 @@ namespace etl template struct is_unsigned : is_unsigned {}; template struct is_unsigned : is_unsigned {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_unsigned_v = is_unsigned::value; +#endif + + //*************************************************************************** /// is_floating_point - ///\ingroup type_traits template struct is_floating_point : false_type {}; template <> struct is_floating_point : true_type {}; template <> struct is_floating_point : true_type {}; @@ -225,149 +296,193 @@ namespace etl template struct is_floating_point : is_floating_point {}; template struct is_floating_point : is_floating_point {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_floating_point_v = is_floating_point::value; +#endif + + //*************************************************************************** /// is_same - ///\ingroup type_traits template struct is_same : public false_type {}; template struct is_same : public true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_same_v = is_same::value; +#endif + + //*************************************************************************** /// is_void - ///\ingroup type_traits template struct is_void : false_type {}; template<> struct is_void : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_void_v = is_void::value; +#endif + + //*************************************************************************** /// is_arithmetic - ///\ingroup type_traits template struct is_arithmetic : integral_constant::value || is_floating_point::value> {}; - /// is_fundamental - ///\ingroup type_traits - template struct is_fundamental : integral_constant::value || - is_void::value || - is_same::type>::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_arithmetic_v = is_arithmetic::value; +#endif + //*************************************************************************** + /// is_fundamental + template struct is_fundamental : integral_constant::value || + is_void::value || + is_same::type>::value> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_fundamental_v = is_fundamental::value; +#endif + + //*************************************************************************** /// is_compound - ///\ingroup type_traits template struct is_compound : integral_constant::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_compound_v = is_compound::value; +#endif + + //*************************************************************************** /// is_array - ///\ingroup type_traits template struct is_array : false_type {}; template struct is_array : true_type {}; template struct is_array : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_array_v = is_array::value; +#endif + + //*************************************************************************** /// is_pointer - ///\ingroup type_traits template struct is_pointer_helper : false_type {}; template struct is_pointer_helper : true_type {}; template struct is_pointer : is_pointer_helper::type> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pointer_v = is_pointer::value; +#endif + + //*************************************************************************** /// is_reference - ///\ingroup type_traits template struct is_reference_helper : false_type {}; template struct is_reference_helper : true_type {}; template struct is_reference : is_reference_helper::type> {}; - /// is_pod - /// For C++03, only fundamental and pointers types are recognised. - ///\ingroup type_traits -#if (ETL_CPP11_SUPPORTED && !defined(ARDUINO) && !defined(ETL_STLPORT)) && !defined(IN_TYPE_TRAITS_TEST) && !defined(ETL_NO_STL) - // For compilers that support C++11 - template struct is_pod : std::is_pod {}; -#else - template struct is_pod : etl::integral_constant::value || etl::is_pointer::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_reference_v = is_reference::value; #endif -#if (ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED) && !defined(ETL_STLPORT) && !defined(IN_TYPE_TRAITS_TEST) && !defined(ETL_NO_STL) - /// is_trivially_constructible - ///\ingroup type_traits - template struct is_trivially_constructible : std::is_trivially_constructible {}; + //*************************************************************************** + /// is_lvalue_reference + template struct is_lvalue_reference_helper : false_type {}; + template struct is_lvalue_reference_helper : true_type {}; + template struct is_lvalue_reference : is_lvalue_reference_helper::type> {}; - /// is_trivially_copy_constructible - ///\ingroup type_traits - template struct is_trivially_copy_constructible : std::is_trivially_copy_constructible {}; - - /// is_trivially_destructible - ///\ingroup type_traits - template struct is_trivially_destructible : std::is_trivially_destructible {}; - - /// is_trivially_copy_assignable - ///\ingroup type_traits - template struct is_trivially_copy_assignable : std::is_trivially_copy_assignable {}; - - /// is_trivially_copyable - ///\ingroup type_traits - template struct is_trivially_copyable : std::is_trivially_copyable {}; -#else - /// is_trivially_constructible - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_constructible : etl::is_pod {}; - - /// is_trivially_copy_constructible - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copy_constructible : etl::is_pod {}; - - /// is_trivially_destructible - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_destructible : etl::is_pod {}; - - /// is_trivially_copy_assignable - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copy_assignable : etl::is_pod {}; - - /// is_trivially_copyable - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copyable : etl::is_pod {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_lvalue_reference_v = etlstd::is_lvalue_reference::value; #endif -#if ETL_CPP11_SUPPORTED + //*************************************************************************** /// is_rvalue_reference - ///\ingroup type_traits - template struct is_rvalue_reference : etl::false_type {}; - template struct is_rvalue_reference : etl::true_type {}; + template struct is_rvalue_reference_helper : false_type {}; + template struct is_rvalue_reference_helper : true_type {}; + template struct is_rvalue_reference : is_rvalue_reference_helper::type> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_rvalue_reference_v = etlstd::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> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pod_v = etlstd::is_pod::value; +#endif + + //*************************************************************************** + /// is_trivially_constructible + /// Only POD types are recognised. + template struct is_trivially_constructible : etlstd::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = etlstd::is_trivially_constructible::value; +#endif + + //*************************************************************************** + /// is_trivially_copy_constructible + /// Only POD types are recognised. + template struct is_trivially_copy_constructible : etlstd::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_constructible_v = etlstd::is_trivially_copy_constructible::value; +#endif + + //*************************************************************************** + /// is_trivially_destructible + /// Only POD types are recognised. + template struct is_trivially_destructible : etlstd::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_destructible_v = etlstd::is_trivially_destructible::value; +#endif + + //*************************************************************************** + /// is_trivially_copy_assignable + /// Only POD types are recognised. + template struct is_trivially_copy_assignable : etlstd::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_assignable_v = etlstd::is_trivially_copy_assignable::value; +#endif + + //*************************************************************************** + /// is_trivially_copyable + /// Only POD types are recognised. + template struct is_trivially_copyable : etlstd::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = etlstd::is_trivially_copyable::value; +#endif + + //*************************************************************************** /// conditional - ///\ingroup type_traits template struct conditional { typedef T type; }; template struct conditional { typedef F type; }; - /// conditional_integral_constant - ///\ingroup type_traits - template - struct conditional_integral_constant; - - template - struct conditional_integral_constant - { - 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(etl::is_integral::value, "Not an integral type"); - static const T value = FALSE_VALUE; - }; - + //*************************************************************************** /// make_signed - ///\ingroup type_traits template struct make_signed { typedef T type; }; template <> struct make_signed { typedef signed char type; }; template <> struct make_signed { typedef signed char type; }; template <> struct make_signed { - typedef etl::conditional::type>::type type; + typedef etlstd::conditional::type>::type type; }; template <> struct make_signed { typedef short type; }; @@ -378,8 +493,13 @@ namespace etl template struct make_signed : add_volatile::type> {}; template struct make_signed : add_const::type>::type> {}; +#if ETL_CPP14_SUPPORTED + template + using make_signed_t = typename make_signed::type; +#endif + + //*************************************************************************** /// make_unsigned - ///\ingroup type_traits template struct make_unsigned { typedef T type; }; template <> struct make_unsigned { typedef unsigned char type; }; template <> struct make_unsigned { typedef unsigned char type; }; @@ -387,11 +507,11 @@ namespace etl template <> struct make_unsigned { - typedef etl::conditional::type>::type type; + typedef etlstd::conditional::type>::type type; }; template <> struct make_unsigned { typedef unsigned int type; }; @@ -401,18 +521,28 @@ namespace etl template struct make_unsigned : add_volatile::type> {}; template struct make_unsigned : add_const::type>::type> {}; +#if ETL_CPP14_SUPPORTED + template + using make_unsigned_t = typename make_unsigned::type; +#endif + + //*************************************************************************** /// enable_if - ///\ingroup type_traits template struct enable_if {}; template struct enable_if { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using enable_if_t = typename enable_if::type; +#endif + + //*************************************************************************** /// extent - ///\ingroup type_traits - template - struct extent : integral_constant {}; + template + struct extent : integral_constant {}; template - struct extent : integral_constant {}; + struct extent : integral_constant {}; template struct extent : integral_constant::value> {}; @@ -423,49 +553,74 @@ namespace etl template struct extent : integral_constant::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t extent_v = extent::value; +#endif + + //*************************************************************************** /// remove_extent - ///\ingroup type_traits template struct remove_extent { typedef T type; }; template struct remove_extent { typedef T type; }; - template struct remove_extent { typedef T type;}; + template struct remove_extent { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_extent_t = typename remove_extent::type; +#endif + + //*************************************************************************** /// remove_all_extents - ///\ingroup type_traits - template struct remove_all_extents { typedef T type;}; + template struct remove_all_extents { typedef T type; }; template struct remove_all_extents { typedef typename remove_all_extents::type type; }; template struct remove_all_extents { typedef typename remove_all_extents::type type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_all_extents_t = typename remove_all_extents::type; +#endif + + //*************************************************************************** /// rank - ///\ingroup type_traits template struct rank : integral_constant {}; template struct rank : public integral_constant::value + 1> {}; template struct rank : public integral_constant::value + 1> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t rank_v = rank::value; +#endif + + //*************************************************************************** /// decay - ///\ingroup type_traits template struct decay { - typedef typename etl::remove_reference::type U; - typedef typename etl::conditional::value, - typename etl::remove_extent::type*, - typename etl::remove_cv::type>::type type; + typedef typename etlstd::remove_reference::type U; + typedef typename etlstd::conditional::value, + typename etlstd::remove_extent::type*, + typename etlstd::remove_cv::type>::type type; }; +#if ETL_CPP14_SUPPORTED + template + using decay_t = typename decay::type; +#endif + + //*************************************************************************** /// is_base_of - ///\ingroup type_traits template::value || etl::is_fundamental::value)> + const bool IsFundamental = (etlstd::is_fundamental::value || etlstd::is_fundamental::value)> struct is_base_of { private: template struct dummy {}; - struct internal: TDerived, dummy{}; + struct internal: TDerived, dummy{}; - static TBase* check(TBase*); - template static char check(dummy*); + static TBase* check(TBase*); + template static char check(dummy*); public: @@ -479,42 +634,681 @@ namespace etl static const bool value = false; }; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_base_of_v = is_base_of::value; +#endif + + //*************************************************************************** + /// add_lvalue_reference + template struct add_lvalue_reference { using type = T & ; }; + template struct add_lvalue_reference { using type = T & ; }; + template <> struct add_lvalue_reference { using type = void; }; + template <> struct add_lvalue_reference { using type = const void; }; + template <> struct add_lvalue_reference { using type = volatile void; }; + template <> struct add_lvalue_reference { using type = const volatile void; }; + +#if ETL_CPP14_SUPPORTED + template + using add_lvalue_reference_t = typename etlstd::add_lvalue_reference::type; +#endif + + //*************************************************************************** + /// add_rvalue_reference +#if ETL_CPP11_SUPPORTED + template struct add_rvalue_reference { using type = T && ; }; + template struct add_rvalue_reference { using type = T & ; }; + template <> struct add_rvalue_reference { using type = void; }; + template <> struct add_rvalue_reference { using type = const void; }; + template <> struct add_rvalue_reference { using type = volatile void; }; + template <> struct add_rvalue_reference { using type = const volatile void; }; +#endif + +#if ETL_CPP14_SUPPORTED + template + using add_rvalue_reference_t = typename etlstd::add_rvalue_reference::type; +#endif + + //*************************************************************************** + /// decval +#if ETL_CPP11_SUPPORTED + template + typename etlstd::add_rvalue_reference::type declval() ETL_NOEXCEPT; +#endif + + //*************************************************************************** + /// is_convertible +#if ETL_CPP11_SUPPORTED + namespace private_type_traits + { + template + using true_type_for = etlstd::true_type; + + template + auto returnable(int)->true_type_for; + + template + auto returnable(...)->etlstd::false_type; + + template + auto nonvoid_convertible(int)->true_type_for()(etlstd::declval())) + >; + template + auto nonvoid_convertible(...)->etlstd::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)> {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_convertible_v = etlstd::is_convertible::value; +#endif + + //*************************************************************************** /// Alignment templates. /// These require compiler specific intrinsics. - ///\ingroup type_traits -#if ETL_CPP11_SUPPORTED - template struct alignment_of : integral_constant {}; +#ifdef ETL_COMPILER_MICROSOFT + template struct alignment_of : integral_constant {}; +#elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI) + template struct alignment_of : integral_constant {}; #else - #ifdef ETL_COMPILER_MICROSOFT - template struct alignment_of : integral_constant {}; - #elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI) - template struct alignment_of : integral_constant {}; - #else - template struct alignment_of : integral_constant {}; - #endif + template struct alignment_of : integral_constant {}; #endif /// Specialisation of 'alignment_of' for 'void'. ///\ingroup type_traits - template <> struct alignment_of : integral_constant {}; + template <> struct alignment_of : integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t alignment_of_v = etlstd::alignment_of::value; +#endif +} + +#else + +//***************************************************************************** +// Traits are derived from the STL +//***************************************************************************** +#include + +namespace etlstd +{ + //*************************************************************************** + /// integral_constant + ///\ingroup type_traits + template + struct integral_constant : std::integral_constant {}; + + /// integral_constant specialisations + ///\ingroup type_traits + typedef integral_constant false_type; + typedef integral_constant true_type; + +#if ETL_CPP17_SUPPORTED + template + using bool_constant = std::integral_constant; +#endif + + //*************************************************************************** + /// remove_reference + ///\ingroup type_traits + template struct remove_reference : std::remove_reference {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_reference_t = std::remove_reference_t; +#endif + + //*************************************************************************** + /// remove_pointer + ///\ingroup type_traits + template struct remove_pointer : std::remove_pointer {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_pointer_t = std::remove_pointer_t; +#endif + + //*************************************************************************** + /// add_pointer + ///\ingroup type_traits + template struct add_pointer : std::add_pointer {}; + +#if ETL_CPP14_SUPPORTED + template + using add_pointer_t = std::add_pointer_t; +#endif + + //*************************************************************************** + /// is_const + ///\ingroup type_traits + template struct is_const : std::is_const {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_const_v = std::is_const_v; +#endif + + //*************************************************************************** + /// remove_const + ///\ingroup type_traits + template struct remove_const : std::remove_const {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_const_t = std::remove_const_t; +#endif + + //*************************************************************************** + /// add_const + ///\ingroup type_traits + template struct add_const : std::add_const {}; + +#if ETL_CPP14_SUPPORTED + template + using add_const_t = std::add_const_t; +#endif + + //*************************************************************************** + /// is_volatile + ///\ingroup type_traits + template struct is_volatile : std::is_volatile {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_volatile_v = std::is_volatile_v; +#endif + + //*************************************************************************** + /// remove_volatile + ///\ingroup type_traits + template struct remove_volatile : std::remove_volatile {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_volatile_t = std::remove_volatile_t; +#endif + + //*************************************************************************** + /// add_volatile + ///\ingroup type_traits + template struct add_volatile : std::add_volatile {}; + +#if ETL_CPP14_SUPPORTED + template + using add_volatile_t = std::add_volatile_t; +#endif + + //*************************************************************************** + /// remove_cv + ///\ingroup type_traits + template struct remove_cv : std::remove_cv {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_cv_t = std::remove_cv_t; +#endif + + //*************************************************************************** + /// add_cv + ///\ingroup type_traits + template struct add_cv : std::add_cv {}; + +#if ETL_CPP14_SUPPORTED + template + using add_cv_t = std::add_cv_t; +#endif + + //*************************************************************************** + /// is_integral + ///\ingroup type_traits + template struct is_integral : std::is_integral {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_integral_v = std::is_integral_v; +#endif + + //*************************************************************************** + /// is_signed + ///\ingroup type_traits + template struct is_signed : std::is_signed {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_signed_v = std::is_signed_v; +#endif + + //*************************************************************************** + /// is_unsigned + ///\ingroup type_traits + template struct is_unsigned : std::is_unsigned {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_unsigned_v = std::is_unsigned_v; +#endif + + //*************************************************************************** + /// is_floating_point + ///\ingroup type_traits + template struct is_floating_point : std::is_floating_point {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_floating_point_v = std::is_floating_point_v; +#endif + + //*************************************************************************** + /// is_same + ///\ingroup type_traits + template struct is_same : std::is_same {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_same_v = std::is_same_v; +#endif + + //*************************************************************************** + /// is_void + ///\ingroup type_traits + template struct is_void : std::is_void {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_void_v = std::is_void_v; +#endif + + //*************************************************************************** + /// is_arithmetic + ///\ingroup type_traits + template struct is_arithmetic : std::is_arithmetic {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_arithmetic_v = std::is_arithmetic_v; +#endif + + //*************************************************************************** + /// is_fundamental + ///\ingroup type_traits + template struct is_fundamental : std::is_fundamental {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_fundamental_v = std::is_fundamental_v; +#endif + + //*************************************************************************** + /// is_compound + ///\ingroup type_traits + template struct is_compound : std::is_compound {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_compound_v = std::is_compound_v; +#endif + + //*************************************************************************** + /// is_array + ///\ingroup type_traits + template struct is_array : std::is_array {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_array_v = std::is_array_v; +#endif + + //*************************************************************************** + /// is_pointer + ///\ingroup type_traits + template struct is_pointer : std::is_pointer {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pointer_v = std::is_pointer_v; +#endif + + //*************************************************************************** + /// is_reference + ///\ingroup type_traits + template struct is_reference : std::is_reference {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_reference_v = std::is_reference_v; +#endif + + //*************************************************************************** + /// is_lvalue_reference + ///\ingroup type_traits + template struct is_lvalue_reference : std::is_lvalue_reference {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_lvalue_reference_v = std::is_lvalue_reference_v; +#endif + + //*************************************************************************** + /// is_rvalue_reference + ///\ingroup type_traits +#if ETL_CPP11_SUPPORTED + template struct is_rvalue_reference : std::is_rvalue_reference {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_rvalue_reference_v = std::is_rvalue_reference_v; +#endif + + //*************************************************************************** + /// is_pod + ///\ingroup type_traits + template struct is_pod : std::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pod_v = std::is_pod_v; +#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 : 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 + + //*************************************************************************** + /// conditional + ///\ingroup type_traits + template struct conditional { typedef T type; }; + template struct conditional { typedef F type; }; + + //*************************************************************************** + /// make_signed + ///\ingroup type_traits + template struct make_signed : std::make_signed {}; + +#if ETL_CPP14_SUPPORTED + template + using make_signed_t = std::make_signed_t; +#endif + + //*************************************************************************** + /// make_unsigned + ///\ingroup type_traits + template struct make_unsigned : std::make_unsigned {}; + +#if ETL_CPP14_SUPPORTED + template + using make_unsigned_t = std::make_unsigned_t; +#endif + + //*************************************************************************** + /// enable_if + ///\ingroup type_traits + template struct enable_if : std::enable_if {}; + +#if ETL_CPP14_SUPPORTED + template + using enable_if_t = std::enable_if_t; +#endif + + //*************************************************************************** + /// extent + ///\ingroup type_traits + template + struct extent : std::extent {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t extent_v = std::extent_v; +#endif + + //*************************************************************************** + /// remove_extent + ///\ingroup type_traits + template struct remove_extent : std::remove_extent { }; + +#if ETL_CPP14_SUPPORTED + template + using remove_extent_t = std::remove_extent_t; +#endif + + //*************************************************************************** + /// remove_all_extents + ///\ingroup type_traits + template struct remove_all_extents : std::remove_all_extents { }; + +#if ETL_CPP14_SUPPORTED + template + using remove_all_extents_t = std::remove_all_extents_t; +#endif + + //*************************************************************************** + /// rank + ///\ingroup type_traits + template struct rank : std::rank {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t rank_v = std::rank_v; +#endif + + //*************************************************************************** + /// decay + ///\ingroup type_traits + template struct decay : std::decay {}; + +#if ETL_CPP14_SUPPORTED + template + using decay_t = std::decay_t; +#endif + + //*************************************************************************** + /// is_base_of + ///\ingroup type_traits + template struct is_base_of : std::is_base_of {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_base_of_v = std::is_base_of_v; +#endif + + //*************************************************************************** + /// add_lvalue_reference + template struct add_lvalue_reference : std::add_lvalue_reference {}; + +#if ETL_CPP14_SUPPORTED + template + using add_lvalue_reference_t = std::add_lvalue_reference_t; +#endif + + //*************************************************************************** + /// add_rvalue_reference +#if ETL_CPP11_SUPPORTED + template struct add_rvalue_reference : std::add_rvalue_reference {}; +#endif + +#if ETL_CPP14_SUPPORTED + template + using add_rvalue_reference_t = std::add_rvalue_reference_t; +#endif + + //*************************************************************************** + /// decval +#if ETL_CPP11_SUPPORTED + template + typename std::add_rvalue_reference::type declval() ETL_NOEXCEPT; +#endif + + //*************************************************************************** + /// is_convertible + ///\ingroup type_traits +#if ETL_CPP11_SUPPORTED + template + struct is_convertible : std::is_convertible {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_convertible_v = std::is_convertible_v; +#endif + + //*************************************************************************** + /// Alignment templates. + ///\ingroup type_traits + template struct alignment_of : std::alignment_of {}; + template <> struct alignment_of : std::integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t alignment_of_v = std::alignment_of_v; +#endif +} +#endif + +//*************************************************************************** +// ETL specific type traits. +//*************************************************************************** +namespace etl +{ + //*************************************************************************** + /// conditional_integral_constant + // /\ingroup type_traits + template + struct conditional_integral_constant; + + template + struct conditional_integral_constant + { + ETL_STATIC_ASSERT(etlstd::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"); + static const T value = FALSE_VALUE; + }; + #if ETL_CPP11_SUPPORTED - - //***************************************************************************" + //*************************************************************************** /// Template to determine if a type is one of a specified list. ///\ingroup types - //***************************************************************************" template struct is_one_of { - static const bool value = etl::is_same::value || - etl::is_one_of::value; + static const bool value = etlstd::is_same::value || + etl::is_one_of::value; }; template struct is_one_of { - static const bool value = etl::is_same::value; + static const bool value = etlstd::is_same::value; }; #else @@ -522,47 +1316,52 @@ namespace etl //*************************************************************************** /// Template to determine if a type is one of a specified list. ///\ingroup types - //*************************************************************************** template struct is_one_of { - static const bool value = - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value || - etl::is_same::value; + static const bool value = + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + etlstd::is_same::value || + 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 + template + inline constexpr bool is_one_of_v = etl::is_one_of::value; +#endif + //*************************************************************************** - // A set of templates to allow related types to be derived. - //*************************************************************************** + /// A set of templates to allow related types to be derived. + ///\ingroup types + // Default. template struct types { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -580,7 +1379,7 @@ namespace etl { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -598,7 +1397,7 @@ namespace etl { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -616,7 +1415,7 @@ namespace etl { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -628,22 +1427,57 @@ namespace etl typedef const type_t* const const_pointer_const; }; - //*************************************************************************** - // size_of - //*************************************************************************** #if ETL_CPP11_SUPPORTED + // rvalue References. template - constexpr size_t size_of() + struct types { - return sizeof(T); - } + private: - template <> - constexpr size_t size_of() - { - return 1; - } + typedef typename etlstd::remove_cv::type type_t; + + public: + + typedef type_t type; + typedef type_t& reference; + typedef const type_t& const_reference; + typedef type_t* pointer; + typedef const type_t* const_pointer; + typedef const type_t* const const_pointer_const; + }; +#endif + +#if ETL_CPP14_SUPPORTED + template + using types_t = typename types::type; + + template + using types_r = typename types::reference; + + template + using types_cr = typename types::const_reference; + + template + using types_p = typename types::pointer; + + template + using types_cp = typename types::const_pointer; + + template + using types_cpc = typename types::const_pointer_const; +#endif + + //*************************************************************************** + /// size_of + ///\ingroup types + template struct size_of : etlstd::integral_constant {}; + template <> struct size_of : etlstd::integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t size_of_v = etl::size_of::value; #endif } + #endif diff --git a/include/etl/type_traits_generator.h b/include/etl/type_traits_generator.h index f090f469..1da6f67a 100644 --- a/include/etl/type_traits_generator.h +++ b/include/etl/type_traits_generator.h @@ -72,18 +72,20 @@ cog.outl("//******************************************************************** #include "nullptr.h" #include "static_assert.h" -#if (ETL_CPP11_SUPPORTED) && !defined(ETL_NO_STL) - #include -#endif - ///\defgroup type_traits type_traits -/// A set of type traits definitions for compilers that do not support the standard header. +/// A set of type traits definitions. +/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined. /// \ingroup utilities -namespace etl +#if defined(ETL_NO_STL) + +//***************************************************************************** +// Traits are defined by the ETL +//***************************************************************************** +namespace etlstd { + //*************************************************************************** /// integral_constant - ///\ingroup type_traits template struct integral_constant { @@ -94,27 +96,31 @@ namespace etl operator value_type() const { - return value; + return value; } }; /// integral_constant specialisations - ///\ingroup type_traits typedef integral_constant false_type; typedef integral_constant true_type; +#if ETL_CPP17_SUPPORTED + template + using bool_constant = integral_constant; +#endif + + //*************************************************************************** /// remove_reference - ///\ingroup type_traits template struct remove_reference { typedef T type; }; template struct remove_reference { typedef T type; }; - /// add_reference - ///\ingroup type_traits - template struct add_reference { typedef T& type; }; - template struct add_reference { typedef T& type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_reference_t = typename remove_reference::type; +#endif + //*************************************************************************** /// remove_pointer - ///\ingroup type_traits template struct remove_pointer { typedef T type; }; template struct remove_pointer { typedef T type; }; template struct remove_pointer { typedef const T type; }; @@ -125,58 +131,108 @@ namespace etl template struct remove_pointer { typedef volatile T type; }; template struct remove_pointer { typedef const volatile T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_pointer_t = typename remove_pointer::type; +#endif + + //*************************************************************************** /// add_pointer - ///\ingroup type_traits template struct add_pointer { typedef typename remove_reference::type* type; }; +#if ETL_CPP14_SUPPORTED + template + using add_pointer_t = typename add_pointer::type; +#endif + + //*************************************************************************** /// is_const - ///\ingroup type_traits template struct is_const : false_type {}; template struct is_const : true_type {}; template struct is_const : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_const_v = is_const::value; +#endif + + //*************************************************************************** /// remove_const - ///\ingroup type_traits template struct remove_const { typedef T type; }; template struct remove_const { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_const_t = typename remove_const::type; +#endif + + //*************************************************************************** /// add_const - ///\ingroup type_traits template struct add_const { typedef const T type; }; template struct add_const { typedef const T type; }; +#if ETL_CPP14_SUPPORTED + template + using add_const_t = typename add_const::type; +#endif + + //*************************************************************************** /// is_volatile - ///\ingroup type_traits template struct is_volatile : false_type {}; template struct is_volatile : true_type {}; template struct is_volatile : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_volatile_v = is_volatile::value; +#endif + + //*************************************************************************** /// remove_volatile - ///\ingroup type_traits template struct remove_volatile { typedef T type; }; template struct remove_volatile { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_volatile_t = typename remove_volatile::type; +#endif + + //*************************************************************************** /// add_volatile - ///\ingroup type_traits template struct add_volatile { typedef volatile T type; }; template struct add_volatile { typedef volatile T type; }; +#if ETL_CPP14_SUPPORTED + template + using add_volatile_t = typename add_volatile::type; +#endif + + //*************************************************************************** /// remove_cv - ///\ingroup type_traits template struct remove_cv { typedef typename remove_volatile::type>::type type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_cv_t = typename remove_cv::type; +#endif + + //*************************************************************************** /// add_cv - ///\ingroup type_traits template struct add_cv { typedef typename add_volatile::type>::type type; }; +#if ETL_CPP14_SUPPORTED + template + using add_cv_t = typename add_cv::type; +#endif + + //*************************************************************************** /// is_integral - ///\ingroup type_traits template struct is_integral : false_type {}; template <> struct is_integral : true_type {}; template <> struct is_integral : true_type {}; @@ -195,8 +251,13 @@ namespace etl template struct is_integral : is_integral {}; template struct is_integral : is_integral {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_integral_v = is_integral::value; +#endif + + //*************************************************************************** /// is_signed - ///\ingroup type_traits template struct is_signed : false_type {}; template <> struct is_signed : integral_constant {}; template <> struct is_signed : public etl::integral_constant(wchar_t(-1) < wchar_t(0))> {}; @@ -205,15 +266,20 @@ namespace etl template <> struct is_signed : true_type {}; template <> struct is_signed : true_type {}; template <> struct is_signed : true_type {}; - template <> struct is_signed : true_type{}; - template <> struct is_signed : true_type{}; - template <> struct is_signed : true_type{}; + template <> struct is_signed : true_type {}; + template <> struct is_signed : true_type {}; + template <> struct is_signed : true_type {}; template struct is_signed : is_signed {}; template struct is_signed : is_signed {}; template struct is_signed : is_signed {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_signed_v = is_signed::value; +#endif + + //*************************************************************************** /// is_unsigned - ///\ingroup type_traits template struct is_unsigned : false_type {}; template <> struct is_unsigned : true_type {}; template <> struct is_unsigned : integral_constant 0)> {}; @@ -227,8 +293,13 @@ namespace etl template struct is_unsigned : is_unsigned {}; template struct is_unsigned : is_unsigned {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_unsigned_v = is_unsigned::value; +#endif + + //*************************************************************************** /// is_floating_point - ///\ingroup type_traits template struct is_floating_point : false_type {}; template <> struct is_floating_point : true_type {}; template <> struct is_floating_point : true_type {}; @@ -237,149 +308,193 @@ namespace etl template struct is_floating_point : is_floating_point {}; template struct is_floating_point : is_floating_point {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_floating_point_v = is_floating_point::value; +#endif + + //*************************************************************************** /// is_same - ///\ingroup type_traits template struct is_same : public false_type {}; template struct is_same : public true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_same_v = is_same::value; +#endif + + //*************************************************************************** /// is_void - ///\ingroup type_traits template struct is_void : false_type {}; template<> struct is_void : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_void_v = is_void::value; +#endif + + //*************************************************************************** /// is_arithmetic - ///\ingroup type_traits template struct is_arithmetic : integral_constant::value || is_floating_point::value> {}; - /// is_fundamental - ///\ingroup type_traits - template struct is_fundamental : integral_constant::value || - is_void::value || - is_same::type>::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_arithmetic_v = is_arithmetic::value; +#endif + //*************************************************************************** + /// is_fundamental + template struct is_fundamental : integral_constant::value || + is_void::value || + is_same::type>::value> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_fundamental_v = is_fundamental::value; +#endif + + //*************************************************************************** /// is_compound - ///\ingroup type_traits template struct is_compound : integral_constant::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_compound_v = is_compound::value; +#endif + + //*************************************************************************** /// is_array - ///\ingroup type_traits template struct is_array : false_type {}; template struct is_array : true_type {}; template struct is_array : true_type {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_array_v = is_array::value; +#endif + + //*************************************************************************** /// is_pointer - ///\ingroup type_traits template struct is_pointer_helper : false_type {}; template struct is_pointer_helper : true_type {}; template struct is_pointer : is_pointer_helper::type> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pointer_v = is_pointer::value; +#endif + + //*************************************************************************** /// is_reference - ///\ingroup type_traits template struct is_reference_helper : false_type {}; template struct is_reference_helper : true_type {}; template struct is_reference : is_reference_helper::type> {}; - /// is_pod - /// For C++03, only fundamental and pointers types are recognised. - ///\ingroup type_traits -#if (ETL_CPP11_SUPPORTED && !defined(ARDUINO) && !defined(ETL_STLPORT)) && !defined(IN_TYPE_TRAITS_TEST) && !defined(ETL_NO_STL) - // For compilers that support C++11 - template struct is_pod : std::is_pod {}; -#else - template struct is_pod : etl::integral_constant::value || etl::is_pointer::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_reference_v = is_reference::value; #endif -#if (ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED) && !defined(ETL_STLPORT) && !defined(IN_TYPE_TRAITS_TEST) && !defined(ETL_NO_STL) - /// is_trivially_constructible - ///\ingroup type_traits - template struct is_trivially_constructible : std::is_trivially_constructible {}; + //*************************************************************************** + /// is_lvalue_reference + template struct is_lvalue_reference_helper : false_type {}; + template struct is_lvalue_reference_helper : true_type {}; + template struct is_lvalue_reference : is_lvalue_reference_helper::type> {}; - /// is_trivially_copy_constructible - ///\ingroup type_traits - template struct is_trivially_copy_constructible : std::is_trivially_copy_constructible {}; - - /// is_trivially_destructible - ///\ingroup type_traits - template struct is_trivially_destructible : std::is_trivially_destructible {}; - - /// is_trivially_copy_assignable - ///\ingroup type_traits - template struct is_trivially_copy_assignable : std::is_trivially_copy_assignable {}; - - /// is_trivially_copyable - ///\ingroup type_traits - template struct is_trivially_copyable : std::is_trivially_copyable {}; -#else - /// is_trivially_constructible - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_constructible : etl::is_pod {}; - - /// is_trivially_copy_constructible - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copy_constructible : etl::is_pod {}; - - /// is_trivially_destructible - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_destructible : etl::is_pod {}; - - /// is_trivially_copy_assignable - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copy_assignable : etl::is_pod {}; - - /// is_trivially_copyable - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copyable : etl::is_pod {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_lvalue_reference_v = etl::is_lvalue_reference::value; #endif -#if ETL_CPP11_SUPPORTED + //*************************************************************************** /// is_rvalue_reference - ///\ingroup type_traits - template struct is_rvalue_reference : etl::false_type {}; - template struct is_rvalue_reference : etl::true_type {}; + template struct is_rvalue_reference_helper : false_type {}; + template struct is_rvalue_reference_helper : true_type {}; + template struct is_rvalue_reference : is_rvalue_reference_helper::type> {}; + +#if ETL_CPP17_SUPPORTED + template + 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 : etl::integral_constant::value || etlstd::is_pointer::value> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pod_v = etlstd::is_pod::value; +#endif + + //*************************************************************************** + /// is_trivially_constructible + /// Only POD types are recognised. + template struct is_trivially_constructible : etlstd::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = etlstd::is_trivially_constructible::value; +#endif + + //*************************************************************************** + /// is_trivially_copy_constructible + /// Only POD types are recognised. + template struct is_trivially_copy_constructible : etlstd::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + 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 {}; + +#if ETL_CPP17_SUPPORTED + template + 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 {}; + +#if ETL_CPP17_SUPPORTED + template + 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 {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable::value; +#endif + + //*************************************************************************** /// conditional - ///\ingroup type_traits template struct conditional { typedef T type; }; template struct conditional { typedef F type; }; - /// conditional_integral_constant - ///\ingroup type_traits - template - struct conditional_integral_constant; - - template - struct conditional_integral_constant - { - 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(etl::is_integral::value, "Not an integral type"); - static const T value = FALSE_VALUE; - }; - + //*************************************************************************** /// make_signed - ///\ingroup type_traits template struct make_signed { typedef T type; }; template <> struct make_signed { typedef signed char type; }; template <> struct make_signed { typedef signed char type; }; template <> struct make_signed { - typedef etl::conditional::type>::type type; + typedef etlstd::conditional::type>::type type; }; template <> struct make_signed { typedef short type; }; @@ -390,8 +505,13 @@ namespace etl template struct make_signed : add_volatile::type> {}; template struct make_signed : add_const::type>::type> {}; +#if ETL_CPP14_SUPPORTED + template + using make_signed_t = typename make_signed::type; +#endif + + //*************************************************************************** /// make_unsigned - ///\ingroup type_traits template struct make_unsigned { typedef T type; }; template <> struct make_unsigned { typedef unsigned char type; }; template <> struct make_unsigned { typedef unsigned char type; }; @@ -399,11 +519,11 @@ namespace etl template <> struct make_unsigned { - typedef etl::conditional::type>::type type; + typedef etlstd::conditional::type>::type type; }; template <> struct make_unsigned { typedef unsigned int type; }; @@ -413,18 +533,28 @@ namespace etl template struct make_unsigned : add_volatile::type> {}; template struct make_unsigned : add_const::type>::type> {}; +#if ETL_CPP14_SUPPORTED + template + using make_unsigned_t = typename make_unsigned::type; +#endif + + //*************************************************************************** /// enable_if - ///\ingroup type_traits template struct enable_if {}; template struct enable_if { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using enable_if_t = typename enable_if::type; +#endif + + //*************************************************************************** /// extent - ///\ingroup type_traits - template - struct extent : integral_constant {}; + template + struct extent : integral_constant {}; template - struct extent : integral_constant {}; + struct extent : integral_constant {}; template struct extent : integral_constant::value> {}; @@ -435,49 +565,74 @@ namespace etl template struct extent : integral_constant::value> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t extent_v = extent::value; +#endif + + //*************************************************************************** /// remove_extent - ///\ingroup type_traits template struct remove_extent { typedef T type; }; template struct remove_extent { typedef T type; }; - template struct remove_extent { typedef T type;}; + template struct remove_extent { typedef T type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_extent_t = typename remove_extent::type; +#endif + + //*************************************************************************** /// remove_all_extents - ///\ingroup type_traits - template struct remove_all_extents { typedef T type;}; + template struct remove_all_extents { typedef T type; }; template struct remove_all_extents { typedef typename remove_all_extents::type type; }; template struct remove_all_extents { typedef typename remove_all_extents::type type; }; +#if ETL_CPP14_SUPPORTED + template + using remove_all_extents_t = typename remove_all_extents::type; +#endif + + //*************************************************************************** /// rank - ///\ingroup type_traits template struct rank : integral_constant {}; template struct rank : public integral_constant::value + 1> {}; template struct rank : public integral_constant::value + 1> {}; +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t rank_v = rank::value; +#endif + + //*************************************************************************** /// decay - ///\ingroup type_traits template struct decay { - typedef typename etl::remove_reference::type U; - typedef typename etl::conditional::value, - typename etl::remove_extent::type*, - typename etl::remove_cv::type>::type type; + typedef typename etlstd::remove_reference::type U; + typedef typename etlstd::conditional::value, + typename etlstd::remove_extent::type*, + typename etlstd::remove_cv::type>::type type; }; +#if ETL_CPP14_SUPPORTED + template + using decay_t = typename decay::type; +#endif + + //*************************************************************************** /// is_base_of - ///\ingroup type_traits template::value || etl::is_fundamental::value)> + const bool IsFundamental = (etlstd::is_fundamental::value || etlstd::is_fundamental::value)> struct is_base_of { private: template struct dummy {}; - struct internal: TDerived, dummy{}; + struct internal: TDerived, dummy{}; - static TBase* check(TBase*); - template static char check(dummy*); + static TBase* check(TBase*); + template static char check(dummy*); public: @@ -491,42 +646,681 @@ namespace etl static const bool value = false; }; +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_base_of_v = is_base_of::value; +#endif + + //*************************************************************************** + /// add_lvalue_reference + template struct add_lvalue_reference { using type = T & ; }; + template struct add_lvalue_reference { using type = T & ; }; + template <> struct add_lvalue_reference { using type = void; }; + template <> struct add_lvalue_reference { using type = const void; }; + template <> struct add_lvalue_reference { using type = volatile void; }; + template <> struct add_lvalue_reference { using type = const volatile void; }; + +#if ETL_CPP14_SUPPORTED + template + using add_lvalue_reference_t = typename etlstd::add_lvalue_reference::type; +#endif + + //*************************************************************************** + /// add_rvalue_reference +#if ETL_CPP11_SUPPORTED + template struct add_rvalue_reference { using type = T && ; }; + template struct add_rvalue_reference { using type = T & ; }; + template <> struct add_rvalue_reference { using type = void; }; + template <> struct add_rvalue_reference { using type = const void; }; + template <> struct add_rvalue_reference { using type = volatile void; }; + template <> struct add_rvalue_reference { using type = const volatile void; }; +#endif + +#if ETL_CPP14_SUPPORTED + template + using add_rvalue_reference_t = typename etlstd::add_rvalue_reference::type; +#endif + + //*************************************************************************** + /// decval +#if ETL_CPP11_SUPPORTED + template + typename etlstd::add_rvalue_reference::type declval() ETL_NOEXCEPT; +#endif + + //*************************************************************************** + /// is_convertible +#if ETL_CPP11_SUPPORTED + namespace private_type_traits + { + template + using true_type_for = etlstd::true_type; + + template + auto returnable(int)->true_type_for; + + template + auto returnable(...)->etlstd::false_type; + + template + auto nonvoid_convertible(int)->true_type_for()(etl::declval())) + >; + template + auto nonvoid_convertible(...)->etlstd::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)> {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_convertible_v = etlstd::is_convertible::value; +#endif + + //*************************************************************************** /// Alignment templates. /// These require compiler specific intrinsics. - ///\ingroup type_traits -#if ETL_CPP11_SUPPORTED - template struct alignment_of : integral_constant {}; +#ifdef ETL_COMPILER_MICROSOFT + template struct alignment_of : integral_constant {}; +#elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI) + template struct alignment_of : integral_constant {}; #else - #ifdef ETL_COMPILER_MICROSOFT - template struct alignment_of : integral_constant {}; - #elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI) - template struct alignment_of : integral_constant {}; - #else - template struct alignment_of : integral_constant {}; - #endif + template struct alignment_of : integral_constant {}; #endif /// Specialisation of 'alignment_of' for 'void'. ///\ingroup type_traits - template <> struct alignment_of : integral_constant {}; + template <> struct alignment_of : integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t alignment_of_v = etlstd::alignment_of::value; +#endif +} + +#else + +//***************************************************************************** +// Traits are derived from the STL +//***************************************************************************** +#include + +namespace etlstd +{ + //*************************************************************************** + /// integral_constant + ///\ingroup type_traits + template + struct integral_constant : std::integral_constant {}; + + /// integral_constant specialisations + ///\ingroup type_traits + typedef integral_constant false_type; + typedef integral_constant true_type; + +#if ETL_CPP17_SUPPORTED + template + using bool_constant = std::integral_constant; +#endif + + //*************************************************************************** + /// remove_reference + ///\ingroup type_traits + template struct remove_reference : std::remove_reference {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_reference_t = std::remove_reference_t; +#endif + + //*************************************************************************** + /// remove_pointer + ///\ingroup type_traits + template struct remove_pointer : std::remove_pointer {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_pointer_t = std::remove_pointer_t; +#endif + + //*************************************************************************** + /// add_pointer + ///\ingroup type_traits + template struct add_pointer : std::add_pointer {}; + +#if ETL_CPP14_SUPPORTED + template + using add_pointer_t = std::add_pointer_t; +#endif + + //*************************************************************************** + /// is_const + ///\ingroup type_traits + template struct is_const : std::is_const {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_const_v = std::is_const_v; +#endif + + //*************************************************************************** + /// remove_const + ///\ingroup type_traits + template struct remove_const : std::remove_const {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_const_t = std::remove_const_t; +#endif + + //*************************************************************************** + /// add_const + ///\ingroup type_traits + template struct add_const : std::add_const {}; + +#if ETL_CPP14_SUPPORTED + template + using add_const_t = std::add_const_t; +#endif + + //*************************************************************************** + /// is_volatile + ///\ingroup type_traits + template struct is_volatile : std::is_volatile {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_volatile_v = std::is_volatile_v; +#endif + + //*************************************************************************** + /// remove_volatile + ///\ingroup type_traits + template struct remove_volatile : std::remove_volatile {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_volatile_t = std::remove_volatile_t; +#endif + + //*************************************************************************** + /// add_volatile + ///\ingroup type_traits + template struct add_volatile : std::add_volatile {}; + +#if ETL_CPP14_SUPPORTED + template + using add_volatile_t = std::add_volatile_t; +#endif + + //*************************************************************************** + /// remove_cv + ///\ingroup type_traits + template struct remove_cv : std::remove_cv {}; + +#if ETL_CPP14_SUPPORTED + template + using remove_cv_t = std::remove_cv_t; +#endif + + //*************************************************************************** + /// add_cv + ///\ingroup type_traits + template struct add_cv : std::add_cv {}; + +#if ETL_CPP14_SUPPORTED + template + using add_cv_t = std::add_cv_t; +#endif + + //*************************************************************************** + /// is_integral + ///\ingroup type_traits + template struct is_integral : std::is_integral {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_integral_v = std::is_integral_v; +#endif + + //*************************************************************************** + /// is_signed + ///\ingroup type_traits + template struct is_signed : std::is_signed {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_signed_v = std::is_signed_v; +#endif + + //*************************************************************************** + /// is_unsigned + ///\ingroup type_traits + template struct is_unsigned : std::is_unsigned {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_unsigned_v = std::is_unsigned_v; +#endif + + //*************************************************************************** + /// is_floating_point + ///\ingroup type_traits + template struct is_floating_point : std::is_floating_point {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_floating_point_v = std::is_floating_point_v; +#endif + + //*************************************************************************** + /// is_same + ///\ingroup type_traits + template struct is_same : std::is_same {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_same_v = std::is_same_v; +#endif + + //*************************************************************************** + /// is_void + ///\ingroup type_traits + template struct is_void : std::is_void {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_void_v = std::is_void_v; +#endif + + //*************************************************************************** + /// is_arithmetic + ///\ingroup type_traits + template struct is_arithmetic : std::is_arithmetic {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_arithmetic_v = std::is_arithmetic_v; +#endif + + //*************************************************************************** + /// is_fundamental + ///\ingroup type_traits + template struct is_fundamental : std::is_fundamental {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_fundamental_v = std::is_fundamental_v; +#endif + + //*************************************************************************** + /// is_compound + ///\ingroup type_traits + template struct is_compound : std::is_compound {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_compound_v = std::is_compound_v; +#endif + + //*************************************************************************** + /// is_array + ///\ingroup type_traits + template struct is_array : std::is_array {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_array_v = std::is_array_v; +#endif + + //*************************************************************************** + /// is_pointer + ///\ingroup type_traits + template struct is_pointer : std::is_pointer {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pointer_v = std::is_pointer_v; +#endif + + //*************************************************************************** + /// is_reference + ///\ingroup type_traits + template struct is_reference : std::is_reference {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_reference_v = std::is_reference_v; +#endif + + //*************************************************************************** + /// is_lvalue_reference + ///\ingroup type_traits + template struct is_lvalue_reference : std::is_lvalue_reference {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_lvalue_reference_v = std::is_lvalue_reference_v; +#endif + + //*************************************************************************** + /// is_rvalue_reference + ///\ingroup type_traits +#if ETL_CPP11_SUPPORTED + template struct is_rvalue_reference : std::is_rvalue_reference {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_rvalue_reference_v = std::is_rvalue_reference_v; +#endif + + //*************************************************************************** + /// is_pod + ///\ingroup type_traits + template struct is_pod : std::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pod_v = std::is_pod_v; +#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 : 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 + + //*************************************************************************** + /// conditional + ///\ingroup type_traits + template struct conditional { typedef T type; }; + template struct conditional { typedef F type; }; + + //*************************************************************************** + /// make_signed + ///\ingroup type_traits + template struct make_signed : std::make_signed {}; + +#if ETL_CPP14_SUPPORTED + template + using make_signed_t = std::make_signed_t; +#endif + + //*************************************************************************** + /// make_unsigned + ///\ingroup type_traits + template struct make_unsigned : std::make_unsigned {}; + +#if ETL_CPP14_SUPPORTED + template + using make_unsigned_t = std::make_unsigned_t; +#endif + + //*************************************************************************** + /// enable_if + ///\ingroup type_traits + template struct enable_if : std::enable_if {}; + +#if ETL_CPP14_SUPPORTED + template + using enable_if_t = std::enable_if_t; +#endif + + //*************************************************************************** + /// extent + ///\ingroup type_traits + template + struct extent : std::extent {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t extent_v = std::extent_v; +#endif + + //*************************************************************************** + /// remove_extent + ///\ingroup type_traits + template struct remove_extent : std::remove_extent { }; + +#if ETL_CPP14_SUPPORTED + template + using remove_extent_t = std::remove_extent_t; +#endif + + //*************************************************************************** + /// remove_all_extents + ///\ingroup type_traits + template struct remove_all_extents : std::remove_all_extents { }; + +#if ETL_CPP14_SUPPORTED + template + using remove_all_extents_t = std::remove_all_extents_t; +#endif + + //*************************************************************************** + /// rank + ///\ingroup type_traits + template struct rank : std::rank {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t rank_v = std::rank_v; +#endif + + //*************************************************************************** + /// decay + ///\ingroup type_traits + template struct decay : std::decay {}; + +#if ETL_CPP14_SUPPORTED + template + using decay_t = std::decay_t; +#endif + + //*************************************************************************** + /// is_base_of + ///\ingroup type_traits + template struct is_base_of : std::is_base_of {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_base_of_v = std::is_base_of_v; +#endif + + //*************************************************************************** + /// add_lvalue_reference + template struct add_lvalue_reference : std::add_lvalue_reference {}; + +#if ETL_CPP14_SUPPORTED + template + using add_lvalue_reference_t = std::add_lvalue_reference_t; +#endif + + //*************************************************************************** + /// add_rvalue_reference +#if ETL_CPP11_SUPPORTED + template struct add_rvalue_reference : std::add_rvalue_reference {}; +#endif + +#if ETL_CPP14_SUPPORTED + template + using add_rvalue_reference_t = std::add_rvalue_reference_t; +#endif + + //*************************************************************************** + /// decval +#if ETL_CPP11_SUPPORTED + template + typename std::add_rvalue_reference::type declval() ETL_NOEXCEPT; +#endif + + //*************************************************************************** + /// is_convertible + ///\ingroup type_traits +#if ETL_CPP11_SUPPORTED + template + struct is_convertible : std::is_convertible {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_convertible_v = std::is_convertible_v; +#endif + + //*************************************************************************** + /// Alignment templates. + ///\ingroup type_traits + template struct alignment_of : std::alignment_of {}; + template <> struct alignment_of : std::integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t alignment_of_v = std::alignment_of_v; +#endif +} +#endif + +//*************************************************************************** +// ETL specific type traits. +//*************************************************************************** +namespace etl +{ + //*************************************************************************** + /// conditional_integral_constant + // /\ingroup type_traits + template + struct conditional_integral_constant; + + template + struct conditional_integral_constant + { + ETL_STATIC_ASSERT(etlstd::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"); + static const T value = FALSE_VALUE; + }; + #if ETL_CPP11_SUPPORTED - - //***************************************************************************" + //*************************************************************************** /// Template to determine if a type is one of a specified list. ///\ingroup types - //***************************************************************************" template struct is_one_of { - static const bool value = etl::is_same::value || - etl::is_one_of::value; + static const bool value = etlstd::is_same::value || + etl::is_one_of::value; }; template struct is_one_of { - static const bool value = etl::is_same::value; + static const bool value = etlstd::is_same::value; }; #else @@ -536,7 +1330,6 @@ namespace etl cog.outl("//***************************************************************************") cog.outl("/// Template to determine if a type is one of a specified list.") cog.outl("///\ingroup types") - cog.outl("//***************************************************************************") cog.outl("template ::value ||" % n) - cog.outl(" etl::is_same::value;" % IsOneOf) + cog.outl(" etlstd::is_same::value ||" % n) + cog.outl(" etlstd::is_same::value;" % IsOneOf) cog.outl("};") ]]]*/ /*[[[end]]]*/ #endif +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_one_of_v = etl::is_one_of::value; +#endif + //*************************************************************************** - // A set of templates to allow related types to be derived. - //*************************************************************************** + /// A set of templates to allow related types to be derived. + ///\ingroup types + // Default. template struct types { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -585,7 +1384,7 @@ namespace etl { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -603,7 +1402,7 @@ namespace etl { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -621,7 +1420,7 @@ namespace etl { private: - typedef typename etl::remove_cv::type type_t; + typedef typename etlstd::remove_cv::type type_t; public: @@ -633,22 +1432,57 @@ namespace etl typedef const type_t* const const_pointer_const; }; - //*************************************************************************** - // size_of - //*************************************************************************** #if ETL_CPP11_SUPPORTED + // rvalue References. template - constexpr size_t size_of() + struct types { - return sizeof(T); - } + private: - template <> - constexpr size_t size_of() - { - return 1; - } + typedef typename etlstd::remove_cv::type type_t; + + public: + + typedef type_t type; + typedef type_t& reference; + typedef const type_t& const_reference; + typedef type_t* pointer; + typedef const type_t* const_pointer; + typedef const type_t* const const_pointer_const; + }; +#endif + +#if ETL_CPP14_SUPPORTED + template + using types_t = typename types::type; + + template + using types_r = typename types::reference; + + template + using types_cr = typename types::const_reference; + + template + using types_p = typename types::pointer; + + template + using types_cp = typename types::const_pointer; + + template + using types_cpc = typename types::const_pointer_const; +#endif + + //*************************************************************************** + /// size_of + ///\ingroup types + template struct size_of : etlstd::integral_constant {}; + template <> struct size_of : etlstd::integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t size_of_v = etl::size_of::value; #endif } + #endif diff --git a/include/etl/u16string.h b/include/etl/u16string.h index c571ebab..4da9ff67 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_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::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 8e152ae8..4606fe21 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_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::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 8f27ffaf..701f7b12 100644 --- a/include/etl/unordered_map.h +++ b/include/etl/unordered_map.h @@ -37,10 +37,10 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" #include "container.h" #include "pool.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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::equal_to > class iunordered_map { public: @@ -172,7 +172,7 @@ namespace etl typedef typename bucket_t::const_iterator local_const_iterator; //********************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -332,7 +332,7 @@ namespace etl }; //********************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -482,7 +482,7 @@ namespace etl local_iterator inode; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etlstd::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 = ETL_STD::distance(first_, last_); + difference_type d = etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::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 7a4edc26..1951e5f0 100644 --- a/include/etl/unordered_multimap.h +++ b/include/etl/unordered_multimap.h @@ -37,10 +37,10 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" #include "container.h" #include "pool.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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::equal_to > class iunordered_multimap { public: @@ -171,7 +171,7 @@ namespace etl typedef typename bucket_t::const_iterator local_const_iterator; //********************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -331,7 +331,7 @@ namespace etl }; //********************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -482,7 +482,7 @@ namespace etl local_iterator inode; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etlstd::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 = ETL_STD::distance(first_, last_); + difference_type d = etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::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 3b634a7b..b7c58585 100644 --- a/include/etl/unordered_multiset.h +++ b/include/etl/unordered_multiset.h @@ -37,10 +37,10 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" #include "container.h" #include "pool.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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::equal_to > class iunordered_multiset { public: @@ -168,7 +168,7 @@ namespace etl typedef typename bucket_t::const_iterator local_const_iterator; //********************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -327,7 +327,7 @@ namespace etl }; //********************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -477,7 +477,7 @@ namespace etl local_iterator inode; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etlstd::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 = ETL_STD::distance(first_, last_); + difference_type d = etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::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 1babd690..c545adfb 100644 --- a/include/etl/unordered_set.h +++ b/include/etl/unordered_set.h @@ -37,10 +37,10 @@ SOFTWARE. #include "platform.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" -#include "stl/utility.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" #include "container.h" #include "pool.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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::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 ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::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 ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etlstd::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 = ETL_STD::distance(first_, last_); + difference_type d = etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 = ETL_STD::equal_to > + template , typename TKeyEqual = etlstd::equal_to > class unordered_set : public etl::iunordered_set { private: diff --git a/include/etl/utility.h b/include/etl/utility.h index 1743c01c..ec357560 100644 --- a/include/etl/utility.h +++ b/include/etl/utility.h @@ -37,8 +37,128 @@ SOFTWARE. ///\defgroup utility utility ///\ingroup utilities -namespace etl +namespace etlstd { + //****************************************************************************** + template + struct pair + { + typedef T1 first_type; + typedef T2 second_type; + + T1 first; + T2 second; + + pair() + : first(T1()), + second(T2()) + { + } + + pair(const T1& a, const T2& b) + : first(a), + second(b) + { + } + + template + pair(const pair& other) + : first(other.first), + second(other.second) + { + } + + pair(const pair& other) + : first(other.first), + second(other.second) + { + } + + void swap(pair& other) + { + T1 temp1 = first; + T2 temp2 = second; + first = other.first; + second = other.second; + other.first = temp1; + other.second = temp2; + } + }; + + //****************************************************************************** + template + inline pair make_pair(T1 a, T2 b) + { + return pair(a, b); + } + + //****************************************************************************** + template + inline void swap(pair& a, pair& b) + { + a.swap(b); + } + + //****************************************************************************** + template + inline bool operator ==(const pair& a, const pair& b) + { + return (a.first == b.first) && (a.second == b.second); + } + + template + inline bool operator !=(const pair& a, const pair& b) + { + return !(a == b); + } + + template + inline bool operator <(const pair& a, const pair& b) + { + return (a.first < b.first) || + (!(b.first < a.first) && (a.second < b.second)); + } + + template + inline bool operator >(const pair& a, const pair& b) + { + return (b < a); + } + + template + inline bool operator <=(const pair& a, const pair& b) + { + return !(b < a); + } + + template + inline bool operator >=(const pair& a, const pair& b) + { + return !(a < b); + } + +#if ETL_CPP11_SUPPORTED + //****************************************************************************** + template + constexpr typename etlstd::remove_reference::type&& move(T&& t) noexcept + { + return static_cast::type&&>(t); + } + + //****************************************************************************** + template + constexpr T&& forward(typename etlstd::remove_reference::type& t) noexcept + { + return static_cast(t); + } + + template + constexpr T&& forward(typename etlstd::remove_reference::type&& t) noexcept + { + return static_cast(t); + } +#endif + //*************************************************************************** /// exchange (const) //*************************************************************************** @@ -54,7 +174,7 @@ namespace etl /// as_const //*************************************************************************** template - typename etl::add_const::type& as_const(T& t) + typename etlstd::add_const::type& as_const(T& t) { return t; } diff --git a/include/etl/variant.h b/include/etl/variant.h index dd84fc72..82f06e35 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 = 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 : + 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 : 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(ETL_STD::forward(args)...); + ::new (static_cast(data)) T(etlstd::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 f9823f6c..ae53934f 100644 --- a/include/etl/variant_pool.h +++ b/include/etl/variant_pool.h @@ -63,7 +63,7 @@ SOFTWARE. #include "type_lookup.h" #include "pool.h" -#include "stl/utility.h" +#include "utility.h" #undef ETL_FILE #define ETL_FILE "40" @@ -105,21 +105,21 @@ namespace etl //*************************************************************************** template class variant_pool { @@ -290,7 +290,7 @@ namespace etl if (p != nullptr) { - new (p) T(ETL_STD::forward(args)...); + new (p) T(etlstd::forward(args)...); } } @@ -305,22 +305,22 @@ namespace etl bool destroy(const T* const p) { ETL_STATIC_ASSERT((etl::is_one_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 || - etl::is_base_of::value), "Invalid type"); + 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"); p->~T(); diff --git a/include/etl/variant_pool_generator.h b/include/etl/variant_pool_generator.h index 47d305e7..d6f785e3 100644 --- a/include/etl/variant_pool_generator.h +++ b/include/etl/variant_pool_generator.h @@ -75,7 +75,7 @@ cog.outl("//******************************************************************** #include "type_lookup.h" #include "pool.h" -#include "stl/utility.h" +#include "utility.h" #undef ETL_FILE #define ETL_FILE "40" @@ -357,7 +357,7 @@ namespace etl if (p != nullptr) { - new (p) T(ETL_STD::forward(args)...); + new (p) T(ETL_OR_STD::forward(args)...); } } @@ -382,8 +382,8 @@ namespace etl cog.outl("T%s>::value ||" % int(NTypes)) for n in range(1, int(NTypes)): - cog.outl(" etl::is_base_of::value ||" % n) - cog.outl(" etl::is_base_of::value), \"Invalid type\");" % int(NTypes)) + cog.outl(" etlstd::is_base_of::value ||" % n) + cog.outl(" etlstd::is_base_of::value), \"Invalid type\");" % int(NTypes)) ]]]*/ /*[[[end]]]*/ diff --git a/include/etl/vector.h b/include/etl/vector.h index 4cc0f656..77d23d8a 100644 --- a/include/etl/vector.h +++ b/include/etl/vector.h @@ -51,9 +51,9 @@ SOFTWARE. #include "debug_count.h" #include "private/vector_base.h" -#include "stl/algorithm.h" -#include "stl/iterator.h" -#include "stl/functional.h" +#include "algorithm.h" +#include "iterator.h" +#include "functional.h" #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_NO_STL) #include @@ -92,10 +92,10 @@ namespace etl typedef const T* const_pointer; typedef T* iterator; typedef const T* const_iterator; - typedef ETL_STD::reverse_iterator reverse_iterator; - typedef ETL_STD::reverse_iterator const_reverse_iterator; + typedef ETL_OR_STD::reverse_iterator reverse_iterator; + typedef ETL_OR_STD::reverse_iterator const_reverse_iterator; typedef size_t size_type; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etlstd::iterator_traits::difference_type difference_type; protected: @@ -365,17 +365,17 @@ namespace etl template void assign(TIterator first, TIterator last) { - ETL_STATIC_ASSERT((etl::is_same::type, typename etl::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); + ETL_STATIC_ASSERT((etlstd::is_same::type, typename etlstd::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etlstd::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(ETL_STD::distance(first, last))) + ETL_ADD_DEBUG_COUNT(uint32_t(etlstd::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(ETL_STD::move(value)); + create_back(etlstd::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(ETL_STD::forward(args)...); + ::new (p_end) T(etlstd::forward(args)...); ++p_end; ETL_INCREMENT_DEBUG_COUNT } @@ -541,7 +541,7 @@ namespace etl else { create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etlstd::copy_backward(position, p_end - 2, p_end - 1); *position = value; } @@ -561,13 +561,13 @@ namespace etl if (position == end()) { - create_back(ETL_STD::move(value)); + create_back(etlstd::move(value)); } else { - create_back(ETL_STD::move(back())); - ETL_STD::move_backward(position, p_end - 2, p_end - 1); - *position = ETL_STD::move(value); + create_back(etlstd::move(back())); + etlstd::move_backward(position, p_end - 2, p_end - 1); + *position = etlstd::move(value); } return position; @@ -594,11 +594,11 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etlstd::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } - ::new (p) T(ETL_STD::forward(args)...); + ::new (p) T(etlstd::forward(args)...); return position; } @@ -619,7 +619,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etlstd::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -644,7 +644,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etlstd::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -669,7 +669,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etlstd::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -694,7 +694,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etlstd::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 = ETL_STD::distance(begin(), position); + size_t insert_begin = etlstd::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. - ETL_STD::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); + etlstd::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. - ETL_STD::fill_n(p_buffer + insert_begin, copy_new_n, value); + etlstd::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 = ETL_STD::distance(first, last); + size_t count = etlstd::distance(first, last); ETL_ASSERT((size() + count) <= CAPACITY, ETL_ERROR(vector_full)); size_t insert_n = count; - size_t insert_begin = ETL_STD::distance(begin(), position); + size_t insert_begin = etlstd::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. - ETL_STD::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); + etlstd::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) { - ETL_STD::copy(i_element + 1, end(), i_element); + etlstd::copy(i_element + 1, end(), i_element); destroy_back(); return i_element; @@ -843,8 +843,8 @@ namespace etl } else { - ETL_STD::copy(last, end(), first); - size_t n_delete = ETL_STD::distance(first, last); + etlstd::copy(last, end(), first); + size_t n_delete = etlstd::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(ETL_STD::move(*itr)); + push_back(etlstd::move(*itr)); ++itr; } @@ -952,7 +952,7 @@ namespace etl void initialise() { etl::destroy(p_buffer, p_end); - ETL_SUBTRACT_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::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(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::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(ETL_STD::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end))) } //************************************************************************* @@ -1018,7 +1018,7 @@ namespace etl //********************************************************************* inline void create_back(rvalue_reference value) { - etl::create_copy_at(p_end, ETL_STD::move(value)); + etl::create_copy_at(p_end, etlstd::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()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etlstd::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 ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etlstd::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(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -1262,7 +1262,7 @@ namespace etl typename etl::ivector::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::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(ETL_STD::move(*itr)); + this->push_back(etlstd::move(*itr)); ++itr; } @@ -1579,7 +1579,7 @@ namespace etl typename etl::ivector::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etlstd::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 ebe0c455..df0ac6d0 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_ = ETL_STD::min(length_, size() - position); + length_ = etlstd::min(length_, size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/test/codeblocks/ETL.cbp b/test/codeblocks/ETL.cbp index 7221311a..52a08930 100644 --- a/test/codeblocks/ETL.cbp +++ b/test/codeblocks/ETL.cbp @@ -361,7 +361,6 @@ - diff --git a/test/no_stl_test_iterators.h b/test/no_stl_test_iterators.h index 476ed842..49d54c56 100644 --- a/test/no_stl_test_iterators.h +++ b/test/no_stl_test_iterators.h @@ -34,10 +34,10 @@ SOFTWARE. #include "etl/platform.h" #include "etl/iterator.h" -#include "etl/stl/iterator.h" +#include "etl/iterator.h" template -struct non_random_iterator : public etl::iterator +struct non_random_iterator : public etl::iterator { non_random_iterator() : ptr(nullptr) @@ -116,7 +116,7 @@ bool operator !=(const non_random_iterator& lhs, const non_random_iterator } template -struct random_iterator : public etl::iterator +struct random_iterator : public etl::iterator { random_iterator() : ptr(nullptr) diff --git a/test/test_algorithm.cpp b/test/test_algorithm.cpp index d0301308..e73fc4fb 100644 --- a/test/test_algorithm.cpp +++ b/test/test_algorithm.cpp @@ -88,7 +88,7 @@ namespace TEST(minmax_element) { ETL_PAIR expected = std::minmax_element(data.begin(), data.end()); - ETL_PAIR result = etl::minmax_element(data.begin(), data.end()); + ETL_PAIR result = etlstd::minmax_element(data.begin(), data.end()); CHECK_EQUAL(std::distance(data.begin(), expected.first), std::distance(data.begin(), result.first)); CHECK_EQUAL(std::distance(data.begin(), expected.second), std::distance(data.begin(), result.second)); } @@ -97,7 +97,7 @@ namespace TEST(minmax_element_compare) { ETL_PAIR expected = std::minmax_element(data.begin(), data.end(), std::greater()); - ETL_PAIR result = etl::minmax_element(data.begin(), data.end(), std::greater()); + ETL_PAIR result = etlstd::minmax_element(data.begin(), data.end(), std::greater()); CHECK_EQUAL(std::distance(data.begin(), expected.first), std::distance(data.begin(), result.first)); CHECK_EQUAL(std::distance(data.begin(), expected.second), std::distance(data.begin(), result.second)); } @@ -109,11 +109,11 @@ namespace int b = 2; ETL_PAIR expected = std::minmax(a, b); - ETL_PAIR result = etl::minmax(a, b); + ETL_PAIR result = etlstd::minmax(a, b); CHECK_EQUAL(expected.first, result.first); CHECK_EQUAL(expected.second, result.second); - result = etl::minmax(b, a); + result = etlstd::minmax(b, a); expected = std::minmax(b, a); CHECK_EQUAL(expected.first, result.first); CHECK_EQUAL(expected.second, result.second); @@ -126,11 +126,11 @@ namespace int b = 2; ETL_PAIR expected = std::minmax(a, b, std::greater()); - ETL_PAIR result = etl::minmax(a, b, std::greater()); + ETL_PAIR result = etlstd::minmax(a, b, std::greater()); CHECK_EQUAL(expected.first, result.first); CHECK_EQUAL(expected.second, result.second); - result = etl::minmax(b, a, std::greater()); + result = etlstd::minmax(b, a, std::greater()); expected = std::minmax(b, a, std::greater()); CHECK_EQUAL(expected.first, result.first); CHECK_EQUAL(expected.second, result.second); @@ -142,7 +142,7 @@ namespace int data[] = { 1, 2, 3, 4, 6, 5, 7, 8, 9, 10 }; int* p1 = std::is_sorted_until(std::begin(data), std::end(data)); - int* p2 = etl::is_sorted_until(std::begin(data), std::end(data)); + int* p2 = etlstd::is_sorted_until(std::begin(data), std::end(data)); CHECK_EQUAL(std::distance(std::begin(data), p1), std::distance(std::begin(data), p2)); } @@ -152,7 +152,7 @@ namespace int data[] = { 10, 9, 8, 7, 5, 6, 4, 3, 4, 2, 1 }; int* p1 = std::is_sorted_until(std::begin(data), std::end(data), std::greater()); - int* p2 = etl::is_sorted_until(std::begin(data), std::end(data), std::greater()); + int* p2 = etlstd::is_sorted_until(std::begin(data), std::end(data), std::greater()); CHECK_EQUAL(std::distance(etl::begin(data), p1), std::distance(std::begin(data), p2)); } @@ -161,12 +161,12 @@ namespace { int data1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; - bool is_sorted = etl::is_sorted(std::begin(data1), std::end(data1)); + bool is_sorted = etlstd::is_sorted(std::begin(data1), std::end(data1)); CHECK(is_sorted); int data2[] = { 1, 2, 3, 4, 6, 5, 7, 8 , 9, 10}; - is_sorted = etl::is_sorted(std::begin(data2), std::end(data2)); + is_sorted = etlstd::is_sorted(std::begin(data2), std::end(data2)); CHECK(!is_sorted); } @@ -175,12 +175,12 @@ namespace { int data1[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; - bool is_sorted = etl::is_sorted(std::begin(data1), std::end(data1), std::greater()); + bool is_sorted = etlstd::is_sorted(std::begin(data1), std::end(data1), std::greater()); CHECK(is_sorted); int data2[] = { 10, 9, 8, 7, 5, 6, 4, 3, 2, 1 }; - is_sorted = etl::is_sorted(std::begin(data2), std::end(data2), std::greater()); + is_sorted = etlstd::is_sorted(std::begin(data2), std::end(data2), std::greater()); CHECK(!is_sorted); } @@ -268,7 +268,7 @@ namespace int* result; std::copy_n(std::begin(data1), 4, std::begin(data2)); - result = etl::copy_n(std::begin(data1), 4, std::begin(data3)); + result = etlstd::copy_n(std::begin(data1), 4, std::begin(data3)); CHECK_EQUAL(std::begin(data3) + 4, result); @@ -286,7 +286,7 @@ namespace int* result; std::copy_n(std::begin(data1), 4, std::begin(data2)); - result = etl::copy_n(std::begin(data1), 4, std::begin(data3)); + result = etlstd::copy_n(std::begin(data1), 4, std::begin(data3)); CHECK_EQUAL(std::begin(data3) + 4, result); @@ -375,7 +375,7 @@ namespace // Copy everything less than 5. std::copy_if(std::begin(data1), std::end(data1), std::begin(data2), std::bind(std::less(), std::placeholders::_1, 5)); - etl::copy_if(std::begin(data1), std::end(data1), std::begin(data3), std::bind(std::less(), std::placeholders::_1, 5)); + etlstd::copy_if(std::begin(data1), std::end(data1), std::begin(data3), std::bind(std::less(), std::placeholders::_1, 5)); bool is_same = std::equal(std::begin(data2), std::end(data2), std::begin(data3)); CHECK(is_same); @@ -446,11 +446,11 @@ namespace int data1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; bool expected = std::any_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); - bool result = etl::any_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); + bool result = etlstd::any_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); CHECK_EQUAL(expected, result); expected = std::any_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); - result = etl::any_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); + result = etlstd::any_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); CHECK_EQUAL(expected, result); } @@ -460,11 +460,11 @@ namespace int data1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; bool expected = std::all_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); - bool result = etl::all_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); + bool result = etlstd::all_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); CHECK_EQUAL(expected, result); expected = std::all_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); - result = etl::all_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); + result = etlstd::all_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); CHECK_EQUAL(expected, result); } @@ -474,11 +474,11 @@ namespace int data1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; bool expected = std::none_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 8)); - bool result = etl::none_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 8)); + bool result = etlstd::none_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 8)); CHECK_EQUAL(expected, result); expected = std::none_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); - result = etl::none_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); + result = etlstd::none_of(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); CHECK_EQUAL(expected, result); } @@ -497,28 +497,28 @@ namespace int permutation[] = { 1, 3, 2, 4, 7, 6, 5, 8 }; int not_permutation[] = { 1, 2, 3, 4, 5, 6, 7, 7 }; - bool is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation)); + bool is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation)); CHECK(is_permutation); - is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation)); + is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation)); CHECK(!is_permutation); - is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation), std::equal_to()); + is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation), std::equal_to()); CHECK(is_permutation); - is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation), std::equal_to()); + is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation), std::equal_to()); CHECK(!is_permutation); - is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation), std::end(permutation)); + is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation), std::end(permutation)); CHECK(is_permutation); - is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation), std::end(not_permutation)); + is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation), std::end(not_permutation)); CHECK(!is_permutation); - is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation), std::end(permutation), std::equal_to()); + is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(permutation), std::end(permutation), std::equal_to()); CHECK(is_permutation); - is_permutation = etl::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation), std::end(not_permutation), std::equal_to()); + is_permutation = etlstd::is_permutation(std::begin(data1), std::end(data1), std::begin(not_permutation), std::end(not_permutation), std::equal_to()); CHECK(!is_permutation); } @@ -528,13 +528,13 @@ namespace int data1[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; bool expected = std::is_partitioned(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); - bool result = etl::is_partitioned(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); + bool result = etlstd::is_partitioned(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); CHECK_EQUAL(expected, result); std::partition(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); expected = std::is_partitioned(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); - result = etl::is_partitioned(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); + result = etlstd::is_partitioned(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); CHECK_EQUAL(expected, result); } @@ -546,13 +546,13 @@ namespace std::partition(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); int* partition1 = std::partition_point(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); - int* partition2 = etl::partition_point(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); + int* partition2 = etlstd::partition_point(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 4)); CHECK_EQUAL(std::distance(std::begin(data1), partition1), std::distance(std::begin(data1), partition2)); std::partition(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 8)); partition1 = std::partition_point(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); - partition2 = etl::partition_point(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); + partition2 = etlstd::partition_point(std::begin(data1), std::end(data1), std::bind(std::greater(), std::placeholders::_1, 0)); CHECK_EQUAL(std::distance(std::begin(data1), partition1), std::distance(std::begin(data1), partition2)); } @@ -566,7 +566,7 @@ namespace int data5[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; std::partition_copy(std::begin(data1), std::end(data1), std::begin(data2), std::begin(data3), std::bind(std::greater(), std::placeholders::_1, 4)); - etl::partition_copy(std::begin(data1), std::end(data1), std::begin(data4), std::begin(data5), std::bind(std::greater(), std::placeholders::_1, 4)); + etlstd::partition_copy(std::begin(data1), std::end(data1), std::begin(data4), std::begin(data5), std::bind(std::greater(), std::placeholders::_1, 4)); bool are_equal; @@ -583,7 +583,7 @@ namespace int data1[] = { 1, 2, 3, 5, 6, 7, 8 }; // Find the element not less than 4. - int* p = etl::find_if_not(std::begin(data1), std::end(data1), std::bind(std::less(), std::placeholders::_1, 4)); + int* p = etlstd::find_if_not(std::begin(data1), std::end(data1), std::bind(std::less(), std::placeholders::_1, 4)); CHECK_EQUAL(5, *p); } @@ -693,7 +693,7 @@ namespace int compare[] = { 2, 16, 4, 14, 6, 0, 0, 0, 0, 0 }; // Double everything and copy to output. - etl::transform(std::begin(input), + etlstd::transform(std::begin(input), std::end(input), std::begin(output), std::begin(output) + (etl::size(output) / 2), @@ -704,7 +704,7 @@ namespace std::fill(std::begin(output), std::end(output), 0); - etl::transform(std::begin(input), + etlstd::transform(std::begin(input), std::begin(input) + (etl::size(input) / 2), std::begin(output), std::end(output), diff --git a/test/test_alignment.cpp b/test/test_alignment.cpp index 7a03a248..3d069a1e 100644 --- a/test/test_alignment.cpp +++ b/test/test_alignment.cpp @@ -50,10 +50,10 @@ namespace size_t alignment; size_t expected; - typedef etl::aligned_storage::value>::type storage32_t; + typedef etl::aligned_storage::value>::type storage32_t; static storage32_t data32[10]; - alignment = etl::alignment_of::value; + alignment = etlstd::alignment_of::value; expected = std::alignment_of::value; CHECK_EQUAL(expected, alignment); @@ -70,7 +70,7 @@ namespace //************************************************************************* TEST(test_aligned_storage_conversion_operators) { - typedef etl::aligned_storage::value>::type storage32_t; + typedef etl::aligned_storage::value>::type storage32_t; static storage32_t data; void* pdata = &data.data; @@ -105,7 +105,7 @@ namespace typedef etl::aligned_storage_as::type storage32_t; static storage32_t data32[10]; - alignment = etl::alignment_of::value; + alignment = etlstd::alignment_of::value; expected = std::alignment_of::value; CHECK_EQUAL(expected, alignment); diff --git a/test/test_binary.cpp b/test/test_binary.cpp index 6c11fcfe..304ca419 100644 --- a/test/test_binary.cpp +++ b/test/test_binary.cpp @@ -939,71 +939,71 @@ namespace CHECK_EQUAL(18446744073709551615U, etl::max_value_for_nbits<64>::value); // Check that the value types are correct. - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); - CHECK((std::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); + CHECK((etlstd::is_same::value_type>::value)); } //************************************************************************* diff --git a/test/test_constant.cpp b/test/test_constant.cpp index 4f18979d..6ce02f35 100644 --- a/test/test_constant.cpp +++ b/test/test_constant.cpp @@ -51,15 +51,15 @@ namespace CHECK_EQUAL((char)etl::integral_limits::max, c1.value); CHECK_EQUAL((char)etl::integral_limits::max, C1::value); - CHECK((std::is_same::value)); + CHECK((etlstd::is_same::value)); CHECK_EQUAL((uint32_t)etl::integral_limits::max, c2.value); CHECK_EQUAL((uint32_t)etl::integral_limits::max, C2::value); - CHECK((std::is_same::value)); + CHECK((etlstd::is_same::value)); CHECK_EQUAL((int64_t)etl::integral_limits::max, c3.value); CHECK_EQUAL((int64_t)etl::integral_limits::max, C3::value); - CHECK((std::is_same::value)); + CHECK((etlstd::is_same::value)); } }; } diff --git a/test/test_iterator.cpp b/test/test_iterator.cpp index 59f652e8..0c3d6492 100644 --- a/test/test_iterator.cpp +++ b/test/test_iterator.cpp @@ -32,27 +32,27 @@ SOFTWARE. namespace { - struct input : public etl::iterator + struct input : public etl::iterator { }; - struct output : public etl::iterator + struct output : public etl::iterator { }; - struct forward : public etl::iterator + struct forward : public etl::iterator { }; - struct bidirectional : public etl::iterator + struct bidirectional : public etl::iterator { }; - struct random : public etl::iterator + struct random : public etl::iterator { }; diff --git a/test/test_largest.cpp b/test/test_largest.cpp index 932015f6..f9638bae 100644 --- a/test/test_largest.cpp +++ b/test/test_largest.cpp @@ -43,13 +43,13 @@ namespace bool type; size = etl::largest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(int), size); CHECK(type); size = etl::largest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(int), size); CHECK(type); @@ -66,13 +66,13 @@ namespace struct S3 { int a; short b; char c; }; size = etl::largest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(S3), size); CHECK(type); size = etl::largest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(S3), size); CHECK(type); @@ -101,43 +101,43 @@ namespace //************************************************************************* TEST(test_larger_int_type) { - CHECK(bool(std::is_same::type, int16_t>::value)); - CHECK(bool(std::is_same::type, int32_t>::value)); - CHECK(bool(std::is_same::type, int64_t>::value)); - CHECK(bool(std::is_same::type, int64_t>::value)); + CHECK(bool(etlstd::is_same::type, int16_t>::value)); + CHECK(bool(etlstd::is_same::type, int32_t>::value)); + CHECK(bool(etlstd::is_same::type, int64_t>::value)); + CHECK(bool(etlstd::is_same::type, int64_t>::value)); - CHECK(bool(std::is_same::type, int16_t>::value)); - CHECK(bool(std::is_same::type, int32_t>::value)); - CHECK(bool(std::is_same::type, int64_t>::value)); - CHECK(bool(std::is_same::type, int64_t>::value)); + CHECK(bool(etlstd::is_same::type, int16_t>::value)); + CHECK(bool(etlstd::is_same::type, int32_t>::value)); + CHECK(bool(etlstd::is_same::type, int64_t>::value)); + CHECK(bool(etlstd::is_same::type, int64_t>::value)); } //************************************************************************* TEST(test_larger_uint_type) { - CHECK(bool(std::is_same::type, uint16_t>::value)); - CHECK(bool(std::is_same::type, uint32_t>::value)); - CHECK(bool(std::is_same::type, uint64_t>::value)); - CHECK(bool(std::is_same::type, uint64_t>::value)); + CHECK(bool(etlstd::is_same::type, uint16_t>::value)); + CHECK(bool(etlstd::is_same::type, uint32_t>::value)); + CHECK(bool(etlstd::is_same::type, uint64_t>::value)); + CHECK(bool(etlstd::is_same::type, uint64_t>::value)); - CHECK(bool(std::is_same::type, uint16_t>::value)); - CHECK(bool(std::is_same::type, uint32_t>::value)); - CHECK(bool(std::is_same::type, uint64_t>::value)); - CHECK(bool(std::is_same::type, uint64_t>::value)); + CHECK(bool(etlstd::is_same::type, uint16_t>::value)); + CHECK(bool(etlstd::is_same::type, uint32_t>::value)); + CHECK(bool(etlstd::is_same::type, uint64_t>::value)); + CHECK(bool(etlstd::is_same::type, uint64_t>::value)); } //************************************************************************* TEST(test_larger_type) { - CHECK(bool(std::is_same::type, int16_t>::value)); - CHECK(bool(std::is_same::type, int32_t>::value)); - CHECK(bool(std::is_same::type, int64_t>::value)); - CHECK(bool(std::is_same::type, int64_t>::value)); + CHECK(bool(etlstd::is_same::type, int16_t>::value)); + CHECK(bool(etlstd::is_same::type, int32_t>::value)); + CHECK(bool(etlstd::is_same::type, int64_t>::value)); + CHECK(bool(etlstd::is_same::type, int64_t>::value)); - CHECK(bool(std::is_same::type, uint16_t>::value)); - CHECK(bool(std::is_same::type, uint32_t>::value)); - CHECK(bool(std::is_same::type, uint64_t>::value)); - CHECK(bool(std::is_same::type, uint64_t>::value)); + CHECK(bool(etlstd::is_same::type, uint16_t>::value)); + CHECK(bool(etlstd::is_same::type, uint32_t>::value)); + CHECK(bool(etlstd::is_same::type, uint64_t>::value)); + CHECK(bool(etlstd::is_same::type, uint64_t>::value)); } }; } diff --git a/test/test_no_stl_algorithm.cpp b/test/test_no_stl_algorithm.cpp index e9a1ae89..0bf610c2 100644 --- a/test/test_no_stl_algorithm.cpp +++ b/test/test_no_stl_algorithm.cpp @@ -31,8 +31,7 @@ SOFTWARE. #undef min #undef max -#include "etl/stl/algorithm.h" -#include "etl/stl/alternate/algorithm.h" +#include "etl/algorithm.h" #include #include @@ -520,7 +519,7 @@ namespace int a = 1; int b = 2; - etlstd::swap(a, b); + swap(a, b); CHECK_EQUAL(2, a); CHECK_EQUAL(1, b); } @@ -765,6 +764,26 @@ namespace CHECK(isEqual); } + //************************************************************************* + TEST(transform_safer) + { + struct Function + { + int operator()(int d) const + { + return d * 2; + } + }; + + int* p1 = std::transform(std::begin(dataS), std::end(dataS), std::begin(dataD1), Function()); + int* p2 = etl::transform(std::begin(dataS), std::end(dataS), std::begin(dataD2), std::end(dataD2), Function()); + + CHECK(p2 == std::end(dataD2)); + + bool isEqual = std::equal(std::begin(dataD1), std::end(dataD1), std::begin(dataD2)); + CHECK(isEqual); + } + //************************************************************************* TEST(transform2) { @@ -777,7 +796,7 @@ namespace }; int* p1 = std::transform(std::begin(dataS), std::end(dataS), std::begin(dataA), std::begin(dataD1), Function()); - int* p2 = etlstd::transform(std::begin(dataS), std::end(dataS), std::begin(dataA), std::begin(dataD2), Function()); + int* p2 = etl::transform(std::begin(dataS), std::end(dataS), std::begin(dataA), std::begin(dataD2), Function()); CHECK(p2 == std::end(dataD2)); diff --git a/test/test_no_stl_functional.cpp b/test/test_no_stl_functional.cpp index 8925f732..b7bbe998 100644 --- a/test/test_no_stl_functional.cpp +++ b/test/test_no_stl_functional.cpp @@ -31,8 +31,7 @@ SOFTWARE. #undef min #undef max -#include "etl/stl/functional.h" -#include "etl/stl/alternate/functional.h" +#include "etl/functional.h" namespace { @@ -42,7 +41,7 @@ namespace return TCompare()(a, b); } - struct test : etlstd::binary_function + struct test : etl::binary_function { bool operator()(int a, int b) const { @@ -63,25 +62,25 @@ namespace //************************************************************************* TEST(test_greater) { - CHECK(!(compare>(1, 2))); - CHECK((compare>(2, 1))); - CHECK(!(compare>(1, 1))); + CHECK(!(compare>(1, 2))); + CHECK((compare>(2, 1))); + CHECK(!(compare>(1, 1))); } //************************************************************************* TEST(test_equal_to) { - CHECK((compare>(1, 1))); - CHECK(!(compare>(1, 2))); - CHECK(!(compare>(2, 1))); + CHECK((compare>(1, 1))); + CHECK(!(compare>(1, 2))); + CHECK(!(compare>(2, 1))); } //************************************************************************* TEST(test_not_equal_to) { - CHECK(!(compare>(1, 1))); - CHECK((compare>(1, 2))); - CHECK((compare>(2, 1))); + CHECK(!(compare>(1, 1))); + CHECK((compare>(1, 2))); + CHECK((compare>(2, 1))); } //************************************************************************* @@ -94,8 +93,8 @@ namespace //************************************************************************* TEST(test_bind2nd) { - CHECK(!(etlstd::bind2nd(test(), 1)(2))); - CHECK((etlstd::bind2nd(test(), 2)(1))); + CHECK(!(etl::bind2nd(test(), 1)(2))); + CHECK((etl::bind2nd(test(), 2)(1))); } }; } diff --git a/test/test_no_stl_iterator.cpp b/test/test_no_stl_iterator.cpp index b96d1f0b..8c209de5 100644 --- a/test/test_no_stl_iterator.cpp +++ b/test/test_no_stl_iterator.cpp @@ -31,8 +31,7 @@ SOFTWARE. #undef min #undef max -#include "etl/stl/iterator.h" -#include "etl/stl/alternate/iterator.h" +#include "etl/iterator.h" #include #include @@ -71,11 +70,11 @@ namespace non_random_iterator itr2 = std::begin(dataA); std::advance(itr1, 4); - etlstd::advance(itr2, 4); + etl::advance(itr2, 4); CHECK_EQUAL(*itr1, *itr2); std::advance(itr1, -3); - etlstd::advance(itr2, -3); + etl::advance(itr2, -3); CHECK_EQUAL(*itr1, *itr2); } @@ -86,11 +85,11 @@ namespace random_iterator itr2 = std::begin(dataA); std::advance(itr1, 4); - etlstd::advance(itr2, 4); + etl::advance(itr2, 4); CHECK_EQUAL(*itr1, *itr2); std::advance(itr1, -3); - etlstd::advance(itr2, -3); + etl::advance(itr2, -3); CHECK_EQUAL(*itr1, *itr2); } @@ -105,7 +104,7 @@ namespace for (size_t i = 1; i <= length; ++i) { - CHECK_EQUAL(data[length - i], *etlstd::prev(itr, i)); + CHECK_EQUAL(data[length - i], *etl::prev(itr, i)); } } @@ -120,7 +119,7 @@ namespace for (size_t i = 1; i <= length; ++i) { - CHECK_EQUAL(data[i], *etlstd::next(itr, i)); + CHECK_EQUAL(data[i], *etl::next(itr, i)); } } @@ -130,34 +129,34 @@ namespace int data[] = { 1, 2, 3, 4, 5, 6, 7 }; std::reverse_iterator sri(&data[7]); - etlstd::reverse_iterator eri(&data[7]); + etl::reverse_iterator eri(&data[7]); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); - CHECK(etlstd::reverse_iterator(&data[5]) < eri); - CHECK(etlstd::reverse_iterator(&data[3]) > eri); - CHECK(etlstd::reverse_iterator(&data[4]) <= eri); - CHECK(etlstd::reverse_iterator(&data[5]) <= eri); - CHECK(etlstd::reverse_iterator(&data[4]) >= eri); - CHECK(etlstd::reverse_iterator(&data[3]) >= eri); + CHECK(etl::reverse_iterator(&data[5]) < eri); + CHECK(etl::reverse_iterator(&data[3]) > eri); + CHECK(etl::reverse_iterator(&data[4]) <= eri); + CHECK(etl::reverse_iterator(&data[5]) <= eri); + CHECK(etl::reverse_iterator(&data[4]) >= eri); + CHECK(etl::reverse_iterator(&data[3]) >= eri); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri, *eri); - CHECK(etlstd::reverse_iterator(&data[1]) == eri); - CHECK(etlstd::reverse_iterator(&data[2]) != eri); - CHECK(etlstd::reverse_iterator(&data[3]) != eri); - CHECK(etlstd::reverse_iterator(&data[4]) != eri); - CHECK(etlstd::reverse_iterator(&data[5]) != eri); - CHECK(etlstd::reverse_iterator(&data[6]) != eri); - CHECK(etlstd::reverse_iterator(&data[7]) != eri); + CHECK(etl::reverse_iterator(&data[1]) == eri); + CHECK(etl::reverse_iterator(&data[2]) != eri); + CHECK(etl::reverse_iterator(&data[3]) != eri); + CHECK(etl::reverse_iterator(&data[4]) != eri); + CHECK(etl::reverse_iterator(&data[5]) != eri); + CHECK(etl::reverse_iterator(&data[6]) != eri); + CHECK(etl::reverse_iterator(&data[7]) != eri); sri = std::reverse_iterator(&data[7]); - eri = etlstd::reverse_iterator(&data[7]); + eri = etl::reverse_iterator(&data[7]); CHECK_EQUAL(sri[0], eri[0]); CHECK_EQUAL(sri[1], eri[1]); CHECK_EQUAL(sri[2], eri[2]); @@ -175,7 +174,7 @@ namespace CHECK_EQUAL(*sri, *eri); std::reverse_iterator sri2 = sri + 3; - etlstd::reverse_iterator eri2 = eri + 3; + etl::reverse_iterator eri2 = eri + 3; CHECK_EQUAL(*sri, *eri); sri2 = sri - 3; @@ -189,34 +188,34 @@ namespace const int data[] = { 1, 2, 3, 4, 5, 6, 7 }; std::reverse_iterator sri(&data[7]); - etlstd::reverse_iterator eri(&data[7]); + etl::reverse_iterator eri(&data[7]); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); - CHECK(etlstd::reverse_iterator(&data[5]) < eri); - CHECK(etlstd::reverse_iterator(&data[3]) > eri); - CHECK(etlstd::reverse_iterator(&data[4]) <= eri); - CHECK(etlstd::reverse_iterator(&data[5]) <= eri); - CHECK(etlstd::reverse_iterator(&data[4]) >= eri); - CHECK(etlstd::reverse_iterator(&data[3]) >= eri); + CHECK(etl::reverse_iterator(&data[5]) < eri); + CHECK(etl::reverse_iterator(&data[3]) > eri); + CHECK(etl::reverse_iterator(&data[4]) <= eri); + CHECK(etl::reverse_iterator(&data[5]) <= eri); + CHECK(etl::reverse_iterator(&data[4]) >= eri); + CHECK(etl::reverse_iterator(&data[3]) >= eri); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri++, *eri++); CHECK_EQUAL(*sri, *eri); - CHECK(etlstd::reverse_iterator(&data[1]) == eri); - CHECK(etlstd::reverse_iterator(&data[2]) != eri); - CHECK(etlstd::reverse_iterator(&data[3]) != eri); - CHECK(etlstd::reverse_iterator(&data[4]) != eri); - CHECK(etlstd::reverse_iterator(&data[5]) != eri); - CHECK(etlstd::reverse_iterator(&data[6]) != eri); - CHECK(etlstd::reverse_iterator(&data[7]) != eri); + CHECK(etl::reverse_iterator(&data[1]) == eri); + CHECK(etl::reverse_iterator(&data[2]) != eri); + CHECK(etl::reverse_iterator(&data[3]) != eri); + CHECK(etl::reverse_iterator(&data[4]) != eri); + CHECK(etl::reverse_iterator(&data[5]) != eri); + CHECK(etl::reverse_iterator(&data[6]) != eri); + CHECK(etl::reverse_iterator(&data[7]) != eri); sri = std::reverse_iterator(&data[7]); - eri = etlstd::reverse_iterator(&data[7]); + eri = etl::reverse_iterator(&data[7]); CHECK_EQUAL(sri[0], eri[0]); CHECK_EQUAL(sri[1], eri[1]); CHECK_EQUAL(sri[2], eri[2]); @@ -242,7 +241,7 @@ namespace CHECK_EQUAL(*sri, *eri); std::reverse_iterator sri2 = sri + 3; - etlstd::reverse_iterator eri2 = eri + 3; + etl::reverse_iterator eri2 = eri + 3; CHECK_EQUAL(*sri, *eri); sri2 = sri - 3; diff --git a/test/test_no_stl_limits.cpp b/test/test_no_stl_limits.cpp index 21df7ce4..4924024f 100644 --- a/test/test_no_stl_limits.cpp +++ b/test/test_no_stl_limits.cpp @@ -28,8 +28,7 @@ SOFTWARE. #include "UnitTest++.h" -#include "etl/stl/alternate/limits.h" - +#include "etl/limits.h" #include namespace @@ -39,724 +38,724 @@ namespace //************************************************************************* TEST(test_bool) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(STD::is_modulo, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(STD_NL::is_modulo, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_char) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_unsigned_char) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(true, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(true, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_signed_char) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_char16_t) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(true, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_char32_t) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(true, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_wchar_t) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(STD::is_modulo, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(STD_NL::is_modulo, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_short) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_unsigned_short) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(true, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(true, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_int) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_unsigned_int) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(true, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(true, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_long) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_unsigned_long) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(true, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(true, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_long_long) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_unsigned_long_long) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(STD::has_denorm_loss, ETL::has_denorm_loss); - CHECK_EQUAL(STD::has_infinity, ETL::has_infinity); - CHECK_EQUAL(STD::has_quiet_NaN, ETL::has_quiet_NaN); - CHECK_EQUAL(STD::has_signaling_NaN, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::infinity(), ETL::infinity()); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(true, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - CHECK_EQUAL(STD::tinyness_before, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(STD_NL::has_denorm_loss, ETL_NL::has_denorm_loss); + CHECK_EQUAL(STD_NL::has_infinity, ETL_NL::has_infinity); + CHECK_EQUAL(STD_NL::has_quiet_NaN, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(STD_NL::has_signaling_NaN, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(true, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + CHECK_EQUAL(STD_NL::tinyness_before, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); } //************************************************************************* TEST(test_float) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(true, ETL::has_denorm_loss); - CHECK_EQUAL(false, ETL::has_infinity); - CHECK_EQUAL(false, ETL::has_quiet_NaN); - CHECK_EQUAL(false, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(true, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(true, ETL_NL::has_denorm_loss); + CHECK_EQUAL(false, ETL_NL::has_infinity); + CHECK_EQUAL(false, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(false, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(true, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); - // CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - // CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - // CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - // CHECK_EQUAL(STD::infinity(), ETL::infinity()); + // CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + // CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + // CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + // CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); } //************************************************************************* TEST(test_double) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(true, ETL::has_denorm_loss); - CHECK_EQUAL(false, ETL::has_infinity); - CHECK_EQUAL(false, ETL::has_quiet_NaN); - CHECK_EQUAL(false, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(true, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(true, ETL_NL::has_denorm_loss); + CHECK_EQUAL(false, ETL_NL::has_infinity); + CHECK_EQUAL(false, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(false, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(true, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); - // CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - // CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - // CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - // CHECK_EQUAL(STD::infinity(), ETL::infinity()); + // CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + // CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + // CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + // CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); } //************************************************************************* TEST(test_long_double) { - typedef etlstd::numeric_limits ETL; - typedef std::numeric_limits STD; + typedef etlstd::numeric_limits ETL_NL; + typedef std::numeric_limits STD_NL; - CHECK_EQUAL(STD::digits, ETL::digits); - CHECK_EQUAL(STD::digits10, ETL::digits10); - CHECK_EQUAL(STD::epsilon(), ETL::epsilon()); - CHECK_EQUAL(int(STD::has_denorm), int(ETL::has_denorm)); - CHECK_EQUAL(true, ETL::has_denorm_loss); - CHECK_EQUAL(false, ETL::has_infinity); - CHECK_EQUAL(false, ETL::has_quiet_NaN); - CHECK_EQUAL(false, ETL::has_signaling_NaN); - CHECK_EQUAL(STD::is_bounded, ETL::is_bounded); - CHECK_EQUAL(STD::is_exact, ETL::is_exact); - CHECK_EQUAL(STD::is_iec559, ETL::is_iec559); - CHECK_EQUAL(STD::is_integer, ETL::is_integer); - CHECK_EQUAL(false, ETL::is_modulo); - CHECK_EQUAL(STD::is_signed, ETL::is_signed); - CHECK_EQUAL(STD::is_specialized, ETL::is_specialized); - CHECK_EQUAL(STD::lowest(), ETL::lowest()); - CHECK_EQUAL(STD::max(), ETL::max()); - CHECK_EQUAL(STD::max_digits10, ETL::max_digits10); - CHECK_EQUAL(STD::max_exponent, ETL::max_exponent); - CHECK_EQUAL(STD::max_exponent10, ETL::max_exponent10); - CHECK_EQUAL(STD::min(), ETL::min()); - CHECK_EQUAL(STD::min_exponent, ETL::min_exponent); - CHECK_EQUAL(STD::min_exponent10, ETL::min_exponent10); - CHECK_EQUAL(STD::radix, ETL::radix); - CHECK_EQUAL(STD::round_error(), ETL::round_error()); - CHECK_EQUAL(int(STD::round_style), int(ETL::round_style)); - CHECK_EQUAL(true, ETL::tinyness_before); - CHECK_EQUAL(false, ETL::traps); + CHECK_EQUAL(STD_NL::digits, ETL_NL::digits); + CHECK_EQUAL(STD_NL::digits10, ETL_NL::digits10); + CHECK_EQUAL(STD_NL::epsilon(), ETL_NL::epsilon()); + CHECK_EQUAL(int(STD_NL::has_denorm), int(ETL_NL::has_denorm)); + CHECK_EQUAL(true, ETL_NL::has_denorm_loss); + CHECK_EQUAL(false, ETL_NL::has_infinity); + CHECK_EQUAL(false, ETL_NL::has_quiet_NaN); + CHECK_EQUAL(false, ETL_NL::has_signaling_NaN); + CHECK_EQUAL(STD_NL::is_bounded, ETL_NL::is_bounded); + CHECK_EQUAL(STD_NL::is_exact, ETL_NL::is_exact); + CHECK_EQUAL(STD_NL::is_iec559, ETL_NL::is_iec559); + CHECK_EQUAL(STD_NL::is_integer, ETL_NL::is_integer); + CHECK_EQUAL(false, ETL_NL::is_modulo); + CHECK_EQUAL(STD_NL::is_signed, ETL_NL::is_signed); + CHECK_EQUAL(STD_NL::is_specialized, ETL_NL::is_specialized); + CHECK_EQUAL(STD_NL::lowest(), ETL_NL::lowest()); + CHECK_EQUAL(STD_NL::max(), ETL_NL::max()); + CHECK_EQUAL(STD_NL::max_digits10, ETL_NL::max_digits10); + CHECK_EQUAL(STD_NL::max_exponent, ETL_NL::max_exponent); + CHECK_EQUAL(STD_NL::max_exponent10, ETL_NL::max_exponent10); + CHECK_EQUAL(STD_NL::min(), ETL_NL::min()); + CHECK_EQUAL(STD_NL::min_exponent, ETL_NL::min_exponent); + CHECK_EQUAL(STD_NL::min_exponent10, ETL_NL::min_exponent10); + CHECK_EQUAL(STD_NL::radix, ETL_NL::radix); + CHECK_EQUAL(STD_NL::round_error(), ETL_NL::round_error()); + CHECK_EQUAL(int(STD_NL::round_style), int(ETL_NL::round_style)); + CHECK_EQUAL(true, ETL_NL::tinyness_before); + CHECK_EQUAL(false, ETL_NL::traps); - // CHECK_EQUAL(STD::denorm_min(), ETL::denorm_min()); - // CHECK_EQUAL(STD::signaling_NaN(), ETL::signaling_NaN()); - // CHECK_EQUAL(STD::quiet_NaN(), ETL::quiet_NaN()); - // CHECK_EQUAL(STD::infinity(), ETL::infinity()); + // CHECK_EQUAL(STD_NL::denorm_min(), ETL_NL::denorm_min()); + // CHECK_EQUAL(STD_NL::signaling_NaN(), ETL_NL::signaling_NaN()); + // CHECK_EQUAL(STD_NL::quiet_NaN(), ETL_NL::quiet_NaN()); + // CHECK_EQUAL(STD_NL::infinity(), ETL_NL::infinity()); } }; } diff --git a/test/test_no_stl_utility.cpp b/test/test_no_stl_utility.cpp index d4d10d67..00d30a9a 100644 --- a/test/test_no_stl_utility.cpp +++ b/test/test_no_stl_utility.cpp @@ -31,7 +31,7 @@ SOFTWARE. #undef min #undef max -#include "etl/stl/alternate/utility.h" +#include "etl/utility.h" namespace { @@ -40,7 +40,7 @@ namespace //************************************************************************* TEST(pair_default_construct) { - etlstd::pair p1; + etl::pair p1; CHECK_EQUAL(int(), p1.first); CHECK_EQUAL(double(), p1.second); @@ -49,7 +49,7 @@ namespace //************************************************************************* TEST(test_pair_construct) { - etlstd::pair p1(1, 2.3); + etl::pair p1(1, 2.3); CHECK_EQUAL(1, p1.first); CHECK_EQUAL(2.3, p1.second); @@ -58,8 +58,8 @@ namespace //************************************************************************* TEST(test_pair_copy_construct) { - etlstd::pair p1(1, 2.3); - etlstd::pair p2(p1); + etl::pair p1(1, 2.3); + etl::pair p2(p1); CHECK_EQUAL(p1.first, p2.first); CHECK_EQUAL(p1.second, p2.second); @@ -68,8 +68,8 @@ namespace //************************************************************************* TEST(test_pair_copy_construct_alternate) { - etlstd::pair p1(1, 2.3f); - etlstd::pair p2(p1); + etl::pair p1(1, 2.3f); + etl::pair p2(p1); CHECK_EQUAL(p1.first, p2.first); CHECK_EQUAL(p1.second, p2.second); @@ -78,9 +78,9 @@ namespace //************************************************************************* TEST(test_make_pair) { - etlstd::pair p1(1, 2.3); - etlstd::pair p2; - p2 = etlstd::make_pair(1, 2.3); + etl::pair p1(1, 2.3); + etl::pair p2; + p2 = etl::make_pair(1, 2.3); CHECK_EQUAL(p1.first, p2.first); CHECK_EQUAL(p1.second, p2.second); @@ -89,8 +89,8 @@ namespace //************************************************************************* TEST(test_pair_swap_member) { - etlstd::pair p1(1, 2.3); - etlstd::pair p2(2, 3.4); + etl::pair p1(1, 2.3); + etl::pair p2(2, 3.4); p1.swap(p2); @@ -104,10 +104,10 @@ namespace //************************************************************************* TEST(test_pair_swap_global) { - etlstd::pair p1(1, 2.3); - etlstd::pair p2(2, 3.4); + etl::pair p1(1, 2.3); + etl::pair p2(2, 3.4); - etlstd::swap(p1, p2); + swap(p1, p2); CHECK_EQUAL(2, p1.first); CHECK_EQUAL(3.4, p1.second); @@ -119,9 +119,9 @@ namespace //************************************************************************* TEST(test_pair_conditional) { - etlstd::pair p1(1, 2.3); - etlstd::pair p2(1, 2.3); - etlstd::pair p3(2, 3.4); + etl::pair p1(1, 2.3); + etl::pair p2(1, 2.3); + etl::pair p3(2, 3.4); CHECK(p1 == p2); CHECK(!(p1 == p3)); diff --git a/test/test_parameter_type.cpp b/test/test_parameter_type.cpp index f4c445ae..d71b853a 100644 --- a/test/test_parameter_type.cpp +++ b/test/test_parameter_type.cpp @@ -77,13 +77,13 @@ namespace { bool b; - b = !etl::is_reference::type>::value; + b = !etlstd::is_reference::type>::value; CHECK(b); - b = etl::is_reference::type>::value; + b = etlstd::is_reference::type>::value; CHECK(b); - b = !etl::is_reference::type>::value; + b = !etlstd::is_reference::type>::value; CHECK(b); } }; diff --git a/test/test_priority_queue.cpp b/test/test_priority_queue.cpp index cd988643..690c47cf 100644 --- a/test/test_priority_queue.cpp +++ b/test/test_priority_queue.cpp @@ -455,8 +455,8 @@ namespace etl::priority_queue priority_queue2; - etl::ipriority_queue, ETL_STD::less>& ipriority_queue1 = priority_queue1; - etl::ipriority_queue, ETL_STD::less>& ipriority_queue2 = priority_queue2; + etl::ipriority_queue, std::less>& ipriority_queue1 = priority_queue1; + etl::ipriority_queue, std::less>& ipriority_queue2 = priority_queue2; ipriority_queue2 = ipriority_queue1; diff --git a/test/test_smallest.cpp b/test/test_smallest.cpp index aa27cd45..b7a2837d 100644 --- a/test/test_smallest.cpp +++ b/test/test_smallest.cpp @@ -33,7 +33,7 @@ SOFTWARE. #include namespace -{ +{ SUITE(test_smallst) { //************************************************************************* @@ -43,13 +43,13 @@ namespace bool type; size = etl::smallest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(char), size); CHECK(type); size = etl::smallest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(char), size); CHECK(type); @@ -66,13 +66,13 @@ namespace struct S3 { int a; short b; char c; }; size = etl::smallest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(S1), size); CHECK(type); size = etl::smallest_type::size; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK_EQUAL(sizeof(S1), size); CHECK(type); @@ -83,40 +83,40 @@ namespace { bool type; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); } @@ -125,40 +125,40 @@ namespace { bool type; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); } @@ -167,28 +167,28 @@ namespace { bool type; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); } @@ -197,49 +197,49 @@ namespace { bool type; - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); - type = std::is_same::type>::value; + type = etlstd::is_same::type>::value; CHECK(type); } }; diff --git a/test/test_type_lookup.cpp b/test/test_type_lookup.cpp index 1d6a2015..fdad5378 100644 --- a/test/test_type_lookup.cpp +++ b/test/test_type_lookup.cpp @@ -117,41 +117,41 @@ namespace //************************************************************************* TEST(test_type_from_id_16) { - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); } //************************************************************************* TEST(test_type_from_id_8) { - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); } //************************************************************************* TEST(test_type_from_id_1) { - CHECK((std::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); } //************************************************************************* @@ -177,7 +177,7 @@ namespace CHECK_EQUAL((unsigned int)Type1::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type()); CHECK_EQUAL((unsigned int)Type1::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type(Type1())); CHECK_EQUAL((unsigned int)Type2::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type()); - CHECK_EQUAL((unsigned int)Type2::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type(Type2())); + CHECK_EQUAL((unsigned int)Type2::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type(Type2())); CHECK_EQUAL((unsigned int)Type3::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type()); CHECK_EQUAL((unsigned int)Type3::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type(Type3())); CHECK_EQUAL((unsigned int)Type4::ID, (unsigned int)Type_Id_Lookup16::get_id_from_type()); @@ -251,41 +251,41 @@ namespace //************************************************************************* TEST(test_type_from_type_16) { - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); } //************************************************************************* TEST(test_type_from_type_8) { - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); } //************************************************************************* TEST(test_type_from_type_1) { - CHECK((std::is_same::type>::value)); + CHECK((etlstd::is_same::type>::value)); } }; } diff --git a/test/test_type_select.cpp b/test/test_type_select.cpp index dec01aea..113dce3b 100644 --- a/test/test_type_select.cpp +++ b/test/test_type_select.cpp @@ -51,66 +51,66 @@ namespace //************************************************************************* TEST(test_type_select1) { - CHECK((std::is_same, typename Types1::select<0>::type>::value)); - CHECK(!(std::is_same, typename Types1::select<0>::type>::value)); + CHECK((etlstd::is_same, typename Types1::select<0>::type>::value)); + CHECK(!(etlstd::is_same, typename Types1::select<0>::type>::value)); } //************************************************************************* TEST(test_type_select8) { - CHECK((std::is_same, typename Types8::select<0>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<0>::type>::value)); - CHECK((std::is_same, typename Types8::select<1>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<1>::type>::value)); - CHECK((std::is_same, typename Types8::select<2>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<2>::type>::value)); - CHECK((std::is_same, typename Types8::select<3>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<3>::type>::value)); - CHECK((std::is_same, typename Types8::select<4>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<4>::type>::value)); - CHECK((std::is_same, typename Types8::select<5>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<5>::type>::value)); - CHECK((std::is_same, typename Types8::select<6>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<6>::type>::value)); - CHECK((std::is_same, typename Types8::select<7>::type>::value)); - CHECK(!(std::is_same, typename Types8::select<7>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<0>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<0>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<1>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<1>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<2>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<2>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<3>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<3>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<4>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<4>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<5>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<5>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<6>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<6>::type>::value)); + CHECK((etlstd::is_same, typename Types8::select<7>::type>::value)); + CHECK(!(etlstd::is_same, typename Types8::select<7>::type>::value)); } //************************************************************************* TEST(test_type_select16) { - CHECK((std::is_same, typename Types16::select<0>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<0>::type>::value)); - CHECK((std::is_same, typename Types16::select<1>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<1>::type>::value)); - CHECK((std::is_same, typename Types16::select<2>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<2>::type>::value)); - CHECK((std::is_same, typename Types16::select<3>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<3>::type>::value)); - CHECK((std::is_same, typename Types16::select<4>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<4>::type>::value)); - CHECK((std::is_same, typename Types16::select<5>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<5>::type>::value)); - CHECK((std::is_same, typename Types16::select<6>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<6>::type>::value)); - CHECK((std::is_same, typename Types16::select<7>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<7>::type>::value)); - CHECK((std::is_same, typename Types16::select<8>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<8>::type>::value)); - CHECK((std::is_same, typename Types16::select<9>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<9>::type>::value)); - CHECK((std::is_same, typename Types16::select<10>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<10>::type>::value)); - CHECK((std::is_same, typename Types16::select<11>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<11>::type>::value)); - CHECK((std::is_same, typename Types16::select<12>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<12>::type>::value)); - CHECK((std::is_same, typename Types16::select<13>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<13>::type>::value)); - CHECK((std::is_same, typename Types16::select<14>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<14>::type>::value)); - CHECK((std::is_same, typename Types16::select<15>::type>::value)); - CHECK(!(std::is_same, typename Types16::select<15>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<0>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<0>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<1>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<1>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<2>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<2>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<3>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<3>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<4>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<4>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<5>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<5>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<6>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<6>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<7>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<7>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<8>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<8>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<9>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<9>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<10>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<10>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<11>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<11>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<12>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<12>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<13>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<13>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<14>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<14>::type>::value)); + CHECK((etlstd::is_same, typename Types16::select<15>::type>::value)); + CHECK(!(etlstd::is_same, typename Types16::select<15>::type>::value)); } }; } diff --git a/test/test_type_traits.cpp b/test/test_type_traits.cpp index f05a8bd9..459ec0fa 100644 --- a/test/test_type_traits.cpp +++ b/test/test_type_traits.cpp @@ -30,16 +30,6 @@ SOFTWARE. #define IN_TYPE_TRAITS_TEST -#if defined(ETL_COMPILER_GCC) -namespace std -{ - template - struct add_reference : public std::add_lvalue_reference - { - }; -} -#endif - #include "etl/type_traits.h" #include @@ -51,10 +41,7 @@ namespace namespace etl { template <> - constexpr size_t size_of() - { - return 20; - } + struct size_of : etlstd::integral_constant {}; } namespace @@ -76,467 +63,456 @@ namespace //************************************************************************* TEST(test_is_integral) { - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); - CHECK(etl::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); + CHECK(etlstd::is_integral::value == std::is_integral::value); } //************************************************************************* TEST(test_is_signed) { - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); - CHECK(etl::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); + CHECK(etlstd::is_signed::value == std::is_signed::value); } //************************************************************************* TEST(test_is_unsigned) { - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); - CHECK(etl::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); + CHECK(etlstd::is_unsigned::value == std::is_unsigned::value); } //************************************************************************* TEST(test_is_floating_point) { - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_floating_point::value); - CHECK(etl::is_floating_point::value == std::is_signed::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_floating_point::value); + CHECK(etlstd::is_floating_point::value == std::is_signed::value); } //************************************************************************* TEST(test_is_pointer) { - CHECK(etl::is_pointer::value == std::is_pointer::value); - CHECK(etl::is_pointer::value == std::is_pointer::value); - CHECK(etl::is_pointer::value == std::is_pointer::value); - CHECK(etl::is_pointer::value == std::is_pointer::value); - CHECK(etl::is_pointer::value == std::is_pointer::value); + CHECK(etlstd::is_pointer::value == std::is_pointer::value); + CHECK(etlstd::is_pointer::value == std::is_pointer::value); + CHECK(etlstd::is_pointer::value == std::is_pointer::value); + CHECK(etlstd::is_pointer::value == std::is_pointer::value); + CHECK(etlstd::is_pointer::value == std::is_pointer::value); } //************************************************************************* TEST(test_is_reference) { - CHECK(etl::is_reference::value == std::is_reference::value); - CHECK(etl::is_reference::value == std::is_reference::value); - CHECK(etl::is_reference::value == std::is_reference::value); - CHECK(etl::is_reference::value == std::is_reference::value); - CHECK(etl::is_reference::value == std::is_reference::value); + CHECK(etlstd::is_reference::value == std::is_reference::value); + CHECK(etlstd::is_reference::value == std::is_reference::value); + CHECK(etlstd::is_reference::value == std::is_reference::value); + CHECK(etlstd::is_reference::value == std::is_reference::value); + CHECK(etlstd::is_reference::value == std::is_reference::value); } //************************************************************************* TEST(test_is_same) { - CHECK((etl::is_same::value == std::is_same::value)); - CHECK((etl::is_same::value == std::is_same::value)); + CHECK((etlstd::is_same::value == etlstd::is_same::value)); + CHECK((etlstd::is_same::value == etlstd::is_same::value)); } //************************************************************************* TEST(test_is_array) { - CHECK(etl::is_array::value == std::is_array::value); - CHECK(etl::is_array::value == std::is_array::value); + CHECK(etlstd::is_array::value == std::is_array::value); + CHECK(etlstd::is_array::value == std::is_array::value); } //************************************************************************* TEST(test_remove_pointer) { - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); - CHECK((std::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::remove_pointer::type>::value)); } //************************************************************************* TEST(test_add_pointer) { - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); - CHECK((std::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); + CHECK((etlstd::is_same::type, std::add_pointer::type>::value)); } //************************************************************************* TEST(test_remove_reference) { - CHECK((std::is_same::type, std::remove_reference::type>::value)); - CHECK((std::is_same::type, std::remove_reference::type>::value)); - CHECK((std::is_same::type, std::remove_reference::type>::value)); - CHECK((std::is_same::type, std::remove_reference::type>::value)); - CHECK((std::is_same::type, std::remove_reference::type>::value)); - } - - //************************************************************************* - TEST(test_add_reference) - { - CHECK((std::is_same::type, std::add_lvalue_reference::type>::value)); - CHECK((std::is_same::type, std::add_lvalue_reference::type>::value)); - CHECK((std::is_same::type, std::add_lvalue_reference::type>::value)); - CHECK((std::is_same::type, std::add_lvalue_reference::type>::value)); - CHECK((std::is_same::type, std::add_lvalue_reference::type>::value)); - + CHECK((etlstd::is_same::type, std::remove_reference::type>::value)); + CHECK((etlstd::is_same::type, std::remove_reference::type>::value)); + CHECK((etlstd::is_same::type, std::remove_reference::type>::value)); + CHECK((etlstd::is_same::type, std::remove_reference::type>::value)); + CHECK((etlstd::is_same::type, std::remove_reference::type>::value)); } //************************************************************************* TEST(test_remove_const) { - CHECK((std::is_same::type, std::remove_const::type>::value)); - CHECK((std::is_same::type, std::remove_const::type>::value)); - CHECK((std::is_same::type, std::remove_const::type>::value)); + CHECK((etlstd::is_same::type, std::remove_const::type>::value)); + CHECK((etlstd::is_same::type, std::remove_const::type>::value)); + CHECK((etlstd::is_same::type, std::remove_const::type>::value)); } //************************************************************************* TEST(test_add_const) { - CHECK((std::is_same::type, std::add_const::type>::value)); - CHECK((std::is_same::type, std::add_const::type>::value)); - CHECK((std::is_same::type, std::add_const::type>::value)); + CHECK((etlstd::is_same::type, std::add_const::type>::value)); + CHECK((etlstd::is_same::type, std::add_const::type>::value)); + CHECK((etlstd::is_same::type, std::add_const::type>::value)); } //************************************************************************* TEST(test_is_const) { - CHECK(etl::is_const::value == std::is_const::value); - CHECK(etl::is_const::value == std::is_const::value); - CHECK(etl::is_const::value == std::is_const::value); + CHECK(etlstd::is_const::value == std::is_const::value); + CHECK(etlstd::is_const::value == std::is_const::value); + CHECK(etlstd::is_const::value == std::is_const::value); } //************************************************************************* TEST(test_is_volatile) { - CHECK(etl::is_volatile::value == std::is_volatile::value); - CHECK(etl::is_volatile::value == std::is_volatile::value); - CHECK(etl::is_volatile::value == std::is_volatile::value); + CHECK(etlstd::is_volatile::value == std::is_volatile::value); + CHECK(etlstd::is_volatile::value == std::is_volatile::value); + CHECK(etlstd::is_volatile::value == std::is_volatile::value); } //************************************************************************* TEST(test_remove_volatile) { - CHECK((std::is_same::type, std::remove_volatile::type>::value)); - CHECK((std::is_same::type, std::remove_volatile::type>::value)); - CHECK((std::is_same::type, std::remove_volatile::type>::value)); + CHECK((etlstd::is_same::type, std::remove_volatile::type>::value)); + CHECK((etlstd::is_same::type, std::remove_volatile::type>::value)); + CHECK((etlstd::is_same::type, std::remove_volatile::type>::value)); } //************************************************************************* TEST(test_add_volatile) { - CHECK((std::is_same::type, std::add_volatile::type>::value)); - CHECK((std::is_same::type, std::add_volatile::type>::value)); - CHECK((std::is_same::type, std::add_volatile::type>::value)); + CHECK((etlstd::is_same::type, std::add_volatile::type>::value)); + CHECK((etlstd::is_same::type, std::add_volatile::type>::value)); + CHECK((etlstd::is_same::type, std::add_volatile::type>::value)); } //************************************************************************* TEST(test_remove_cv) { - CHECK((std::is_same::type, std::remove_cv::type>::value)); - CHECK((std::is_same::type, std::remove_cv::type>::value)); - CHECK((std::is_same::type, std::remove_cv::type>::value)); - CHECK((std::is_same::type, std::remove_cv::type>::value)); + CHECK((etlstd::is_same::type, std::remove_cv::type>::value)); + CHECK((etlstd::is_same::type, std::remove_cv::type>::value)); + CHECK((etlstd::is_same::type, std::remove_cv::type>::value)); + CHECK((etlstd::is_same::type, std::remove_cv::type>::value)); } //************************************************************************* TEST(test_add_cv) { - typedef etl::add_cv::type t1; + typedef etlstd::add_cv::type t1; typedef std::add_cv::type t2; - bool pass = std::is_same::value; - //std::is_same::type, std::add_cv::type>::value; + bool pass = etlstd::is_same::value; + //etlstd::is_same::type, std::add_cv::type>::value; CHECK(pass); - CHECK((std::is_same::type, std::add_cv::type>::value)); - CHECK((std::is_same::type, std::add_cv::type>::value)); - CHECK((std::is_same::type, std::add_cv::type>::value)); + CHECK((etlstd::is_same::type, std::add_cv::type>::value)); + CHECK((etlstd::is_same::type, std::add_cv::type>::value)); + CHECK((etlstd::is_same::type, std::add_cv::type>::value)); } //************************************************************************* TEST(test_is_arithmetic) { - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); - CHECK(etl::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); + CHECK(etlstd::is_arithmetic::value == std::is_arithmetic::value); } //************************************************************************* TEST(test_is_fundamental) { - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); - CHECK(etl::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); + CHECK(etlstd::is_fundamental::value == std::is_fundamental::value); } //************************************************************************* TEST(test_is_compound) { - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); - CHECK(etl::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); + CHECK(etlstd::is_compound::value == std::is_compound::value); } //************************************************************************* TEST(test_is_void) { - CHECK(etl::is_void::value == std::is_void::value); - CHECK(etl::is_void::value == std::is_void::value); + CHECK(etlstd::is_void::value == std::is_void::value); + CHECK(etlstd::is_void::value == std::is_void::value); } //************************************************************************* TEST(test_make_signed) { - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK(std::is_signed::type>::value && (sizeof(wchar_t) == sizeof(etl::make_signed::type))); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); - CHECK((std::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK(etlstd::is_signed::type>::value && (sizeof(wchar_t) == sizeof(etlstd::make_signed::type))); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); + CHECK((etlstd::is_same::type, std::make_signed::type>::value)); } //************************************************************************* TEST(test_make_unsigned) { - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK(std::is_unsigned::type>::value && (sizeof(wchar_t) == sizeof(etl::make_unsigned::type))); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); - CHECK((std::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK(etlstd::is_unsigned::type>::value && (sizeof(wchar_t) == sizeof(etlstd::make_unsigned::type))); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); + CHECK((etlstd::is_same::type, std::make_unsigned::type>::value)); } //************************************************************************* TEST(test_extent) { - CHECK(std::extent::value == etl::extent::value); - CHECK(std::extent::value == etl::extent::value); - CHECK(std::extent::value == etl::extent::value); + CHECK(std::extent::value == etlstd::extent::value); + CHECK(std::extent::value == etlstd::extent::value); + CHECK(std::extent::value == etlstd::extent::value); } //************************************************************************* TEST(test_remove_extent) { - CHECK((std::is_same::type, std::remove_extent::type>::value)); - CHECK((std::is_same::type, std::remove_extent::type>::value)); - CHECK((std::is_same::type, std::remove_extent::type>::value)); + CHECK((etlstd::is_same::type, std::remove_extent::type>::value)); + CHECK((etlstd::is_same::type, std::remove_extent::type>::value)); + CHECK((etlstd::is_same::type, std::remove_extent::type>::value)); } //************************************************************************* TEST(test_remove_all_extents) { - CHECK((std::is_same::type, std::remove_all_extents::type>::value)); - CHECK((std::is_same::type, std::remove_all_extents::type>::value)); - CHECK((std::is_same::type, std::remove_all_extents::type>::value)); + CHECK((etlstd::is_same::type, std::remove_all_extents::type>::value)); + CHECK((etlstd::is_same::type, std::remove_all_extents::type>::value)); + CHECK((etlstd::is_same::type, std::remove_all_extents::type>::value)); } //************************************************************************* TEST(test_rank) { - CHECK(etl::rank::value == std::rank::value); - CHECK(etl::rank::value == std::rank::value); - CHECK(etl::rank::value == std::rank::value); + CHECK(etlstd::rank::value == std::rank::value); + CHECK(etlstd::rank::value == std::rank::value); + CHECK(etlstd::rank::value == std::rank::value); } //************************************************************************* @@ -549,19 +525,19 @@ namespace float c; }; - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); - CHECK(std::alignment_of::value == etl::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); + CHECK(std::alignment_of::value == etlstd::alignment_of::value); } //************************************************************************* @@ -603,135 +579,135 @@ namespace struct B : public A { }; struct C { }; - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); - CHECK((std::is_base_of::value) == (etl::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); + CHECK((std::is_base_of::value) == (etlstd::is_base_of::value)); } //************************************************************************* TEST(test_types) { - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); - CHECK((std::is_same::type>::value)); - CHECK((std::is_same::reference>::value)); - CHECK((std::is_same::const_reference>::value)); - CHECK((std::is_same::pointer>::value)); - CHECK((std::is_same::const_pointer>::value)); - CHECK((std::is_same::const_pointer_const>::value)); + CHECK((etlstd::is_same::type>::value)); + CHECK((etlstd::is_same::reference>::value)); + CHECK((etlstd::is_same::const_reference>::value)); + CHECK((etlstd::is_same::pointer>::value)); + CHECK((etlstd::is_same::const_pointer>::value)); + CHECK((etlstd::is_same::const_pointer_const>::value)); } }; @@ -748,10 +724,62 @@ namespace //************************************************************************* TEST(size_of) { - CHECK_EQUAL(1, etl::size_of()); - CHECK_EQUAL(1, etl::size_of()); - CHECK_EQUAL(2, etl::size_of()); - CHECK_EQUAL(4, etl::size_of()); - CHECK_EQUAL(20, etl::size_of()); + CHECK_EQUAL(1, etl::size_of::value); + CHECK_EQUAL(1, etl::size_of::value); + CHECK_EQUAL(2, etl::size_of::value); + CHECK_EQUAL(4, etl::size_of::value); + CHECK_EQUAL(20, etl::size_of::value); + + CHECK_EQUAL(1, etl::size_of_v); + CHECK_EQUAL(1, etl::size_of_v); + CHECK_EQUAL(2, etl::size_of_v); + CHECK_EQUAL(4, etl::size_of_v); + CHECK_EQUAL(20, etl::size_of_v); + } + + //************************************************************************* + TEST(is_convertible) + { + CHECK((etlstd::is_convertible::value)); + CHECK((etlstd::is_convertible::value)); + CHECK((etlstd::is_convertible::value)); + CHECK((etlstd::is_convertible::value)); + CHECK((etlstd::is_convertible::value)); + CHECK((etlstd::is_convertible::value)); + CHECK((etlstd::is_convertible::value)); + CHECK(!(etlstd::is_convertible::value)); + CHECK(!(etlstd::is_convertible::value)); + CHECK(!(etlstd::is_convertible::value)); + CHECK(!(etlstd::is_convertible::value)); + } + + //************************************************************************* + TEST(add_lvalue_reference) + { + CHECK(!std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + CHECK(std::is_lvalue_reference_v::type>); + } + + //************************************************************************* + TEST(add_rvalue_reference) + { + CHECK(!std::is_rvalue_reference_v::type>); + CHECK(std::is_rvalue_reference_v::type>); + CHECK(std::is_rvalue_reference_v::type>); + CHECK(!std::is_rvalue_reference_v::type>); + CHECK(std::is_rvalue_reference_v::type>); + } + + //************************************************************************* + TEST(is_lvalue_reference) + { + CHECK_EQUAL(std::is_lvalue_reference_v, etlstd::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etlstd::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etlstd::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etlstd::is_lvalue_reference_v); + CHECK_EQUAL(std::is_lvalue_reference_v, etlstd::is_lvalue_reference_v); } } diff --git a/test/test_variant.cpp b/test/test_variant.cpp index 65c70f27..5ef05e8d 100644 --- a/test/test_variant.cpp +++ b/test/test_variant.cpp @@ -216,10 +216,10 @@ namespace static test_variant_c c(3); static test_variant_d d(4.5); - CHECK((uintptr_t(&a.get()) % uintptr_t(etl::alignment_of::value)) == 0); - CHECK((uintptr_t(&b.get()) % uintptr_t(etl::alignment_of::value)) == 0); - CHECK((uintptr_t(&c.get()) % uintptr_t(etl::alignment_of::value)) == 0); - CHECK((uintptr_t(&d.get()) % uintptr_t(etl::alignment_of::value)) == 0); + CHECK((uintptr_t(&a.get()) % uintptr_t(etlstd::alignment_of::value)) == 0); + CHECK((uintptr_t(&b.get()) % uintptr_t(etlstd::alignment_of::value)) == 0); + CHECK((uintptr_t(&c.get()) % uintptr_t(etlstd::alignment_of::value)) == 0); + CHECK((uintptr_t(&d.get()) % uintptr_t(etlstd::alignment_of::value)) == 0); } //************************************************************************* diff --git a/test/vs2017/etl.vcxproj b/test/vs2017/etl.vcxproj index 3e2240c0..db8603b9 100644 --- a/test/vs2017/etl.vcxproj +++ b/test/vs2017/etl.vcxproj @@ -732,6 +732,7 @@ + @@ -798,16 +799,6 @@ - - - - - - - - - - diff --git a/test/vs2017/etl.vcxproj.filters b/test/vs2017/etl.vcxproj.filters index a467fa68..e27c2993 100644 --- a/test/vs2017/etl.vcxproj.filters +++ b/test/vs2017/etl.vcxproj.filters @@ -67,12 +67,6 @@ {0bcdf7f9-8e2b-4f70-932b-bde56404f421} - - {86dc2850-2ddf-4582-9908-2436a1aa6e86} - - - {0d093ee6-686c-4c9e-856e-bdf7075ff7a6} - {da88d71d-e5ea-4c26-9807-94616d31addb} @@ -618,15 +612,6 @@ ETL\Private - - ETL\STL\Alternate - - - ETL\STL\Alternate - - - ETL\STL - ETL\Profiles @@ -642,27 +627,6 @@ ETL\Profiles - - ETL\STL\Alternate - - - ETL\STL - - - ETL\STL - - - ETL\STL\Alternate - - - ETL\STL - - - ETL\STL\Alternate - - - ETL\STL - ETL\Maths @@ -792,9 +756,6 @@ ETL\Containers - - ETL\Private - ETL\Private @@ -858,6 +819,12 @@ ETL\Profiles + + ETL\Private + + + ETL\Utilities + @@ -1364,9 +1331,6 @@ Resource Files - - Resource Files\CI\CircleCI - Resource Files