diff --git a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx index f89a79e0..7b7077f4 100644 --- a/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx +++ b/examples/ArmTimerCallbacks - C++/ArmTimerCallbacks.uvprojx @@ -11,7 +11,7 @@ 0x4 ARM-ADS 6130001::V6.13.1::.\ARMCLANG - 1 + 0 STM32F401RETx @@ -312,7 +312,7 @@ 1 - 7 + 1 0 0 1 @@ -321,7 +321,7 @@ 1 0 0 - 3 + 2 0 0 1 diff --git a/include/etl/algorithm.h b/include/etl/algorithm.h index 690a802b..a9960120 100644 --- a/include/etl/algorithm.h +++ b/include/etl/algorithm.h @@ -32,34 +32,1299 @@ 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 #include "platform.h" -#include "iterator.h" #include "type_traits.h" #include "container.h" +#include "iterator.h" +#include "functional.h" +#include "utility.h" +#if !defined(ETL_NO_STL) + #include + #include + #include + #include +#endif + +//***************************************************************************** +// Algorithms defined by the ETL +//***************************************************************************** namespace etl { +// We can't have std::swap and etl::swap templates coexisting in the unit tests +// as the compiler will be unable to decide of which one to use, due to ADL. +#if defined(ETL_NO_STL) && !defined(ETL_IN_UNIT_TEST) + //*************************************************************************** + // swap +#if ETL_CPP11_SUPPORTED + template + void swap(T& a, T& b) + { + T temp(etl::move(a)); + a = etl::move(b); + b = etl::move(temp); + } +#else + template + void swap(T& a, T& b) + { + T temp(a); + a = b; + b = temp; + } +#endif +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // iter_swap + template + void iter_swap(TIterator1 a, TIterator2 b) + { + typename etl::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 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 etl::iterator_traits::value_type value_t; + typedef typename etl::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; + } +#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 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 etl::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; + } +#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 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 etl::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; + } +#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++ = etl::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) = etl::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 etl::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 etl::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 + ETL_NODISCARD + TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + typedef typename etl::iterator_traits::difference_type difference_t; + + difference_t count = etl::distance(first, last); + + while (count > 0) + { + TIterator itr = first; + difference_t step = count / 2; + + etl::advance(itr, step); + + if (compare(*itr, value)) + { + first = ++itr; + count -= step + 1; + } + else + { + count = step; + } + } + + return first; + } + + template + ETL_NODISCARD + TIterator lower_bound(TIterator first, TIterator last, const TValue& value) + { + typedef etl::less::value_type> compare; + + return etl::lower_bound(first, last, value, compare()); + } +#else + //*************************************************************************** + // lower_bound + template + ETL_NODISCARD + TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + return std::lower_bound(first, last, value, compare); + } + + template + ETL_NODISCARD + TIterator lower_bound(TIterator first, TIterator last, const TValue& value) + { + return std::lower_bound(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // upper_bound + template + ETL_NODISCARD + TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + typedef typename etl::iterator_traits::difference_type difference_t; + + difference_t count = etl::distance(first, last); + + while (count > 0) + { + TIterator itr = first; + difference_t step = count / 2; + + etl::advance(itr, step); + + if (!compare(value, *itr)) + { + first = ++itr; + count -= step + 1; + } + else + { + count = step; + } + } + + return first; + } + + template + ETL_NODISCARD + TIterator upper_bound(TIterator first, TIterator last, const TValue& value) + { + typedef etl::less::value_type> compare; + + return etl::upper_bound(first, last, value, compare()); + } +#else + //*************************************************************************** + // upper_bound + template + ETL_NODISCARD + TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + return std::upper_bound(first, last, value, compare); + } + + template + ETL_NODISCARD + TIterator upper_bound(TIterator first, TIterator last, const TValue& value) + { + return std::upper_bound(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // equal_range + template + ETL_NODISCARD + ETL_OR_STD::pair equal_range(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + return ETL_OR_STD::make_pair(etl::lower_bound(first, last, value, compare), + etl::upper_bound(first, last, value, compare)); + } + + template + ETL_NODISCARD + ETL_OR_STD::pair equal_range(TIterator first, TIterator last, const TValue& value) + { + typedef etl::less::value_type> compare; + + return ETL_OR_STD::make_pair(etl::lower_bound(first, last, value, compare()), + etl::upper_bound(first, last, value, compare())); + } +#else + //*************************************************************************** + // equal_range + template + ETL_NODISCARD + std::pair equal_range(TIterator first, TIterator last, const TValue& value, TCompare compare) + { + return std::equal_range(first, last, value, compare); + } + + template + ETL_NODISCARD + std::pair equal_range(TIterator first, TIterator last, const TValue& value) + { + return std::equal_range(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // find_if + template + ETL_NODISCARD + TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate) + { + while (first != last) + { + if (predicate(*first)) + { + return first; + } + + ++first; + } + + return last; + } +#else + //*************************************************************************** + // find_if + template + ETL_NODISCARD + TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate) + { + return std::find_if(first, last, predicate); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // find + template + ETL_NODISCARD + TIterator find(TIterator first, TIterator last, const T& value) + { + while (first != last) + { + if (*first == value) + { + return first; + } + + ++first; + } + + return last; + } +#else + //*************************************************************************** + // find + template + ETL_NODISCARD + TIterator find(TIterator first, TIterator last, const T& value) + { + return std::find(first, last, value); + } +#endif + +#if defined(ETL_NO_STL) + //*************************************************************************** + // 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); + } +#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 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); + } +#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 + ETL_NODISCARD + typename etl::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 + ETL_NODISCARD + 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 + ETL_NODISCARD + typename etl::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 + ETL_NODISCARD + 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 + ETL_NODISCARD + typename etl::enable_if::value || !etl::is_pointer::value || !etl::is_pod::value_type>::value, bool>::type + equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) + { + while (first1 != last1) + { + if (*first1++ != *first2++) + { + return false; + } + } + + return true; + } + + template + ETL_NODISCARD + typename etl::enable_if::value && etl::is_pointer::value && etl::is_pod::value_type>::value, bool>::type + equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) + { + typedef typename etl::iterator_traits::value_type value_t; + + return (memcmp(first1, first2, sizeof(value_t) * (last1 - first1)) == 0); + } +#else + //*************************************************************************** + // equal + template + ETL_NODISCARD + bool equal(TIterator1 first1, TIterator1 last1, TIterator2 first2) + { + return std::equal(first1, last1, first2); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // lexicographical_compare + template + ETL_NODISCARD + 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 + ETL_NODISCARD + bool lexicographical_compare(TIterator1 first1, TIterator1 last1, + TIterator2 first2, TIterator2 last2) + { + typedef etl::less::value_type> compare; + + return etl::lexicographical_compare(first1, last1, first2, last2, compare()); + } +#else + //*************************************************************************** + // lexicographical_compare + template + ETL_NODISCARD + bool lexicographical_compare(TIterator1 first1, TIterator1 last1, + TIterator2 first2, TIterator2 last2, + TCompare compare) + { + return std::lexicographical_compare(first1, last1, first2, last2, compare); + } + + //*************************************************************************** + // lexicographical_compare + template + ETL_NODISCARD + 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_NODISCARD + ETL_CONSTEXPR const T& min(const T& a, const T& b, TCompare compare) + { + return (compare(a, b)) ? a : b; + } + + template + ETL_NODISCARD + ETL_CONSTEXPR const T& min(const T& a, const T& b) + { + typedef etl::less compare; + + return etl::min(a, b, compare()); + } +#else + //*************************************************************************** + // min + template + ETL_NODISCARD + ETL_CONSTEXPR const T& min(const T& a, const T& b, TCompare compare) + { + return std::min(a, b, compare); + } + + template + ETL_NODISCARD + ETL_CONSTEXPR const T& min(const T& a, const T& b) + { + return std::min(a, b); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // max + template + ETL_NODISCARD + ETL_CONSTEXPR const T& max(const T& a, const T& b, TCompare compare) + { + return (compare(a, b)) ? b : a; + } + + template + ETL_NODISCARD + ETL_CONSTEXPR const T& max(const T& a, const T& b) + { + typedef etl::less compare; + + return etl::max(a, b, compare()); + } +#else + //*************************************************************************** + // max + template + ETL_NODISCARD + ETL_CONSTEXPR const T& max(const T& a, const T& b, TCompare compare) + { + return std::max(a, b, compare); + } + + template + ETL_NODISCARD + ETL_CONSTEXPR const T& max(const T& a, const T& b) + { + return std::max(a, b); + } +#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 etl::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::difference_type distance_t; + + value_t value = last[-1]; + last[-1] = first[0]; + + 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 etl::less::value_type> compare; + + etl::pop_heap(first, last, compare()); + } + + // Push Heap + template + void push_heap(TIterator first, TIterator last, TCompare compare) + { + typedef typename etl::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::value_type value_t; + + private_heap::push_heap(first, difference_t(last - first - 1), difference_t(0), value_t(*(last - 1)), compare); + } + + // Push Heap + template + void push_heap(TIterator first, TIterator last) + { + typedef etl::less::value_type> compare; + + etl::push_heap(first, last, compare()); + } + + // Make Heap + template + void make_heap(TIterator first, TIterator last, TCompare compare) + { + typedef typename etl::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 etl::less::value_type> compare; + + etl::make_heap(first, last, compare()); + } + + // Is Heap + template + ETL_NODISCARD + bool is_heap(TIterator first, TIterator last) + { + typedef etl::less::value_type> compare; + + return private_heap::is_heap(first, last - first, compare()); + } + + // Is Heap + template + ETL_NODISCARD + bool is_heap(TIterator first, TIterator last, TCompare compare) + { + return private_heap::is_heap(first, last - first, compare); + } +#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 + ETL_NODISCARD + bool is_heap(TIterator first, TIterator last) + { + return std::is_heap(first, last); + } + + // Is Heap + template + ETL_NODISCARD + bool is_heap(TIterator first, TIterator last, TCompare compare) + { + return std::is_heap(first, last, compare); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // Search + template + ETL_NODISCARD + 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 + ETL_NODISCARD + 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 + ETL_NODISCARD + TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare) + { + return std::search(first, last, search_first, search_last, compare); + } + + // Search + template + ETL_NODISCARD + TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last) + { + return std::search(first, last, search_first, search_last); + } +#endif + +#if defined (ETL_NO_STL) + //*************************************************************************** + // Rotate + template + TIterator rotate(TIterator first, TIterator middle, TIterator last) + { + using ETL_OR_STD::swap; // Allow ADL + + TIterator next = middle; + + while (first != next) + { + using ETL_OR_STD::swap; + + 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 + ETL_NODISCARD + 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 + ETL_NODISCARD + 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 + ETL_NODISCARD + TIterator1 find_end(TIterator1 b, TIterator1 e, + TIterator2 sb, TIterator2 se, + TPredicate predicate) + { + return std::find_end(b, e, sb, se, predicate); + } + + // Default + template + ETL_NODISCARD + 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_NODISCARD + ETL_OR_STD::pair minmax_element(TIterator begin, + TIterator end, + TCompare compare) { TIterator minimum = begin; TIterator maximum = begin; @@ -79,7 +1344,7 @@ namespace etl ++begin; } - return ETL_PAIR(minimum, maximum); + return ETL_OR_STD::pair(minimum, maximum); } //*************************************************************************** @@ -88,24 +1353,56 @@ namespace etl /// //*************************************************************************** template - ETL_PAIR minmax_element(TIterator begin, - TIterator end) + ETL_NODISCARD + ETL_OR_STD::pair minmax_element(TIterator begin, + TIterator end) { - typedef typename ETL_STD::iterator_traits::value_type value_t; + typedef typename etl::iterator_traits::value_type value_t; - return etl::minmax_element(begin, end, ETL_STD::less()); + return etl::minmax_element(begin, end, etl::less()); + } +#else + //*************************************************************************** +/// Finds the greatest and the smallest element in the range (begin, end).
+/// +///\ingroup algorithm +//*************************************************************************** + template + ETL_NODISCARD + std::pair minmax_element(TIterator begin, + TIterator end, + TCompare compare) + { + return std::minmax_element(begin, end, compare); } + + //*************************************************************************** + /// minmax_element + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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_NODISCARD + 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); } //*************************************************************************** @@ -113,21 +1410,51 @@ namespace etl ///\ingroup algorithm /// //*************************************************************************** - template - ETL_PAIR minmax(const T& a, - const T& b, - TCompare compare) + template + ETL_NODISCARD + ETL_OR_STD::pair minmax(const T& a, + const T& b, + TCompare compare) { - return compare(b, a) ? ETL_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 + ETL_NODISCARD + std::pair minmax(const T& a, + const T& b) + { + return std::minmax(a, b); } + //*************************************************************************** + /// minmax + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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 /// //*************************************************************************** template + ETL_NODISCARD TIterator is_sorted_until(TIterator begin, TIterator end) { @@ -154,8 +1481,8 @@ namespace etl ///\ingroup algorithm /// //*************************************************************************** - template + template + ETL_NODISCARD TIterator is_sorted_until(TIterator begin, TIterator end, TCompare compare) @@ -177,13 +1504,43 @@ namespace etl return end; } +#else + //*************************************************************************** + /// is_sorted_until + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + TIterator is_sorted_until(TIterator begin, + TIterator end) + { + return std::is_sorted_until(begin, end); + } + //*************************************************************************** + /// is_sorted_until + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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 /// //*************************************************************************** template + ETL_NODISCARD bool is_sorted(TIterator begin, TIterator end) { @@ -195,158 +1552,416 @@ namespace etl ///\ingroup algorithm /// //*************************************************************************** - template + template + ETL_NODISCARD bool is_sorted(TIterator begin, TIterator end, TCompare compare) { return etl::is_sorted_until(begin, end, compare) == end; } - +#else //*************************************************************************** - /// copy - /// A 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. - ///\param i_end End of the input range. - ///\param o_begin Beginning of the output range. - ///\param o_end End of the output range. + /// is_sorted ///\ingroup algorithm + /// //*************************************************************************** - template - typename etl::enable_if::value && - etl::is_random_iterator::value, TOutputIterator>::type - copy(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end) + template + ETL_NODISCARD + bool is_sorted(TIterator begin, + TIterator 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 size = (s_size < d_size) ? s_size : d_size; - - return ETL_STD::copy(i_begin, i_begin + size, o_begin); + return std::is_sorted(begin, end); } //*************************************************************************** - /// copy - /// A 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. - ///\param i_end End of the input range. - ///\param o_begin Beginning of the output range. - ///\param o_end End of the output range. + /// is_sorted ///\ingroup algorithm + /// //*************************************************************************** - template - typename etl::enable_if::value || - !etl::is_random_iterator::value, TOutputIterator>::type - copy(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end) + template + ETL_NODISCARD + bool is_sorted(TIterator begin, + TIterator end, + TCompare compare) { - while ((i_begin != i_end) && (o_begin != o_end)) + return std::is_sorted(begin, end, compare); + } +#endif + +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + //*************************************************************************** + /// find_if_not + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + TIterator find_if_not(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + while (begin != end) { - *o_begin++ = *i_begin++; + if (!predicate(*begin)) + { + return begin; + } + + ++begin; } - return o_begin; + return end; } - +#else //*************************************************************************** - /// copy_n (Random input iterators) + /// find_if_not ///\ingroup algorithm - /// + /// //*************************************************************************** - template - typename etl::enable_if::value, TOutputIterator>::type - copy_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin) + template + ETL_NODISCARD + TIterator find_if_not(TIterator begin, + TIterator end, + TUnaryPredicate predicate) { - return ETL_STD::copy(i_begin, i_begin + n, o_begin); + return std::find_if_not(begin, end, predicate); } +#endif +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED //*************************************************************************** - /// copy_n (Non-random input iterators) + /// is_permutation ///\ingroup algorithm - /// + /// //*************************************************************************** - template - typename etl::enable_if::value, TOutputIterator>::type - copy_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin) + template + ETL_NODISCARD + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2) { - while (n-- > 0) + if (begin1 != end1) { - *o_begin++ = *i_begin++; + TIterator2 end2 = begin2; + + etl::advance(end2, etl::distance(begin1, end1)); + + for (TIterator1 i = begin1; i != end1; ++i) + { + if (i == etl::find(begin1, i, *i)) + { + size_t n = etl::count(begin2, end2, *i); + + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) + { + return false; + } + } + } } - return o_begin; + return true; } //*************************************************************************** - /// copy_n - /// A form of copy_n where the smallest of the two ranges is used. + /// is_permutation ///\ingroup algorithm + /// //*************************************************************************** - template - TOutputIterator copy_n(TInputIterator i_begin, - TSize n, - TOutputIterator o_begin, - TOutputIterator o_end) + template + ETL_NODISCARD + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TBinaryPredicate predicate) { - while ((n-- > 0) && (o_begin != o_end)) + if (begin1 != end1) { - *o_begin++ = *i_begin++; + TIterator2 end2 = begin2; + + etl::advance(end2, etl::distance(begin1, end1)); + + for (TIterator1 i = begin1; i != end1; ++i) + { + if (i == etl::find_if(begin1, i, etl::bind1st(predicate, *i))) + { + size_t n = etl::count(begin2, end2, *i); + + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) + { + return false; + } + } + } } - return o_begin; + return true; } //*************************************************************************** - /// copy_n - /// A form of copy_n where the smallest of the two ranges is used. + /// is_permutation ///\ingroup algorithm + /// //*************************************************************************** - template - TOutputIterator copy_n(TInputIterator i_begin, - TSize1 n1, - TOutputIterator o_begin, - TSize2 n2) + template + ETL_NODISCARD + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TIterator2 end2) { - while ((n1-- > 0) && (n2-- > 0)) + if (begin1 != end1) { - *o_begin++ = *i_begin++; + for (TIterator1 i = begin1; i != end1; ++i) + { + if (i == etl::find(begin1, i, *i)) + { + size_t n = etl::count(begin2, end2, *i); + + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) + { + return false; + } + } + } } - return o_begin; + return true; } + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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 == etl::find_if(begin1, i, etl::bind1st(predicate, *i))) + { + size_t n = etl::count(begin2, end2, *i); + + if (n == 0 || size_t(etl::count(i, end1, *i)) != n) + { + return false; + } + } + } + } + + return true; + } +#else + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2) + { + return std::is_permutation(begin1, end1, begin2); + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TBinaryPredicate predicate) + { + return std::is_permutation(begin1, end1, begin2, predicate); + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + bool is_permutation(TIterator1 begin1, + TIterator1 end1, + TIterator2 begin2, + TIterator2 end2) + { + return std::is_permutation(begin1, end1, begin2, end2); + } + + //*************************************************************************** + /// is_permutation + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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 + ETL_NODISCARD + 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 + ETL_NODISCARD + 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 + ETL_NODISCARD + 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 + ETL_NODISCARD + 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 + template TOutputIterator copy_if(TIterator begin, TIterator end, TOutputIterator out, @@ -364,21 +1979,230 @@ namespace etl 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 + ETL_NODISCARD + bool all_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return etl::find_if_not(begin, end, predicate) == end; + } +#else + //*************************************************************************** + /// all_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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 + ETL_NODISCARD + bool any_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return etl::find_if(begin, end, predicate) != end; + } +#else + //*************************************************************************** + /// any_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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 + ETL_NODISCARD + bool none_of(TIterator begin, + TIterator end, + TUnaryPredicate predicate) + { + return etl::find_if(begin, end, predicate) == end; + } +#else + //*************************************************************************** + /// none_of + ///\ingroup algorithm + /// + //*************************************************************************** + template + ETL_NODISCARD + 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. + ///\param i_end End of the input range. + ///\param o_begin Beginning of the output range. + ///\param o_end End of the output range. + ///\ingroup algorithm + //*************************************************************************** + template + typename etl::enable_if::value && + etl::is_random_iterator::value, TOutputIterator>::type + copy_s(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end) + { + size_t s_size = etl::distance(i_begin, i_end); + size_t d_size = etl::distance(o_begin, o_end); + size_t size = (s_size < d_size) ? s_size : d_size; + + return etl::copy(i_begin, i_begin + size, o_begin); + } + + //*************************************************************************** + /// copy + /// 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. + ///\param i_end End of the input range. + ///\param o_begin Beginning of the output range. + ///\param o_end End of the output range. + ///\ingroup algorithm + //*************************************************************************** + template + typename etl::enable_if::value || + !etl::is_random_iterator::value, TOutputIterator>::type + copy_s(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end) + { + while ((i_begin != i_end) && (o_begin != o_end)) + { + *o_begin++ = *i_begin++; + } + + return o_begin; + } + + //*************************************************************************** + /// copy_n + /// A safer form of copy_n where the smallest of the two ranges is used. + ///\ingroup algorithm + //*************************************************************************** + template + TOutputIterator copy_n_s(TInputIterator i_begin, + TSize n, + TOutputIterator o_begin, + TOutputIterator o_end) + { + while ((n-- > 0) && (o_begin != o_end)) + { + *o_begin++ = *i_begin++; + } + + return o_begin; + } + + //*************************************************************************** + /// copy_n + /// A safer form of copy_n where the smallest of the two ranges is used. + ///\ingroup algorithm + //*************************************************************************** + template + TOutputIterator copy_n_s(TInputIterator i_begin, + TSize1 n1, + TOutputIterator o_begin, + TSize2 n2) + { + while ((n1-- > 0) && (n2-- > 0)) + { + *o_begin++ = *i_begin++; + } + + return o_begin; + } //*************************************************************************** /// 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 //*************************************************************************** template - TOutputIterator copy_if(TInputIterator i_begin, - TInputIterator i_end, - TOutputIterator o_begin, - TOutputIterator o_end, - TUnaryPredicate predicate) + TOutputIterator copy_if_s(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end, + TUnaryPredicate predicate) { while ((i_begin != i_end) && (o_begin != o_end)) { @@ -425,13 +2249,13 @@ namespace etl ///\ingroup algorithm /// Does a binary search and returns an iterator to the value or end if not found. //*************************************************************************** - template - TIterator binary_find(TIterator begin, - TIterator end, - const TValue& value) + template + ETL_NODISCARD + TIterator binary_find(TIterator begin, + TIterator end, + const TValue& value) { - TIterator it = ETL_STD::lower_bound(begin, end, value); + TIterator it = etl::lower_bound(begin, end, value); if ((it == end) || (*it != value)) { @@ -450,13 +2274,14 @@ namespace etl typename TValue, typename TBinaryPredicate, typename TBinaryEquality> - TIterator binary_find(TIterator begin, - TIterator end, - const TValue& value, - TBinaryPredicate predicate, - TBinaryEquality equality) + ETL_NODISCARD + 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 = etl::lower_bound(begin, end, value, predicate); if ((it == end) || !equality(*it, value)) { @@ -466,299 +2291,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 @@ -784,7 +2316,7 @@ namespace etl return function; } - //*************************************************************************** + //*************************************************************************** /// Like std::for_each but for 'n' iterations. ///\ingroup algorithm //*************************************************************************** @@ -830,24 +2362,24 @@ 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) + template + TOutputIterator transform_s(TInputIterator i_begin, + TInputIterator i_end, + TOutputIterator o_begin, + TOutputIterator o_end, + TUnaryFunction function) { while ((i_begin != i_end) && (o_begin != o_end)) { *o_begin++ = function(*i_begin++); } + + return o_begin; } //*************************************************************************** @@ -860,13 +2392,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); + etl::advance(i_end, n); + + etl::transform(i_begin, i_end, o_begin, function); } //*************************************************************************** @@ -880,64 +2414,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); - } + TInputIterator1 i_end1(i_begin1); + etl::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; - } + etl::transform(i_begin1, i_end1, i_begin2, o_begin, function); } //*************************************************************************** @@ -1064,13 +2550,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 +2570,7 @@ namespace etl } } - return ETL_PAIR(destination_true, destination_false); + return ETL_OR_STD::pair(destination_true, destination_false); } //*************************************************************************** @@ -1099,14 +2585,14 @@ namespace etl typename TBinaryFunctionTrue, typename TBinaryFunctionFalse, typename TBinaryPredicate> - ETL_PAIR partition_transform(TSource1 begin1, - TSource1 end1, - TSource2 begin2, - TDestinationTrue destination_true, - TDestinationFalse destination_false, - TBinaryFunctionTrue function_true, - TBinaryFunctionFalse function_false, - TBinaryPredicate predicate) + ETL_OR_STD::pair partition_transform(TSource1 begin1, + TSource1 end1, + TSource2 begin2, + TDestinationTrue destination_true, + TDestinationFalse destination_false, + TBinaryFunctionTrue function_true, + TBinaryFunctionFalse function_false, + TBinaryPredicate predicate) { while (begin1 != end1) { @@ -1120,7 +2606,7 @@ namespace etl } } - return ETL_PAIR(destination_true, destination_false); + return ETL_OR_STD::pair(destination_true, destination_false); } //*************************************************************************** @@ -1136,9 +2622,9 @@ namespace etl return; } - typedef typename ETL_STD::iterator_traits::difference_type difference_t; + typedef typename etl::iterator_traits::difference_type difference_t; - difference_t n = ETL_STD::distance(first, last); + difference_t n = etl::distance(first, last); for (difference_t i = n / 2; i > 0; i /= 2) { @@ -1149,12 +2635,12 @@ namespace etl TIterator itr1 = first; TIterator itr2 = first; - ETL_STD::advance(itr1, k); - ETL_STD::advance(itr2, k + i); + etl::advance(itr1, k); + etl::advance(itr2, k + i); if (compare(*itr2, *itr1)) { - ETL_STD::iter_swap(itr1, itr2); + etl::iter_swap(itr1, itr2); } } } @@ -1168,7 +2654,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, etl::less::value_type>()); } //*************************************************************************** @@ -1181,7 +2667,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)); + etl::rotate(etl::upper_bound(first, itr, *itr, compare), itr, etl::next(itr)); } } @@ -1192,7 +2678,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, etl::less::value_type>()); } //*************************************************************************** @@ -1213,7 +2699,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, etl::less::value_type>()); } //*************************************************************************** @@ -1236,129 +2722,159 @@ 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, etl::less::value_type>()); } -#if ETL_CPP11_SUPPORTED //*************************************************************************** /// Returns the maximum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimax(const T& a, const T& b) { return a < b ? b : a; } template + ETL_NODISCARD constexpr const T& multimax(const T& t, const Tx&... tx) { return multimax(t, multimax(tx...)); } +#endif //*************************************************************************** /// Returns the maximum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimax_compare(TCompare compare, const T& a, const T& b) { return compare(a, b) ? b : a; } template + ETL_NODISCARD constexpr const T& multimax_compare(TCompare compare, const T& t, const Tx&... tx) { return multimax_compare(compare, t, multimax_compare(compare, tx...)); } +#endif //*************************************************************************** /// Returns the maximum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimin(const T& a, const T& b) { return a < b ? a : b; } template + ETL_NODISCARD constexpr const T& multimin(const T& t, const Tx&... tx) { return multimin(t, multimin(tx...)); } +#endif //*************************************************************************** /// Returns the minimum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const T& multimin_compare(TCompare compare, const T& a, const T& b) { return compare(a, b) ? a : b; } template + ETL_NODISCARD constexpr const T& multimin_compare(TCompare compare, const T& t, const Tx&... tx) { return multimin_compare(compare, t, multimin_compare(compare, tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the maximum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimax_iter(const TIterator& a, const TIterator& b) { return *a < *b ? b : a; } template + ETL_NODISCARD constexpr const TIterator& multimax_iter(const TIterator& t, const TIteratorx&... tx) { return multimax_iter(t, multimax_iter(tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the maximum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimax_iter_compare(TCompare compare, const TIterator& a, const TIterator& b) { return compare(*a, *b) ? b : a; } template + ETL_NODISCARD constexpr const TIterator& multimax_iter_compare(TCompare compare, const TIterator& t, const TIteratorx&... tx) { return multimax_iter_compare(compare, t, multimax_iter_compare(compare, tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the minimum value. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimin_iter(const TIterator& a, const TIterator& b) { return *a < *b ? a : b; } template + ETL_NODISCARD constexpr const TIterator& multimin_iter(const TIterator& t, const Tx&... tx) { return multimin_iter(t, multimin_iter(tx...)); } +#endif //*************************************************************************** /// Returns the iterator to the minimum value. /// User supplied compare function. //*************************************************************************** +#if ETL_CPP11_SUPPORTED template + ETL_NODISCARD constexpr const TIterator& multimin_iter_compare(TCompare compare, const TIterator& a, const TIterator& b) { return compare(*a, *b) ? a : b; } template + ETL_NODISCARD constexpr const TIterator& multimin_iter_compare(TCompare compare, const TIterator& t, const Tx&... tx) { return multimin_iter_compare(compare, t, multimin_iter_compare(compare, tx...)); diff --git a/include/etl/array.h b/include/etl/array.h index 748bfef4..e0167dd7 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); + etl::fill(begin(), end(), value); } //************************************************************************* @@ -351,9 +351,11 @@ namespace etl //************************************************************************* void swap(array& other) { + using ETL_OR_STD::swap; // Allow ADL + for (size_t i = 0; i < SIZE; ++i) { - ETL_STD::swap(_buffer[i], other._buffer[i]); + swap(_buffer[i], other._buffer[i]); } } @@ -367,7 +369,7 @@ namespace etl template void assign(TIterator first, const TIterator last) { - etl::copy(first, last, begin(), end()); + etl::copy_s(first, last, begin(), end()); } //************************************************************************* @@ -381,10 +383,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 = etl::copy_s(first, last, begin(), end()); // Default initialise any that are left. - ETL_STD::fill(p, end(), value); + etl::fill(p, end(), value); } //************************************************************************* @@ -406,7 +408,7 @@ namespace etl { iterator p = const_cast(position); - ETL_STD::copy_backward(p, end() - 1, end()); + etl::copy_backward(p, end() - 1, end()); *p = value; return p; @@ -436,18 +438,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 = etl::distance(first, last); + size_t destination_space = etl::distance(position, cend()); // Do we need to move anything? if (source_size < destination_space) { - size_t length = SIZE - (ETL_STD::distance(begin(), p) + source_size); - ETL_STD::copy_backward(p, p + length, end()); + size_t length = SIZE - (etl::distance(begin(), p) + source_size); + etl::copy_backward(p, p + length, end()); } // Copy from the range. - etl::copy(first, last, p, end()); + etl::copy_s(first, last, p, end()); return result; } @@ -470,7 +472,7 @@ namespace etl iterator erase(const_iterator position) { iterator p = const_cast(position); - ETL_STD::copy(p + 1, end(), p); + etl::copy(p + 1, end(), p); return p; } @@ -495,7 +497,7 @@ namespace etl iterator erase(const_iterator first, const_iterator last) { iterator p = const_cast(first); - ETL_STD::copy(last, cend(), p); + etl::copy(last, cend(), p); return p; } @@ -518,7 +520,7 @@ namespace etl { iterator p = const_cast(position); - ETL_STD::copy(p + 1, end(), p); + etl::copy(p + 1, end(), p); back() = value; return p; @@ -544,8 +546,8 @@ namespace etl { iterator p = const_cast(first); - p = ETL_STD::copy(last, cend(), p); - ETL_STD::fill(p, end(), value); + p = etl::copy(last, cend(), p); + etl::fill(p, end(), value); return const_cast(first); } @@ -574,7 +576,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 etl::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()); } //************************************************************************* @@ -598,7 +600,7 @@ namespace etl template bool operator <(const etl::array& lhs, const etl::array& rhs) { - return ETL_STD::lexicographical_compare(lhs.cbegin(), + return etl::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend()); diff --git a/include/etl/array_view.h b/include/etl/array_view.h index 1187e531..a682b665 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_) + etl::distance(begin_, end_)) { } @@ -356,7 +356,7 @@ namespace etl void assign(const TIterator begin_, const TIterator end_) { mbegin = etl::addressof(*begin_); - mend = etl::addressof(*begin_) + ETL_STD::distance(begin_, end_); + mend = etl::addressof(*begin_) + etl::distance(begin_, end_); } //************************************************************************* @@ -411,8 +411,10 @@ namespace etl //************************************************************************* void swap(array_view& other) { - ETL_STD::swap(mbegin, other.mbegin); - ETL_STD::swap(mend, other.mend); + using ETL_OR_STD::swap; // Allow ADL + + swap(mbegin, other.mbegin); + swap(mend, other.mend); } //************************************************************************* @@ -437,7 +439,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()); + etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -453,7 +455,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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/array_wrapper.h b/include/etl/array_wrapper.h index ab64120c..cf72edb2 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,7 +310,7 @@ namespace etl //************************************************************************* void fill(parameter_t value) { - ETL_STD::fill(begin(), end(), value); + etl::fill(begin(), end(), value); } //************************************************************************* @@ -320,9 +320,11 @@ namespace etl typename etl::enable_if::value, void>::type swap(etl::array_wrapper& other) { + using ETL_OR_STD::swap; // Allow ADL + for (size_t i = 0; i < SIZE; ++i) { - ETL_STD::swap(ARRAY_[i], other.begin()[i]); + swap(ARRAY_[i], other.begin()[i]); } } }; @@ -334,7 +336,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) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -354,7 +356,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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/basic_string.h b/include/etl/basic_string.h index bacb384c..0e5c56e8 100644 --- a/include/etl/basic_string.h +++ b/include/etl/basic_string.h @@ -37,10 +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" #include "alignment.h" @@ -282,11 +281,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 etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the string. @@ -418,12 +417,12 @@ namespace etl is_truncated = true; } - new_size = ETL_STD::min(new_size, CAPACITY); + new_size = etl::min(new_size, CAPACITY); // Size up? if (new_size > current_size) { - ETL_STD::fill(p_buffer + current_size, p_buffer + new_size, value); + etl::fill(p_buffer + current_size, p_buffer + new_size, value); } current_size = new_size; @@ -596,7 +595,7 @@ namespace etl is_truncated = (length_ > CAPACITY); - length_ = ETL_STD::min(length_, CAPACITY); + length_ = etl::min(length_, CAPACITY); etl::copy_n(other, length_, begin()); @@ -615,7 +614,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(string_iterator)); #endif @@ -643,9 +642,9 @@ namespace etl is_truncated = (n > CAPACITY); - n = ETL_STD::min(n, CAPACITY); + n = etl::min(n, CAPACITY); - ETL_STD::fill_n(begin(), n, value); + etl::fill_n(begin(), n, value); current_size = n; p_buffer[current_size] = 0; } @@ -780,7 +779,7 @@ namespace etl { // Insert in the middle. ++current_size; - ETL_STD::copy_backward(insert_position, end() - 1, end()); + etl::copy_backward(insert_position, end() - 1, end()); *insert_position = value; } else @@ -796,7 +795,7 @@ namespace etl if (position != end()) { // Insert in the middle. - ETL_STD::copy_backward(insert_position, end() - 1, end()); + etl::copy_backward(insert_position, end() - 1, end()); *insert_position = value; } @@ -823,7 +822,7 @@ namespace etl // Quick hack, as iterators are pointers. iterator insert_position = const_cast(position); - const size_t start = ETL_STD::distance(cbegin(), position); + const size_t start = etl::distance(cbegin(), position); // No effect. if (start >= CAPACITY) @@ -841,7 +840,7 @@ namespace etl } current_size = CAPACITY; - ETL_STD::fill(insert_position, end(), value); + etl::fill(insert_position, end(), value); } else { @@ -850,7 +849,7 @@ namespace etl const size_t to_position = start + shift_amount; const size_t remaining_characters = current_size - start; const size_t max_shift_characters = CAPACITY - start - shift_amount; - const size_t characters_to_shift = ETL_STD::min(max_shift_characters, remaining_characters); + const size_t characters_to_shift = etl::min(max_shift_characters, remaining_characters); // Will the string truncate? if ((start + shift_amount + remaining_characters) > CAPACITY) @@ -863,8 +862,8 @@ namespace etl current_size += shift_amount; } - 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); + etl::copy_backward(insert_position, insert_position + characters_to_shift, begin() + to_position + characters_to_shift); + etl::fill(insert_position, insert_position + shift_amount, value); } p_buffer[current_size] = 0; @@ -885,8 +884,8 @@ namespace etl return; } - const size_t start = ETL_STD::distance(begin(), position); - const size_t n = ETL_STD::distance(first, last); + const size_t start = etl::distance(begin(), position); + const size_t n = etl::distance(first, last); // No effect. if (start >= CAPACITY) @@ -917,7 +916,7 @@ namespace etl const size_t to_position = start + shift_amount; const size_t remaining_characters = current_size - start; const size_t max_shift_characters = CAPACITY - start - shift_amount; - const size_t characters_to_shift = ETL_STD::min(max_shift_characters, remaining_characters); + const size_t characters_to_shift = etl::min(max_shift_characters, remaining_characters); // Will the string truncate? if ((start + shift_amount + remaining_characters) > CAPACITY) @@ -930,7 +929,7 @@ namespace etl current_size += shift_amount; } - ETL_STD::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift); + etl::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift); while (first != last) { @@ -1037,7 +1036,7 @@ namespace etl etl::ibasic_string& erase(size_t position, size_t length_ = npos) { // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); erase(begin() + position, begin() + position + length_); @@ -1051,7 +1050,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - ETL_STD::copy(i_element + 1, end(), i_element); + etl::copy(i_element + 1, end(), i_element); p_buffer[--current_size] = 0; return i_element; @@ -1067,8 +1066,8 @@ namespace etl //********************************************************************* iterator erase(iterator first, iterator last) { - ETL_STD::copy(last, end(), first); - size_t n_delete = ETL_STD::distance(first, last); + etl::copy(last, end(), first); + size_t n_delete = etl::distance(first, last); current_size -= n_delete; p_buffer[current_size] = 0; @@ -1098,7 +1097,7 @@ namespace etl is_truncated = true; } - size_t endpos = ETL_STD::min(pos + len, size()); + size_t endpos = etl::min(pos + len, size()); for (size_t i = pos; i < endpos; ++i) { @@ -1120,7 +1119,7 @@ namespace etl return npos; } - const_iterator iposition = ETL_STD::search(begin() + pos, end(), str.begin(), str.end()); + const_iterator iposition = etl::search(begin() + pos, end(), str.begin(), str.end()); if (iposition == end()) { @@ -1128,7 +1127,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -1146,7 +1145,7 @@ namespace etl } #endif - const_iterator iposition = ETL_STD::search(begin() + pos, end(), s, s + etl::strlen(s)); + const_iterator iposition = etl::search(begin() + pos, end(), s, s + etl::strlen(s)); if (iposition == end()) { @@ -1154,7 +1153,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -1173,7 +1172,7 @@ namespace etl } #endif - const_iterator iposition = ETL_STD::search(begin() + pos, end(), s, s + n); + const_iterator iposition = etl::search(begin() + pos, end(), s, s + n); if (iposition == end()) { @@ -1181,7 +1180,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -1192,11 +1191,11 @@ namespace etl //********************************************************************* size_t find(T c, size_t position = 0) const { - const_iterator i = ETL_STD::find(begin() + position, end(), c); + const_iterator i = etl::find(begin() + position, end(), c); if (i != end()) { - return ETL_STD::distance(begin(), i); + return etl::distance(begin(), i); } else { @@ -1223,7 +1222,7 @@ namespace etl position = size() - position; - const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), str.rbegin(), str.rend()); + const_reverse_iterator iposition = etl::search(rbegin() + position, rend(), str.rbegin(), str.rend()); if (iposition == rend()) { @@ -1231,7 +1230,7 @@ namespace etl } else { - return size() - str.size() - ETL_STD::distance(rbegin(), iposition); + return size() - str.size() - etl::distance(rbegin(), iposition); } } @@ -1259,7 +1258,7 @@ namespace etl const_reverse_iterator srbegin(s + len); const_reverse_iterator srend(s); - const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), srbegin, srend); + const_reverse_iterator iposition = etl::search(rbegin() + position, rend(), srbegin, srend); if (iposition == rend()) { @@ -1267,7 +1266,7 @@ namespace etl } else { - return size() - len - ETL_STD::distance(rbegin(), iposition); + return size() - len - etl::distance(rbegin(), iposition); } } @@ -1293,7 +1292,7 @@ namespace etl const_reverse_iterator srbegin(s + length_); const_reverse_iterator srend(s); - const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), srbegin, srend); + const_reverse_iterator iposition = etl::search(rbegin() + position, rend(), srbegin, srend); if (iposition == rend()) { @@ -1301,7 +1300,7 @@ namespace etl } else { - return size() - length_ - ETL_STD::distance(rbegin(), iposition); + return size() - length_ - etl::distance(rbegin(), iposition); } } @@ -1319,11 +1318,11 @@ namespace etl position = size() - position; - const_reverse_iterator i = ETL_STD::find(rbegin() + position, rend(), c); + const_reverse_iterator i = etl::find(rbegin() + position, rend(), c); if (i != rend()) { - return size() - ETL_STD::distance(rbegin(), i) - 1; + return size() - etl::distance(rbegin(), i) - 1; } else { @@ -1342,7 +1341,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1388,8 +1387,8 @@ namespace etl ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds)); // Limit the lengths. - length_ = ETL_STD::min(length_, size() - position); - sublength = ETL_STD::min(sublength, str.size() - subposition); + length_ = etl::min(length_, size() - position); + sublength = etl::min(sublength, str.size() - subposition); // Erase the bit we want to replace. erase(position, length_); @@ -1413,7 +1412,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1450,7 +1449,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1487,7 +1486,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); // Erase the bit we want to replace. erase(position, length_); @@ -1554,7 +1553,7 @@ namespace etl ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds)); // Limit the length. - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); return compare(p_buffer + position, p_buffer + position + length_, @@ -1571,8 +1570,8 @@ namespace etl ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds)); // Limit the lengths. - length_ = ETL_STD::min(length_, size() - position); - sublength = ETL_STD::min(sublength, str.size() - subposition); + length_ = etl::min(length_, size() - position); + sublength = etl::min(sublength, str.size() - subposition); return compare(p_buffer + position, p_buffer + position + length_, @@ -1712,7 +1711,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1745,7 +1744,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1869,7 +1868,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -1907,7 +1906,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -2106,7 +2105,7 @@ namespace etl template bool operator ==(const etl::ibasic_string& lhs, const etl::ibasic_string& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2119,7 +2118,7 @@ namespace etl template bool operator ==(const etl::ibasic_string& lhs, const T* rhs) { - return (lhs.size() == etl::strlen(rhs)) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs); + return (lhs.size() == etl::strlen(rhs)) && etl::equal(lhs.begin(), lhs.end(), rhs); } //*************************************************************************** @@ -2132,7 +2131,7 @@ namespace etl template bool operator ==(const T* lhs, const etl::ibasic_string& rhs) { - return (rhs.size() == etl::strlen(lhs)) && ETL_STD::equal(rhs.begin(), rhs.end(), lhs); + return (rhs.size() == etl::strlen(lhs)) && etl::equal(rhs.begin(), rhs.end(), lhs); } @@ -2185,7 +2184,7 @@ namespace etl template bool operator <(const etl::ibasic_string& lhs, const etl::ibasic_string& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** @@ -2198,7 +2197,7 @@ namespace etl template bool operator <(const etl::ibasic_string& lhs, const T* rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs)); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs)); } //*************************************************************************** @@ -2211,7 +2210,7 @@ namespace etl template bool operator <(const T* lhs, const etl::ibasic_string& rhs) { - return ETL_STD::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end()); } diff --git a/include/etl/binary.h b/include/etl/binary.h index 104f75e6..f81f3d05 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" @@ -238,7 +238,7 @@ namespace etl 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(NBITS <= etl::numeric_limits::digits, "NBITS too large for return type"); struct S { @@ -260,8 +260,8 @@ namespace etl 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(NBITS <= etl::numeric_limits::digits, "NBITS too large for return type"); + ETL_STATIC_ASSERT(SHIFT <= etl::numeric_limits::digits, "SHIFT too large"); struct S { @@ -283,7 +283,7 @@ namespace etl ETL_STATIC_ASSERT(etl::is_integral::value, "TReturn not an integral type"); ETL_STATIC_ASSERT(etl::is_signed::value, "TReturn not a signed type"); - ETL_ASSERT((NBITS <= ETL_STD::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); + ETL_ASSERT((NBITS <= etl::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); TReturn mask = TReturn(1) << (NBITS - 1); value = value & static_cast((TReturn(1) << NBITS) - 1); @@ -304,7 +304,7 @@ namespace etl ETL_STATIC_ASSERT(etl::is_integral::value, "TReturn not an integral type"); ETL_STATIC_ASSERT(etl::is_signed::value, "TReturn not a signed type"); - ETL_ASSERT((NBITS <= ETL_STD::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); + ETL_ASSERT((NBITS <= etl::numeric_limits::digits), ETL_ERROR(binary_out_of_range)); TReturn mask = TReturn(1) << (NBITS - 1); value = (value >> SHIFT) & static_cast((TReturn(1) << NBITS) - 1); diff --git a/include/etl/bit_stream.h b/include/etl/bit_stream.h index 36a2c0b0..c662edd0 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(etl::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(etl::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_, etl::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_, etl::distance(begin_, end_)); } //*************************************************************************** @@ -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(etl::min(width, bits_in_byte)); unsigned char chunk = get_chunk(mask_width); width -= mask_width; @@ -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(etl::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(etl::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); + etl::reverse_copy(data, data + sizeof(T), temp); } else { - ETL_STD::copy(data, data + sizeof(T), temp); + etl::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); + etl::reverse_copy(pf, pf + sizeof(T), data); } else { - ETL_STD::copy(pf, pf + sizeof(T), data); + etl::copy(pf, pf + sizeof(T), data); } } diff --git a/include/etl/bitset.h b/include/etl/bitset.h index 89fdd9b9..9d71f50d 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 = etl::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 = etl::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 = etl::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 = etl::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 = etl::min(NBITS, etl::strlen(text)); while (i > 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 etl::equal(lhs.pdata, lhs.pdata + lhs.SIZE, rhs.pdata); } element_t TOP_MASK; diff --git a/include/etl/char_traits.h b/include/etl/char_traits.h index d0004d9b..36cffb37 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); + etl::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..90ceae28 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..efdea919 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]); } ///************************************************************************** @@ -296,7 +273,7 @@ namespace etl char(&array_size(T(&array)[ARRAY_SIZE]))[ARRAY_SIZE]; } -#if ETL_CPP11_SUPPORTED +#if ETL_CPP11_SUPPORTED && !defined(ETL_FORCE_NO_ADVANCED_CPP) #define ETL_ARRAY_SIZE(a) (etl::size(a)) #else #define ETL_ARRAY_SIZE(a) sizeof(etl::array_size(a)) diff --git a/include/etl/cstring.h b/include/etl/cstring.h index 958279ab..9dee9685 100644 --- a/include/etl/cstring.h +++ b/include/etl/cstring.h @@ -191,7 +191,7 @@ namespace etl { ETL_ASSERT(position < this->size(), ETL_ERROR(string_out_of_bounds)); - length_ = ETL_STD::min(length_, this->size() - position); + length_ = etl::min(length_, this->size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/include/etl/cyclic_value.h b/include/etl/cyclic_value.h index dadcb277..78277bfb 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,9 @@ namespace etl //************************************************************************* void swap(cyclic_value& other) { - ETL_STD::swap(value, other.value); + using ETL_OR_STD::swap; // Allow ADL + + swap(value, other.value); } //************************************************************************* @@ -531,9 +533,11 @@ 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); + using ETL_OR_STD::swap; // Allow ADL + + 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..522953e0 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 etl::iterator_traits::difference_type difference_type; protected: @@ -256,7 +256,7 @@ namespace etl //************************************************************************* /// Iterator //************************************************************************* - struct iterator : public etl::iterator + struct iterator : public etl::iterator { friend class ideque; @@ -421,7 +421,9 @@ namespace etl //*************************************************** void swap(iterator& other) { - ETL_STD::swap(index, other.index); + using ETL_OR_STD::swap; // Allow ADL + + swap(index, other.index); } private: @@ -442,7 +444,7 @@ namespace etl //************************************************************************* /// Const Iterator //************************************************************************* - struct const_iterator : public etl::iterator + struct const_iterator : public etl::iterator { friend class ideque; @@ -603,7 +605,7 @@ namespace etl //*************************************************** void swap(const_iterator& other) { - ETL_STD::swap(index, other.index); + swap(index, other.index); } private: @@ -634,8 +636,8 @@ 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. @@ -893,13 +895,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. *--position = value; @@ -910,7 +912,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. *position = value; @@ -935,38 +937,38 @@ namespace etl if (insert_position == begin()) { - create_element_front(ETL_STD::move(value)); + create_element_front(etl::move(value)); position = _begin; } else if (insert_position == end()) { - create_element_back(ETL_STD::move(value)); + create_element_back(etl::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 (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. - create_element_front(ETL_STD::move(*_begin)); + create_element_front(etl::move(*_begin)); // Move the values. - ETL_STD::move(_begin + 1, position, _begin); + etl::move(_begin + 1, position, _begin); // Write the new value. - *--position = ETL_STD::move(value); + *--position = etl::move(value); } else { // Construct the _end. - create_element_back(ETL_STD::move(*(_end - 1))); + create_element_back(etl::move(*(_end - 1))); // Move the values. - ETL_STD::move_backward(position, _end - 2, _end - 1); + etl::move_backward(position, _end - 2, _end - 1); // Write the new value. - *position = ETL_STD::move(value); + *position = etl::move(value); } } @@ -1008,13 +1010,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1027,7 +1029,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1035,7 +1037,7 @@ namespace etl } } - ::new (p) T(ETL_STD::forward(args)...); + ::new (p) T(etl::forward(args)...); return position; } @@ -1075,13 +1077,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1094,7 +1096,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1140,13 +1142,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1159,7 +1161,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1205,13 +1207,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1224,7 +1226,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1270,13 +1272,13 @@ namespace etl else { // Are we closer to the front? - if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1)) + if (etl::distance(_begin, position) < etl::distance(position, _end - 1)) { // Construct the _begin. create_element_front(*_begin); // Move the values. - ETL_STD::copy(_begin + 1, position, _begin); + etl::copy(_begin + 1, position, _begin); // Write the new value. --position; @@ -1289,7 +1291,7 @@ namespace etl create_element_back(*(_end - 1)); // Move the values. - ETL_STD::copy_backward(position, _end - 2, _end - 1); + etl::copy_backward(position, _end - 2, _end - 1); // Write the new value. (*position).~T(); @@ -1343,8 +1345,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 = etl::distance(begin(), position); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1372,15 +1374,15 @@ namespace etl // Copy new. to = position - n_create_copy; - ETL_STD::fill_n(to, n_copy_new, value); + etl::fill_n(to, n_copy_new, value); position = _begin + n_move; } else { size_t n_insert = n; - size_t n_move = ETL_STD::distance(position, end()); - size_t n_create_copy = ETL_STD::min(n_insert, n_move); + size_t n_move = etl::distance(position, end()); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1400,10 +1402,10 @@ namespace etl } // Copy old. - ETL_STD::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); + etl::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); // Copy new. - ETL_STD::fill_n(position, n_copy_new, value); + etl::fill_n(position, n_copy_new, value); } } @@ -1423,7 +1425,7 @@ namespace etl { iterator position; - difference_type n = ETL_STD::distance(range_begin, range_end); + difference_type n = etl::distance(range_begin, range_end); ETL_ASSERT((current_size + n) <= CAPACITY, ETL_ERROR(deque_full)); @@ -1451,8 +1453,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 = etl::distance(begin(), position); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1482,8 +1484,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 = etl::distance(position, end()); + size_t n_create_copy = etl::min(n_insert, n_move); size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0; size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0; size_t n_copy_old = n_move - n_create_copy; @@ -1504,7 +1506,7 @@ namespace etl } // Copy old. - ETL_STD::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); + etl::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old); // Copy new. item = range_begin; @@ -1541,13 +1543,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); + etl::copy_backward(_begin, position, position + 1); destroy_element_front(); ++position; } else { - ETL_STD::copy(position + 1, _end, position); + etl::copy(position + 1, _end, position); destroy_element_back(); } } @@ -1568,7 +1570,7 @@ namespace etl ETL_ASSERT((distance(range_begin) <= difference_type(current_size)) && (distance(range_end) <= difference_type(current_size)), ETL_ERROR(deque_out_of_bounds)); // How many to erase? - size_t length = ETL_STD::distance(range_begin, range_end); + size_t length = etl::distance(range_begin, range_end); // At the beginning? if (position == _begin) @@ -1597,7 +1599,7 @@ namespace etl if (distance(_begin, position) < difference_type(current_size / 2)) { // Move the items. - ETL_STD::copy_backward(_begin, position, position + length); + etl::copy_backward(_begin, position, position + length); for (size_t i = 0; i < length; ++i) { @@ -1610,7 +1612,7 @@ namespace etl // Must be closer to the back. { // Move the items. - ETL_STD::copy(position + length, _end, position); + etl::copy(position + length, _end, position); for (size_t i = 0; i < length; ++i) { @@ -1646,7 +1648,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(etl::move(item)); } #endif @@ -1662,7 +1664,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(deque_full)); #endif - ::new (&(*_end)) T(ETL_STD::forward(args)...); + ::new (&(*_end)) T(etl::forward(args)...); ++_end; ++current_size; ETL_INCREMENT_DEBUG_COUNT @@ -1774,7 +1776,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(etl::move(item)); } #endif @@ -1791,7 +1793,7 @@ namespace etl #endif --_begin; - ::new (&(*_begin)) T(ETL_STD::forward(args)...); + ::new (&(*_begin)) T(etl::forward(args)...); ++current_size; ETL_INCREMENT_DEBUG_COUNT } @@ -1965,7 +1967,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -2117,7 +2119,7 @@ namespace etl void create_element_front(rvalue_reference value) { --_begin; - ::new (&(*_begin)) T(ETL_STD::move(value)); + ::new (&(*_begin)) T(etl::move(value)); ++current_size; ETL_INCREMENT_DEBUG_COUNT } @@ -2127,7 +2129,7 @@ namespace etl //********************************************************************* void create_element_back(rvalue_reference value) { - ::new (&(*_end)) T(ETL_STD::move(value)); + ::new (&(*_end)) T(etl::move(value)); ++_end; ++current_size; ETL_INCREMENT_DEBUG_COUNT @@ -2233,7 +2235,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 etl::iterator_traits::difference_type difference_type; //************************************************************************* /// Default constructor. @@ -2278,7 +2280,7 @@ namespace etl typename etl::ideque::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2342,7 +2344,7 @@ namespace etl typename etl::ideque::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2384,7 +2386,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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -2410,10 +2412,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 etl::lexicographical_compare(lhs.begin(), + lhs.end(), + rhs.begin(), + rhs.end()); } //*************************************************************************** diff --git a/include/etl/fixed_iterator.h b/include/etl/fixed_iterator.h index 877babb6..ebe39467 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 etl::iterator_traits::value_type> { public: @@ -100,7 +100,7 @@ namespace etl //*************************************************************************** /// Dereference operator. //*************************************************************************** - typename ETL_STD::iterator_traits::value_type operator *() + typename etl::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 etl::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 etl::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 etl::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 etl::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 etl::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 etl::iterator_traits::difference_type operator -(etl::fixed_iterator& lhs, etl::fixed_iterator& rhs) { return TIterator(lhs) - TIterator(rhs); diff --git a/include/etl/flat_map.h b/include/etl/flat_map.h index 8375e9a9..66494873 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: @@ -72,7 +72,7 @@ namespace etl public: - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; typedef TKey key_type; typedef TMapped mapped_type; typedef TKeyCompare key_compare; @@ -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 etl::iterator_traits::difference_type difference_type; protected: @@ -232,7 +232,7 @@ namespace etl //********************************************************************* mapped_type& operator [](key_parameter_t key) { - return insert(ETL_MAKE_PAIR(key, mapped_type())).first->second; + return insert(ETL_OR_STD::make_pair(key, mapped_type())).first->second; } //********************************************************************* @@ -268,7 +268,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_map_full)); #endif @@ -285,11 +285,11 @@ namespace etl /// If asserts or exceptions are enabled, emits flat_map_full if the flat_map is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(const_reference value) + ETL_OR_STD::pair insert(const_reference value) { iterator i_element = lower_bound(value.first); - ETL_PAIR result(i_element, false); + ETL_OR_STD::pair result(i_element, false); // Doesn't already exist? if ((i_element == end()) || compare(value.first, i_element->first)) @@ -335,7 +335,7 @@ namespace etl //************************************************************************* /// Emplaces a value to the map. //************************************************************************* - ETL_PAIR emplace(const value_type& value) + ETL_OR_STD::pair emplace(const value_type& value) { return emplace(value.first, value.second); } @@ -345,18 +345,18 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, Args && ... args) + ETL_OR_STD::pair emplace(const key_type& key, Args && ... args) { ETL_ASSERT(!full(), ETL_ERROR(flat_map_full)); // 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(etl::forward(args)...); iterator i_element = lower_bound(key); - ETL_PAIR result(i_element, false); + ETL_OR_STD::pair result(i_element, false); // Doesn't already exist? if ((i_element == end()) || compare(key, i_element->first)) @@ -379,7 +379,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1) { ETL_ASSERT(!full(), ETL_ERROR(flat_map_full)); @@ -390,7 +390,7 @@ namespace etl iterator i_element = lower_bound(key); - ETL_PAIR result(i_element, false); + ETL_OR_STD::pair result(i_element, false); // Doesn't already exist? if ((i_element == end()) || compare(key, i_element->first)) @@ -411,7 +411,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1, const T2& value2) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1, const T2& value2) { ETL_ASSERT(!full(), ETL_ERROR(flat_map_full)); @@ -422,7 +422,7 @@ namespace etl iterator i_element = lower_bound(key); - ETL_PAIR result(i_element, false); + ETL_OR_STD::pair result(i_element, false); // Doesn't already exist? if ((i_element == end()) || compare(key, i_element->first)) @@ -443,7 +443,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3) { ETL_ASSERT(!full(), ETL_ERROR(flat_map_full)); @@ -454,7 +454,7 @@ namespace etl iterator i_element = lower_bound(key); - ETL_PAIR result(i_element, false); + ETL_OR_STD::pair result(i_element, false); // Doesn't already exist? if ((i_element == end()) || compare(key, i_element->first)) @@ -475,7 +475,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3, const T4& value4) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3, const T4& value4) { ETL_ASSERT(!full(), ETL_ERROR(flat_map_full)); @@ -486,7 +486,7 @@ namespace etl iterator i_element = lower_bound(key); - ETL_PAIR result(i_element, false); + ETL_OR_STD::pair result(i_element, false); // Doesn't already exist? if ((i_element == end()) || compare(key, i_element->first)) @@ -662,7 +662,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { return refmap_t::equal_range(key); } @@ -672,7 +672,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { return refmap_t::equal_range(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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -813,11 +813,11 @@ namespace etl /// A flat_map implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_map //*************************************************************************** - template > + template > class flat_map : public etl::iflat_map { public: diff --git a/include/etl/flat_multimap.h b/include/etl/flat_multimap.h index 0069ea92..d4066458 100644 --- a/include/etl/flat_multimap.h +++ b/include/etl/flat_multimap.h @@ -59,12 +59,12 @@ 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: - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; private: @@ -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 etl::iterator_traits::difference_type difference_type; protected: @@ -237,7 +237,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multimap_full)); #endif @@ -254,11 +254,11 @@ namespace etl /// If asserts or exceptions are enabled, emits flat_multimap_full if the flat_multimap is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(const value_type& value) + ETL_OR_STD::pair insert(const value_type& value) { ETL_ASSERT(!refmap_t::full(), ETL_ERROR(flat_multimap_full)); - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); iterator i_element = lower_bound(value.first); @@ -300,7 +300,7 @@ namespace etl //************************************************************************* /// Emplaces a value to the map. //************************************************************************* - ETL_PAIR emplace(const value_type& value) + ETL_OR_STD::pair emplace(const value_type& value) { return insert(value); } @@ -308,7 +308,7 @@ namespace etl //************************************************************************* /// Emplaces a value to the map. //************************************************************************* - ETL_PAIR emplace(const key_type& key, const mapped_type& value) + ETL_OR_STD::pair emplace(const key_type& key, const mapped_type& value) { ETL_ASSERT(!full(), ETL_ERROR(flat_multimap_full)); @@ -327,14 +327,14 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, Args && ... args) + ETL_OR_STD::pair emplace(const key_type& key, Args && ... args) { ETL_ASSERT(!full(), ETL_ERROR(flat_multimap_full)); // 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(etl::forward(args)...); iterator i_element = lower_bound(key); ETL_INCREMENT_DEBUG_COUNT @@ -346,7 +346,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1) { ETL_ASSERT(!full(), ETL_ERROR(flat_multimap_full)); @@ -364,7 +364,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1, const T2& value2) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1, const T2& value2) { ETL_ASSERT(!full(), ETL_ERROR(flat_multimap_full)); @@ -382,7 +382,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3) { ETL_ASSERT(!full(), ETL_ERROR(flat_multimap_full)); @@ -400,7 +400,7 @@ namespace etl /// Emplaces a value to the map. //************************************************************************* template - ETL_PAIR emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3, const T4& value4) + ETL_OR_STD::pair emplace(const key_type& key, const T1& value1, const T2& value2, const T3& value3, const T4& value4) { ETL_ASSERT(!full(), ETL_ERROR(flat_multimap_full)); @@ -423,7 +423,7 @@ namespace etl //********************************************************************* size_t erase(key_parameter_t key) { - ETL_PAIR range = equal_range(key); + ETL_OR_STD::pair range = equal_range(key); if (range.first == end()) { @@ -431,7 +431,7 @@ namespace etl } else { - size_t d = ETL_STD::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -571,7 +571,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { return refmap_t::equal_range(key); } @@ -581,7 +581,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { return refmap_t::equal_range(key); } @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -720,11 +720,11 @@ namespace etl /// A flat_multimap implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_multimap //*************************************************************************** - template > + template > class flat_multimap : public etl::iflat_multimap { public: diff --git a/include/etl/flat_multiset.h b/include/etl/flat_multiset.h index 931f61c6..23a793c7 100644 --- a/include/etl/flat_multiset.h +++ b/include/etl/flat_multiset.h @@ -57,7 +57,7 @@ namespace etl /// Can be used as a reference type for all flat_multisets containing a specific type. ///\ingroup flat_multiset //*************************************************************************** - template > + template > class iflat_multiset : private etl::ireference_flat_multiset { private: @@ -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 etl::iterator_traits::difference_type difference_type; protected: @@ -209,7 +209,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multiset_full)); #endif @@ -226,13 +226,13 @@ namespace etl /// If asserts or exceptions are enabled, emits flat_multiset_full if the flat_multiset is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(parameter_t value) + ETL_OR_STD::pair insert(parameter_t value) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full)); - iterator i_element = ETL_STD::lower_bound(begin(), end(), value, compare); + iterator i_element = etl::lower_bound(begin(), end(), value, compare); value_type* pvalue = storage.allocate(); ::new (pvalue) value_type(value); @@ -273,7 +273,7 @@ namespace etl /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(parameter_t value) + ETL_OR_STD::pair emplace(parameter_t value) { return insert(value); } @@ -283,25 +283,25 @@ namespace etl //************************************************************************* #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) template - ETL_PAIR emplace(Args && ... args) + ETL_OR_STD::pair emplace(Args && ... args) { ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full)); // Create it. value_type* pvalue = storage.allocate(); - ::new (pvalue) value_type(ETL_STD::forward(args)...); + ::new (pvalue) value_type(etl::forward(args)...); iterator i_element = lower_bound(*pvalue); ETL_INCREMENT_DEBUG_COUNT - return ETL_PAIR(refset_t::insert_at(i_element, *pvalue)); + return ETL_OR_STD::pair(refset_t::insert_at(i_element, *pvalue)); } #else //************************************************************************* /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1) + ETL_OR_STD::pair emplace(const T1& value1) { ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full)); @@ -312,14 +312,14 @@ namespace etl iterator i_element = lower_bound(*pvalue); ETL_INCREMENT_DEBUG_COUNT - return ETL_PAIR(refset_t::insert_at(i_element, *pvalue)); + return ETL_OR_STD::pair(refset_t::insert_at(i_element, *pvalue)); } //************************************************************************* /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1, const T2& value2) + ETL_OR_STD::pair emplace(const T1& value1, const T2& value2) { ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full)); @@ -330,14 +330,14 @@ namespace etl iterator i_element = lower_bound(*pvalue); ETL_INCREMENT_DEBUG_COUNT - return ETL_PAIR(refset_t::insert_at(i_element, *pvalue)); + return ETL_OR_STD::pair(refset_t::insert_at(i_element, *pvalue)); } //************************************************************************* /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1, const T2& value2, const T3& value3) + ETL_OR_STD::pair emplace(const T1& value1, const T2& value2, const T3& value3) { ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full)); @@ -348,14 +348,14 @@ namespace etl iterator i_element = lower_bound(*pvalue); ETL_INCREMENT_DEBUG_COUNT - return ETL_PAIR(refset_t::insert_at(i_element, *pvalue)); + return ETL_OR_STD::pair(refset_t::insert_at(i_element, *pvalue)); } //************************************************************************* /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4) + ETL_OR_STD::pair emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4) { ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full)); @@ -366,7 +366,7 @@ namespace etl iterator i_element = lower_bound(*pvalue); ETL_INCREMENT_DEBUG_COUNT - return ETL_PAIR(refset_t::insert_at(i_element, *pvalue)); + return ETL_OR_STD::pair(refset_t::insert_at(i_element, *pvalue)); } #endif @@ -377,7 +377,7 @@ namespace etl //********************************************************************* size_t erase(parameter_t key) { - ETL_PAIR range = equal_range(key); + ETL_OR_STD::pair range = equal_range(key); if (range.first == end()) { @@ -385,7 +385,7 @@ namespace etl } else { - size_t d = ETL_STD::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -525,7 +525,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) + ETL_OR_STD::pair equal_range(parameter_t key) { return refset_t::equal_range(key); } @@ -535,7 +535,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) const + ETL_OR_STD::pair equal_range(parameter_t key) const { return refset_t::equal_range(key); } @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -675,11 +675,11 @@ namespace etl //*************************************************************************** /// A flat_multiset implementation that uses a fixed size buffer. ///\tparam T The value type. - ///\tparam TCompare The type to compare keys. Default = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_multiset //*************************************************************************** - template > + template > class flat_multiset : public etl::iflat_multiset { public: diff --git a/include/etl/flat_set.h b/include/etl/flat_set.h index 9b0e2d76..ff2aac95 100644 --- a/include/etl/flat_set.h +++ b/include/etl/flat_set.h @@ -59,7 +59,7 @@ namespace etl /// Can be used as a reference type for all flat_sets containing a specific type. ///\ingroup flat_set //*************************************************************************** - template > + template > class iflat_set : private etl::ireference_flat_set { private: @@ -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 etl::iterator_traits::difference_type difference_type; protected: @@ -211,7 +211,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full)); #endif @@ -228,11 +228,11 @@ namespace etl /// If asserts or exceptions are enabled, emits flat_set_full if the flat_set is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(parameter_t value) + ETL_OR_STD::pair insert(parameter_t value) { iterator i_element = lower_bound(value); - ETL_PAIR result(i_element, false); + ETL_OR_STD::pair result(i_element, false); // Doesn't already exist? if ((i_element == end()) || compare(value, *i_element)) @@ -278,7 +278,7 @@ namespace etl //************************************************************************* /// Emplaces a value to the set. //************************************************************************* - ETL_PAIR emplace(parameter_t value) + ETL_OR_STD::pair emplace(parameter_t value) { return insert(value); } @@ -288,15 +288,15 @@ namespace etl //************************************************************************* #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) template - ETL_PAIR emplace(Args && ... args) + ETL_OR_STD::pair emplace(Args && ... args) { ETL_ASSERT(!full(), ETL_ERROR(flat_set_full)); - ETL_PAIR result; + ETL_OR_STD::pair result; // Create it. value_type* pvalue = storage.allocate(); - ::new (pvalue) value_type(ETL_STD::forward(args)...); + ::new (pvalue) value_type(etl::forward(args)...); iterator i_element = lower_bound(*pvalue); @@ -311,7 +311,7 @@ namespace etl // Destroy it. pvalue->~value_type(); storage.release(pvalue); - result = ETL_PAIR(end(), false); + result = ETL_OR_STD::pair(end(), false); } return result; @@ -321,11 +321,11 @@ namespace etl /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1) + ETL_OR_STD::pair emplace(const T1& value1) { ETL_ASSERT(!full(), ETL_ERROR(flat_set_full)); - ETL_PAIR result; + ETL_OR_STD::pair result; // Create it. value_type* pvalue = storage.allocate(); @@ -344,7 +344,7 @@ namespace etl // Destroy it. pvalue->~value_type(); storage.release(pvalue); - result = ETL_PAIR(end(), false); + result = ETL_OR_STD::pair(end(), false); } return result; @@ -354,11 +354,11 @@ namespace etl /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1, const T2& value2) + ETL_OR_STD::pair emplace(const T1& value1, const T2& value2) { ETL_ASSERT(!full(), ETL_ERROR(flat_set_full)); - ETL_PAIR result; + ETL_OR_STD::pair result; // Create it. value_type* pvalue = storage.allocate(); @@ -377,7 +377,7 @@ namespace etl // Destroy it. pvalue->~value_type(); storage.release(pvalue); - result = ETL_PAIR(end(), false); + result = ETL_OR_STD::pair(end(), false); } return result; @@ -387,11 +387,11 @@ namespace etl /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1, const T2& value2, const T3& value3) + ETL_OR_STD::pair emplace(const T1& value1, const T2& value2, const T3& value3) { ETL_ASSERT(!full(), ETL_ERROR(flat_set_full)); - ETL_PAIR result; + ETL_OR_STD::pair result; // Create it. value_type* pvalue = storage.allocate(); @@ -410,7 +410,7 @@ namespace etl // Destroy it. pvalue->~value_type(); storage.release(pvalue); - result = ETL_PAIR(end(), false); + result = ETL_OR_STD::pair(end(), false); } return result; @@ -420,11 +420,11 @@ namespace etl /// Emplaces a value to the set. //************************************************************************* template - ETL_PAIR emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4) + ETL_OR_STD::pair emplace(const T1& value1, const T2& value2, const T3& value3, const T4& value4) { ETL_ASSERT(!full(), ETL_ERROR(flat_set_full)); - ETL_PAIR result; + ETL_OR_STD::pair result; // Create it. value_type* pvalue = storage.allocate(); @@ -443,7 +443,7 @@ namespace etl // Destroy it. pvalue->~value_type(); storage.release(pvalue); - result = ETL_PAIR(end(), false); + result = ETL_OR_STD::pair(end(), false); } return result; @@ -608,7 +608,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) + ETL_OR_STD::pair equal_range(parameter_t key) { return refset_t::equal_range(key); } @@ -618,7 +618,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) const + ETL_OR_STD::pair equal_range(parameter_t key) const { return refset_t::upper_bound(key); } @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -758,11 +758,11 @@ namespace etl //*************************************************************************** /// A flat_set implementation that uses a fixed size buffer. ///\tparam T The value type. - ///\tparam TCompare The type to compare keys. Default = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup flat_set //*************************************************************************** - template > + template > class flat_set : public etl::iflat_set { public: diff --git a/include/etl/forward_list.h b/include/etl/forward_list.h index 76e03ac8..5a551d77 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 etl::iterator_traits::difference_type difference_type; //************************************************************************* /// Gets the beginning of the forward_list. @@ -671,7 +671,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(forward_list_iterator)); #endif @@ -735,7 +735,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); #endif - data_node_t& data_node = allocate_data_node(ETL_STD::move(value)); + data_node_t& data_node = allocate_data_node(etl::move(value)); insert_node_after(start_node, data_node); } #endif @@ -751,7 +751,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); #endif data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node_after(start_node, *p_data_node); } @@ -907,7 +907,7 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node_after(*position.p_node, *p_data_node); @@ -1001,7 +1001,7 @@ namespace etl void insert_after(iterator position, TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT((d + size()) <= MAX_SIZE, ETL_ERROR(forward_list_full)); #endif @@ -1141,7 +1141,7 @@ namespace etl //************************************************************************* void unique() { - unique(ETL_STD::equal_to()); + unique(etl::equal_to()); } //************************************************************************* @@ -1182,7 +1182,7 @@ namespace etl //************************************************************************* void sort() { - sort(ETL_STD::less()); + sort(etl::less()); } //************************************************************************* @@ -1386,7 +1386,7 @@ namespace etl //************************************************************************* iforward_list& operator = (iforward_list&& rhs) { - move_container(ETL_STD::move(rhs)); + move_container(etl::move(rhs)); return *this; } @@ -1460,7 +1460,7 @@ namespace etl data_node_t& allocate_data_node(rvalue_reference value) { data_node_t* p_node = p_node_pool->allocate(); - ::new (&(p_node->value)) T(ETL_STD::move(value)); + ::new (&(p_node->value)) T(etl::move(value)); ETL_INCREMENT_DEBUG_COUNT return *p_node; @@ -1487,7 +1487,7 @@ namespace etl { ETL_ASSERT(!full(), ETL_ERROR(forward_list_full)); - data_node_t& data_node = this->allocate_data_node(ETL_STD::move(*first++)); + data_node_t& data_node = this->allocate_data_node(etl::move(*first++)); join(p_last_node, &data_node); data_node.next = nullptr; p_last_node = &data_node; @@ -1633,7 +1633,7 @@ namespace etl forward_list(forward_list&& other) : etl::iforward_list(node_pool, MAX_SIZE, false) { - this->move_container(ETL_STD::move(other)); + this->move_container(etl::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(etl::move(rhs)); return *this; } @@ -1774,7 +1774,7 @@ namespace etl typename etl::iforward_list::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::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(etl::move(rhs)); return *this; } @@ -1862,7 +1862,7 @@ namespace etl bool operator ==(const etl::iforward_list& lhs, const etl::iforward_list& rhs) { return (lhs.size() == rhs.size()) && - ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + etl::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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/frame_check_sequence.h b/include/etl/frame_check_sequence.h index a1ed9028..31168c59 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"); @@ -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 etl::iterator_traits::value_type) == 1, "Type not supported"); reset(); add(begin, end); @@ -96,7 +96,7 @@ namespace etl template void add(TIterator begin, const TIterator end) { - ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Type not supported"); while (begin != end) { diff --git a/include/etl/functional.h b/include/etl/functional.h index 68300759..a540f3a7 100644 --- a/include/etl/functional.h +++ b/include/etl/functional.h @@ -105,6 +105,138 @@ namespace etl { return reference_wrapper(t.get()); } + + //*************************************************************************** + template + struct less + { + typedef T value_type; + + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const + { + return lhs < rhs; + } + }; + + //*************************************************************************** + template + struct greater + { + typedef T value_type; + + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const + { + return lhs > rhs; + } + }; + + //*************************************************************************** + template + struct equal_to + { + typedef T value_type; + + ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const + { + return lhs == rhs; + } + }; + + //*************************************************************************** + template + struct not_equal_to + { + typedef T value_type; + + 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 etl::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 etl::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/generate_type_traits.bat b/include/etl/generate_type_traits.bat index 39366a70..a1e5f97b 100644 --- a/include/etl/generate_type_traits.bat +++ b/include/etl/generate_type_traits.bat @@ -1 +1 @@ -python -m cogapp -d -e -otype_traits.h -DIsOneOf=17 type_traits_generator.h +python -m cogapp -d -e -otype_traits.h -DIsOneOf=16 type_traits_generator.h diff --git a/include/etl/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..09511ddb 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((etl::is_same::type, typename etl::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::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(etl::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(etl::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(etl::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(etl::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(etl::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(etl::move(*itr)); ++itr; } @@ -1172,7 +1171,7 @@ namespace etl while (itr != other.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etl::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()) && etl::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 etl::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(etl::move(other)); } //************************************************************************* @@ -1384,7 +1383,7 @@ namespace etl //************************************************************************* indirect_vector& operator = (indirect_vector&& rhs) { - this->move_container(ETL_STD::move(rhs)); + this->move_container(etl::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(etl::move(other)); } //************************************************************************* @@ -1512,7 +1511,7 @@ namespace etl //************************************************************************* indirect_vector& operator = (indirect_vector&& rhs) { - this->move_container(ETL_STD::move(rhs)); + this->move_container(etl::move(rhs)); return *this; } diff --git a/include/etl/integral_limits.h b/include/etl/integral_limits.h index 2c95c0a3..3a33bbde 100644 --- a/include/etl/integral_limits.h +++ b/include/etl/integral_limits.h @@ -31,7 +31,6 @@ SOFTWARE. #ifndef ETL_INTEGRAL_LIMITS_INCLUDED #define ETL_INTEGRAL_LIMITS_INCLUDED -#include #include #include "platform.h" diff --git a/include/etl/intrusive_forward_list.h b/include/etl/intrusive_forward_list.h index 879865f5..48ed3972 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 = etl::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 etl::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 -= etl::distance(first, last) - 1; link_type* p_first = first.p_value; link_type* p_last = last.p_value; @@ -712,7 +712,7 @@ namespace etl //************************************************************************* void sort() { - sort(ETL_STD::less()); + sort(etl::less()); } //************************************************************************* @@ -958,7 +958,7 @@ namespace etl { if (&other != this) { - size_t n = ETL_STD::distance(begin_, end_) - 1; + size_t n = etl::distance(begin_, end_) - 1; this->current_size += n; other.current_size -= n; } @@ -987,7 +987,7 @@ namespace etl //************************************************************************* void merge(list_type& other) { - merge(other, ETL_STD::less()); + merge(other, etl::less()); } //************************************************************************* diff --git a/include/etl/intrusive_links.h b/include/etl/intrusive_links.h index d018f4e8..c8149514 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" @@ -265,7 +265,9 @@ namespace etl void reverse() { - ETL_STD::swap(etl_previous, etl_next); + using ETL_OR_STD::swap; // Allow ADL + + swap(etl_previous, etl_next); } bidirectional_link* etl_previous; diff --git a/include/etl/intrusive_list.h b/include/etl/intrusive_list.h index 059bb121..f618ef9b 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 = etl::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 etl::iterator_traits::difference_type difference_type; //************************************************************************* /// Constructor. @@ -734,7 +734,7 @@ namespace etl // Join the ends. etl::link(p_first->etl_previous, p_last); - this->current_size -= ETL_STD::distance(first, last); + this->current_size -= etl::distance(first, last); if (p_last == &this->terminal_link) { @@ -781,7 +781,7 @@ namespace etl //************************************************************************* void sort() { - sort(ETL_STD::less()); + sort(etl::less()); } //************************************************************************* @@ -1013,7 +1013,7 @@ namespace etl { if (&other != this) { - size_t n = ETL_STD::distance(begin_, end_); + size_t n = etl::distance(begin_, end_); this->current_size += n; other.current_size -= n; } @@ -1036,7 +1036,7 @@ namespace etl //************************************************************************* void merge(list_type& other) { - merge(other, ETL_STD::less()); + merge(other, etl::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..5ca901c6 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 { + //*************************************************************************** + // 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 etl::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 etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::input_iterator_tag) + { + typename etl::iterator_traits::difference_type d = 0; + + while (first != last) + { + ++d; + ++first; + } + + return d; + } + + template + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::forward_iterator_tag) + { + typename etl::iterator_traits::difference_type d = 0; + + while (first != last) + { + ++d; + ++first; + } + + return d; + } + + template + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::bidirectional_iterator_tag) + { + typename etl::iterator_traits::difference_type d = 0; + + while (first != last) + { + ++d; + ++first; + } + + return d; + } + + template + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::random_access_iterator_tag) + { + return last - first; + } + + template + ETL_CONSTEXPR17 typename etl::iterator_traits::difference_type distance(TIterator first, TIterator last) + { + typedef typename etl::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 etl::iterator_traits::difference_type n = 1) + { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + etl::advance(itr, -n); +#else + std::advance(itr, -n); +#endif + return itr; + } + + //*************************************************************************** + // Next + template + ETL_CONSTEXPR17 TIterator next(TIterator itr, typename etl::iterator_traits::difference_type n = 1) + { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + etl::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 = etl::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 = etl::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 = etl::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 = etl::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 = etl::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..5880d907 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 etl::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 diff --git a/include/etl/largest_generator.h b/include/etl/largest_generator.h index 0dd78c85..dfd05dd7 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 etl::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 diff --git a/include/etl/limits.h b/include/etl/limits.h new file mode 100644 index 00000000..7e033dd2 --- /dev/null +++ b/include/etl/limits.h @@ -0,0 +1,586 @@ +///\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_LIMITS_INCLUDED +#define ETL_LIMITS_INCLUDED + +#include "etl/platform.h" +#include "etl/type_traits.h" +#include "etl/char_traits.h" +#include "etl/integral_limits.h" + +#include +#include +#include +#include + +#if defined(ETL_NO_STL) +#define ETL_LOG10_OF_2(x) (((x) * 301) / 1000) + +namespace etl +{ + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3, + }; + + enum float_denorm_style + { + denorm_indeterminate = -1, + denorm_absent = 0, + denorm_present = 1 + }; + + class etl_integral_limits + { + public: + + static const bool is_specialized = true; + static const bool is_integer = true; + static const bool is_exact = true; + static const int max_digits10 = 0; + static const int radix = 2; + static const int min_exponent = 0; + static const int min_exponent10 = 0; + static const int max_exponent = 0; + static const int max_exponent10 = 0; + static const bool has_infinity = false; + static const bool has_quiet_NaN = false; + static const bool has_signaling_NaN = false; + static const bool has_denorm_loss = false; + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool traps = false; + static const bool tinyness_before = false; + static const float_denorm_style has_denorm = denorm_absent; + static const float_round_style round_style = round_toward_zero; + }; + + class etl_floating_point_limits + { + public: + + static const bool is_specialized = true; + static const bool is_signed = true; + static const bool is_integer = false; + static const bool is_exact = false; + static const int radix = 2; + static const bool has_infinity = true; + static const bool has_quiet_NaN = true; + static const bool has_signaling_NaN = true; + static const bool has_denorm_loss = false; + static const bool is_iec559 = false; + static const bool is_bounded = true; + static const bool is_modulo = false; + static const bool traps = false; + static const bool tinyness_before = false; + static const float_denorm_style has_denorm = denorm_indeterminate; + static const float_round_style round_style = round_indeterminate; + + static const float round_error() { return float(0.5); } + }; + + //*************************************************************************** + // Default + template + class numeric_limits; + + template + class numeric_limits : public numeric_limits { }; + + template + class numeric_limits : public numeric_limits { }; + + template + class numeric_limits : public numeric_limits { }; + + //*************************************************************************** + // bool + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = 1; + static const int digits10 = 0; + static const bool is_signed = false; + static const bool is_modulo = false; + + static const bool min() { return false; } + static const bool max() { return true; } + static const bool lowest() { return false; } + static const bool epsilon() { return false; } + static const bool round_error() { return false; } + static const bool denorm_min() { return false; } + static const bool infinity() { return false; } + static const bool quiet_NaN() { return false; } + static const bool signaling_NaN() { return false; } + }; + + //*************************************************************************** + // char + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(char)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = etl::is_signed::value; + static const bool is_modulo = false; + + static const char min() { return char(CHAR_MIN); } + static const char max() { return char(CHAR_MAX); } + static const char lowest() { return char(CHAR_MIN); } + static const char epsilon() { return 0; } + static const char round_error() { return 0; } + static const char denorm_min() { return 0; } + static const char infinity() { return 0; } + static const char quiet_NaN() { return 0; } + static const char signaling_NaN() { return 0; } + }; + + //*************************************************************************** + // unsigned char + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(unsigned char)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = false; + static const bool is_modulo = true; + + static const unsigned char min() { return 0U; } + static const unsigned char max() { return UCHAR_MAX; } + static const unsigned char lowest() { return 0U; } + static const unsigned char epsilon() { return 0U; } + static const unsigned char round_error() { return 0U; } + static const unsigned char denorm_min() { return 0U; } + static const unsigned char infinity() { return 0U; } + static const unsigned char quiet_NaN() { return 0U; } + static const unsigned char signaling_NaN() { return 0U; } + }; + + //*************************************************************************** + // signed char + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(char)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = true; + static const bool is_modulo = false; + + static const signed char min() { return SCHAR_MIN; } + static const signed char max() { return SCHAR_MAX; } + static const signed char lowest() { return SCHAR_MIN; } + static const signed char epsilon() { return 0; } + static const signed char round_error() { return 0; } + static const signed char denorm_min() { return 0; } + static const signed char infinity() { return 0; } + static const signed char quiet_NaN() { return 0; } + static const signed char signaling_NaN() { return 0; } + }; + +#if (ETL_NO_LARGE_CHAR_SUPPORT == false) + //*************************************************************************** + // char16_t + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(char16_t)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = false; + static const bool is_modulo = true; + + static const char16_t min() { return 0U; } + static const char16_t max() { return UINT_LEAST16_MAX; } + static const char16_t lowest() { return 0U; } + static const char16_t epsilon() { return 0U; } + static const char16_t round_error() { return 0U; } + static const char16_t denorm_min() { return 0U; } + static const char16_t infinity() { return 0U; } + static const char16_t quiet_NaN() { return 0U; } + static const char16_t signaling_NaN() { return 0U; } + }; + + //*************************************************************************** + // char32_t + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(char32_t)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = false; + static const bool is_modulo = true; + + static const char32_t min() { return 0U; } + static const char32_t max() { return UINT_LEAST32_MAX; } + static const char32_t lowest() { return 0U; } + static const char32_t epsilon() { return 0U; } + static const char32_t round_error() { return 0U; } + static const char32_t denorm_min() { return 0U; } + static const char32_t infinity() { return 0U; } + static const char32_t quiet_NaN() { return 0U; } + static const char32_t signaling_NaN() { return 0U; } + }; + +#endif + + //*************************************************************************** + // wchar_t + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(wchar_t)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = etl::is_signed::value; + static const bool is_modulo = etl::is_unsigned::value; + + static const wchar_t min() { return WCHAR_MIN; } + static const wchar_t max() { return WCHAR_MAX; } + static const wchar_t lowest() { return WCHAR_MIN; } + static const wchar_t epsilon() { return wchar_t(0); } + static const wchar_t round_error() { return wchar_t(0); } + static const wchar_t denorm_min() { return wchar_t(0); } + static const wchar_t infinity() { return wchar_t(0); } + static const wchar_t quiet_NaN() { return wchar_t(0); } + static const wchar_t signaling_NaN() { return wchar_t(0); } + }; + + //*************************************************************************** + // short + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(short)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = true; + static const bool is_modulo = false; + + static const short min() { return SHRT_MIN; } + static const short max() { return SHRT_MAX; } + static const short lowest() { return SHRT_MIN; } + static const short epsilon() { return 0; } + static const short round_error() { return 0; } + static const short denorm_min() { return 0; } + static const short infinity() { return 0; } + static const short quiet_NaN() { return 0; } + static const short signaling_NaN() { return 0; } + }; + + //*************************************************************************** + // unsigned short + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(unsigned short)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = false; + static const bool is_modulo = true; + + static const unsigned short min() { return 0U; } + static const unsigned short max() { return USHRT_MAX; } + static const unsigned short lowest() { return 0U; } + static const unsigned short epsilon() { return 0U; } + static const unsigned short round_error() { return 0U; } + static const unsigned short denorm_min() { return 0U; } + static const unsigned short infinity() { return 0U; } + static const unsigned short quiet_NaN() { return 0U; } + static const unsigned short signaling_NaN() { return 0U; } + + }; + + //*************************************************************************** + // int + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(int)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = true; + static const bool is_modulo = false; + + static const int min() { return INT_MIN; } + static const int max() { return INT_MAX; } + static const int lowest() { return INT_MIN; } + static const int epsilon() { return 0; } + static const int round_error() { return 0; } + static const int denorm_min() { return 0; } + static const int infinity() { return 0; } + static const int quiet_NaN() { return 0; } + static const int signaling_NaN() { return 0; } + }; + + //*************************************************************************** + // unsigned int + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(unsigned int)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = false; + static const bool is_modulo = true; + + static const unsigned int min() { return 0U; } + static const unsigned int max() { return UINT_MAX; } + static const unsigned int lowest() { return 0U; } + static const unsigned int epsilon() { return 0U; } + static const unsigned int round_error() { return 0U; } + static const unsigned int denorm_min() { return 0U; } + static const unsigned int infinity() { return 0U; } + static const unsigned int quiet_NaN() { return 0U; } + static const unsigned int signaling_NaN() { return 0U; } + }; + + //*************************************************************************** + // long + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = true; + static const bool is_modulo = false; + + static const long min() { return LONG_MIN; } + static const long max() { return LONG_MAX; } + static const long lowest() { return LONG_MIN; } + static const long epsilon() { return 0; } + static const long round_error() { return 0; } + static const long denorm_min() { return 0; } + static const long infinity() { return 0; } + static const long quiet_NaN() { return 0; } + static const long signaling_NaN() { return 0; } + }; + + //*************************************************************************** + // unsigned long + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(unsigned long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = false; + static const bool is_modulo = true; + + static const unsigned long min() { return 0U; } + static const unsigned long max() { return ULONG_MAX; } + static const unsigned long lowest() { return 0U; } + static const unsigned long epsilon() { return 0U; } + static const unsigned long round_error() { return 0U; } + static const unsigned long denorm_min() { return 0U; } + static const unsigned long infinity() { return 0U; } + static const unsigned long quiet_NaN() { return 0U; } + static const unsigned long signaling_NaN() { return 0U; } + }; + + //*************************************************************************** + // long long + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(long long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = true; + static const bool is_modulo = false; + + static const long long min() { return LLONG_MIN; } + static const long long max() { return LLONG_MAX; } + static const long long lowest() { return LLONG_MIN; } + static const long long epsilon() { return 0; } + static const long long round_error() { return 0; } + static const long long denorm_min() { return 0; } + static const long long infinity() { return 0; } + static const long long quiet_NaN() { return 0; } + static const long long signaling_NaN() { return 0; } + }; + + //*************************************************************************** + // unsigned long long + template<> + class numeric_limits : public etl_integral_limits + { + public: + + static const int digits = (CHAR_BIT * sizeof(unsigned long long)) - (etl::is_signed::value ? 1 : 0); + static const int digits10 = ETL_LOG10_OF_2(digits); + static const bool is_signed = false; + static const bool is_modulo = true; + + static const unsigned long long min() { return 0U; } + static const unsigned long long max() { return ULLONG_MAX; } + static const unsigned long long lowest() { return 0U; } + static const unsigned long long epsilon() { return 0U; } + static const unsigned long long round_error() { return 0U; } + static const unsigned long long denorm_min() { return 0U; } + static const unsigned long long infinity() { return 0U; } + static const unsigned long long quiet_NaN() { return 0U; } + static const unsigned long long signaling_NaN() { return 0U; } + }; + + //*************************************************************************** + // float + template<> + class numeric_limits : public etl_floating_point_limits + { + public: + + static const float min() { return FLT_MIN; } + static const float max() { return FLT_MAX; } + static const float lowest() { return -FLT_MAX; } + static const float epsilon() { return FLT_EPSILON; } + static const float denorm_min() { return FLT_MIN; } + static const float infinity() { return HUGE_VALF; } + static const float quiet_NaN() { return nanf(""); } + static const float signaling_NaN() { return nanf(""); } + + static const int digits = FLT_MANT_DIG; + static const int digits10 = FLT_DIG; + static const int max_digits10 = ETL_LOG10_OF_2(FLT_MANT_DIG) + 2; + + static const int min_exponent = FLT_MIN_EXP; + static const int min_exponent10 = FLT_MIN_10_EXP; + static const int max_exponent = FLT_MAX_EXP; + static const int max_exponent10 = FLT_MAX_10_EXP; + }; + + //*************************************************************************** + // double + template<> + class numeric_limits : public etl_floating_point_limits + { + public: + + static const double min() { return DBL_MIN; } + static const double max() { return DBL_MAX; } + static const double lowest() { return -DBL_MAX; } + static const double epsilon() { return DBL_EPSILON; } + static const double denorm_min() { return DBL_MIN; } + static const double infinity() { return HUGE_VAL; } + static const double quiet_NaN() { return nan(""); } + static const double signaling_NaN() { return nan(""); } + + static const int digits = DBL_MANT_DIG; + static const int digits10 = DBL_DIG; + static const int max_digits10 = ETL_LOG10_OF_2(DBL_MANT_DIG) + 2; + + static const int min_exponent = DBL_MIN_EXP; + static const int min_exponent10 = DBL_MIN_10_EXP; + static const int max_exponent = DBL_MAX_EXP; + static const int max_exponent10 = DBL_MAX_10_EXP; + }; + + //*************************************************************************** + // long double + template<> + class numeric_limits : public etl_floating_point_limits + { + public: + + static const long double min() { return LDBL_MIN; } + static const long double max() { return LDBL_MAX; } + static const long double lowest() { return -LDBL_MAX; } + static const long double epsilon() { return LDBL_EPSILON; } + static const long double denorm_min() { return LDBL_MIN; } + static const long double infinity() { return HUGE_VALL; } + static const long double quiet_NaN() { return nanl(""); } + static const long double signaling_NaN() { return nanl(""); } + + + static const int digits = LDBL_MANT_DIG; + static const int digits10 = LDBL_DIG; + static const int max_digits10 = ETL_LOG10_OF_2(LDBL_MANT_DIG) + 2; + + static const int min_exponent = LDBL_MIN_EXP; + static const int min_exponent10 = LDBL_MIN_10_EXP; + static const int max_exponent = LDBL_MAX_EXP; + static const int max_exponent10 = LDBL_MAX_10_EXP; + }; +} + +#else + +#include + +namespace etl +{ + 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..6225d011 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,9 @@ namespace etl //*********************************************************************** inline void reverse() { - ETL_STD::swap(previous, next); + using ETL_OR_STD::swap; // Allow ADL + + swap(previous, next); } node_t* previous; @@ -482,7 +484,7 @@ namespace etl //************************************************************************* /// iterator. //************************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -583,7 +585,7 @@ namespace etl //************************************************************************* /// const_iterator //************************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -676,10 +678,10 @@ namespace etl const node_t* p_node; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etl::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 +812,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(list_iterator)); ETL_ASSERT(size_t(d) <= MAX_SIZE, ETL_ERROR(list_full)); #endif @@ -866,7 +868,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(list_full)); #endif - insert_node(get_head(), allocate_data_node(ETL_STD::move(value))); + insert_node(get_head(), allocate_data_node(etl::move(value))); } #endif @@ -883,7 +885,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(get_head(), *p_data_node); } @@ -989,7 +991,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(list_full)); #endif - insert_node(terminal_node, allocate_data_node(ETL_STD::move(value))); + insert_node(terminal_node, allocate_data_node(etl::move(value))); } #endif @@ -1006,7 +1008,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(terminal_node, *p_data_node); } @@ -1101,7 +1103,7 @@ namespace etl { ETL_ASSERT(!full(), ETL_ERROR(list_full)); - data_node_t& data_node = allocate_data_node(ETL_STD::move(value)); + data_node_t& data_node = allocate_data_node(etl::move(value)); insert_node(*position.p_node, data_node); return iterator(data_node); @@ -1119,7 +1121,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(ETL_STD::forward(args)...); + ::new (&(p_data_node->value)) T(etl::forward(args)...); ETL_INCREMENT_DEBUG_COUNT insert_node(*position.p_node, *p_data_node); @@ -1269,7 +1271,7 @@ namespace etl else if (n < size()) { iterator i_start = end(); - ETL_STD::advance(i_start, -difference_type(size() - n)); + etl::advance(i_start, -difference_type(size() - n)); erase(i_start, end()); } // Larger? @@ -1334,7 +1336,7 @@ namespace etl //************************************************************************* void unique() { - unique(ETL_STD::equal_to()); + unique(etl::equal_to()); } //************************************************************************* @@ -1390,7 +1392,7 @@ namespace etl typename ilist::iterator itr = other.begin(); while (itr != other.end()) { - to = insert(to, ETL_STD::move(*itr++)); + to = insert(to, etl::move(*itr++)); } other.erase(other.begin(), other.end()); @@ -1430,7 +1432,7 @@ namespace etl else { // From another list. - insert(to, ETL_STD::move(*from)); + insert(to, etl::move(*from)); other.erase(from); } } @@ -1471,7 +1473,7 @@ namespace etl ilist::iterator itr = first; while (itr != last) { - to = insert(to, ETL_STD::move(*itr++)); + to = insert(to, etl::move(*itr++)); ++to; } @@ -1485,7 +1487,7 @@ namespace etl //************************************************************************* void merge(ilist& other) { - merge(other, ETL_STD::less()); + merge(other, etl::less()); } //************************************************************************* @@ -1542,7 +1544,7 @@ namespace etl //************************************************************************* void merge(ilist&& other) { - merge(ETL_STD::move(other), ETL_STD::less()); + merge(etl::move(other), etl::less()); } //************************************************************************* @@ -1577,7 +1579,7 @@ namespace etl { while ((other_begin != other_end) && (compare(*other_begin, *this_begin))) { - insert(this_begin, ETL_STD::move(*other_begin)); + insert(this_begin, etl::move(*other_begin)); ++other_begin; } } @@ -1588,7 +1590,7 @@ namespace etl { while (other_begin != other_end) { - insert(this_end, ETL_STD::move(*other_begin++)); + insert(this_end, etl::move(*other_begin++)); } } @@ -1603,7 +1605,7 @@ namespace etl //************************************************************************* void sort() { - sort(ETL_STD::less()); + sort(etl::less()); } //************************************************************************* @@ -1765,7 +1767,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -1917,7 +1919,7 @@ namespace etl ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool)); data_node_t* p_data_node = p_node_pool->allocate(); - ::new (&(p_data_node->value)) T(ETL_STD::move(value)); + ::new (&(p_data_node->value)) T(etl::move(value)); ETL_INCREMENT_DEBUG_COUNT return *p_data_node; @@ -2033,7 +2035,7 @@ namespace etl typename etl::ilist::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2089,7 +2091,7 @@ namespace etl typename etl::ilist::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2191,7 +2193,7 @@ namespace etl typename etl::ilist::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2214,7 +2216,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 +2249,7 @@ namespace etl typename etl::ilist::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -2282,7 +2284,7 @@ namespace etl template bool operator ==(const etl::ilist& lhs, const etl::ilist& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -2307,10 +2309,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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/map.h b/include/etl/map.h index 79a11f7e..b068888f 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,13 +462,13 @@ namespace etl /// A templated base for all etl::map types. ///\ingroup map //*************************************************************************** - template > + template > class imap : public etl::map_base { public: typedef TKey key_type; - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; typedef TMapped mapped_type; typedef TKeyCompare key_compare; typedef value_type& reference; @@ -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 etl::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. @@ -917,7 +917,7 @@ namespace etl if (!i_element.p_node) { // Doesn't exist, so create a new one. - i_element = insert(ETL_MAKE_PAIR(key, mapped_type())).first; + i_element = insert(ETL_OR_STD::make_pair(key, mapped_type())).first; } return i_element->second; @@ -989,9 +989,9 @@ namespace etl /// Returns two iterators with bounding (lower bound, upper bound) the key /// provided //************************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, key)), iterator(*this, find_upper_node(root_node, key))); } @@ -1000,9 +1000,9 @@ namespace etl /// Returns two const iterators with bounding (lower bound, upper bound) /// the key provided. //************************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, key)), const_iterator(*this, find_upper_node(root_node, key))); } @@ -1093,7 +1093,7 @@ namespace etl /// If asserts or exceptions are enabled, emits map_full if the map is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(const value_type& value) + ETL_OR_STD::pair insert(const value_type& value) { // Default to no inserted node Node* inserted_node = nullptr; @@ -1109,7 +1109,7 @@ namespace etl inserted = inserted_node == &node; // Insert node into tree and return iterator to new node location in tree - return ETL_MAKE_PAIR(iterator(*this, inserted_node), inserted); + return ETL_OR_STD::make_pair(iterator(*this, inserted_node), inserted); } //********************************************************************* @@ -2042,7 +2042,7 @@ namespace etl //************************************************************************* /// A templated map implementation that uses a fixed size buffer. //************************************************************************* - template > + template > class map : public etl::imap { public: @@ -2129,7 +2129,7 @@ namespace etl template bool operator ==(const etl::imap& lhs, const etl::imap& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/memory.h b/include/etl/memory.h index 8e6ff921..8d9c1aa1 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 { //***************************************************************************** /// 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 etl::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); + etl::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 etl::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 etl::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 etl::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(etl::distance(o_begin, o_end)); - ETL_STD::fill(o_begin, o_end, value); + etl::fill(o_begin, o_end, value); return o_end; } @@ -108,25 +122,59 @@ 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 etl::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(etl::distance(o_begin, o_end)); etl::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(etl::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); } @@ -134,36 +182,66 @@ namespace etl //***************************************************************************** /// 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); } +#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 etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin) + typename etl::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); + return etl::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 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 etl::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 etl::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 = etl::copy(i_begin, i_end, o_begin); + count += int32_t(etl::distance(o_begin, o_end)); return o_end; } @@ -195,25 +274,52 @@ 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 etl::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); - count += int32_t(ETL_STD::distance(o_begin, o_end)); + count += int32_t(etl::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); } @@ -221,79 +327,67 @@ namespace etl //***************************************************************************** /// 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); } - +#else //***************************************************************************** - /// Default contruct an item at address p. + /// Copies N objects to uninitialised memory. + /// 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) { + 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*/, TCounter& count) + template + TOutputIterator uninitialized_copy_n(TInputIterator i_begin, TSize n, TOutputIterator o_begin, TCounter& count) { - ++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) - { - ::new (p) T; - } + 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, TCounter& count) + template + typename etl::enable_if::value_type>::value, void>::type + uninitialized_default_construct(TOutputIterator /*o_begin*/, TOutputIterator /*o_end*/) { - ::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 etl::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 etl::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -304,50 +398,82 @@ 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 etl::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(etl::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 etl::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(etl::distance(o_begin, o_end)); etl::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 etl::enable_if::value_type>::value, void>::type + uninitialized_default_construct(TOutputIterator o_begin, TOutputIterator o_end) + { + std::uninitialized_default_construct(o_begin, o_end); + } + //***************************************************************************** + /// 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) + { + count = int32_t(etl::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 etl::enable_if::value_type>::value, TOutputIterator>::type - uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) + typename etl::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 etl::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n) { TOutputIterator o_end = o_begin + n; @@ -358,12 +484,13 @@ 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 etl::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { TOutputIterator o_end = o_begin + n; @@ -374,12 +501,13 @@ 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 etl::enable_if::value_type>::value, TOutputIterator>::type + uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { TOutputIterator o_end = o_begin + n; @@ -389,178 +517,58 @@ namespace etl 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 + TOutputIterator 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. + /// 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_value_at(T* p, TCounter& count) + template + TOutputIterator uninitialized_default_construct_n(TOutputIterator o_begin, TSize n, TCounter& count) { - ::new (p) T(); - ++count; - } + count += n; - //***************************************************************************** - /// 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(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 etl::enable_if::value_type>::value, void>::type + uninitialized_value_construct(TOutputIterator o_begin, TOutputIterator o_end) { - ::new (p) T(value); - ++count; - } + typedef typename etl::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); + etl::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 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; - - 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 etl::iterator_traits::value_type value_type; while (o_begin != o_end) { @@ -571,19 +579,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(etl::distance(o_begin, o_end)); etl::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(etl::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 @@ -598,6 +636,7 @@ namespace etl //***************************************************************************** /// Default initialises N objects to uninitialised memory. + /// https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct_n /// Debug counter version. ///\ingroup memory //***************************************************************************** @@ -612,24 +651,53 @@ namespace etl 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*/) + 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) + destroy_at(T* p) { p->~T(); } @@ -637,11 +705,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) + destroy_at(T* /*p*/, TCounter& count) { --count; } @@ -649,33 +718,62 @@ 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) + 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 etl::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 etl::enable_if::value_type>::value, void>::type + destroy(TIterator i_begin, TIterator i_end) { while (i_begin != i_end) { @@ -687,25 +785,27 @@ 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 etl::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(etl::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 etl::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(etl::distance(i_begin, i_end)); while (i_begin != i_end) { @@ -713,25 +813,54 @@ namespace etl ++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(etl::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 etl::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 etl::enable_if::value_type>::value, TIterator>::type + destroy_n(TIterator i_begin, TSize n) { while (n > 0) { @@ -746,11 +875,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 etl::enable_if::value_type>::value, TIterator>::type + destroy_n(TIterator i_begin, TSize n, TCounter& count) { count -= n; return i_begin + n; @@ -759,11 +889,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 etl::enable_if::value_type>::value, TIterator>::type + destroy_n(TIterator i_begin, TSize n, TCounter& count) { count -= n; @@ -776,45 +907,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 +952,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,6 +968,7 @@ namespace etl //***************************************************************************** /// Unique pointer. ///\tparam T The pointed to type type. + /// https://en.cppreference.com/w/cpp/memory/unique_ptr ///\ingroup memory //***************************************************************************** template > @@ -851,119 +976,119 @@ namespace etl { 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 +1104,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 +1171,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 +1235,237 @@ namespace etl pointer p; }; +} + +namespace etl +{ + //***************************************************************************** + /// Default contruct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + typename etl::enable_if::value, void>::type + create_default_at(T* /*p*/) + { + } + + //***************************************************************************** + /// 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; + } + + //***************************************************************************** + /// Default contruct an item at address p. + ///\ingroup memory + //***************************************************************************** + template + typename etl::enable_if::value, void>::type + create_default_at(T* p) + { + ::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; + } + + //***************************************************************************** + /// 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(etl::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(etl::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::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 +1516,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(etl::distance(begin, end)); memory_clear_range(begin, n); } @@ -1217,7 +1574,7 @@ namespace etl template void memory_set_range(volatile T* begin, volatile T* end, const char value) { - const size_t n = static_cast(ETL_STD::distance(begin, end)); + const size_t n = static_cast(etl::distance(begin, end)); memory_set_range(begin, n, value); } diff --git a/include/etl/message_bus.h b/include/etl/message_bus.h index 2844feea..12e75c8f 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 = etl::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_OR_STD::pair range = etl::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 = etl::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_OR_STD::pair range = etl::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 = etl::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..37ca3902 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,12 +624,12 @@ namespace etl /// A templated base for all etl::multimap types. ///\ingroup map //*************************************************************************** - template > + template > class imultimap : public etl::multimap_base { public: - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; typedef const TKey key_type; typedef TMapped mapped_type; typedef TKeyCompare key_compare; @@ -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 etl::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. @@ -1097,9 +1097,9 @@ namespace etl /// Returns two iterators with bounding (lower bound, upper bound) the key /// provided //************************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, key)), iterator(*this, find_upper_node(root_node, key))); } @@ -1108,9 +1108,9 @@ namespace etl /// Returns two const iterators with bounding (lower bound, upper bound) /// the key provided. //************************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, key)), const_iterator(*this, find_upper_node(root_node, key))); } @@ -1931,7 +1931,7 @@ namespace etl //************************************************************************* /// A templated multimap implementation that uses a fixed size buffer. //************************************************************************* - template > + template > class multimap : public etl::imultimap { public: @@ -2018,7 +2018,7 @@ namespace etl template bool operator ==(const etl::imultimap& lhs, const etl::imultimap& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/multiset.h b/include/etl/multiset.h index 6e03ce4b..ffc63709 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 etl::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. @@ -1062,9 +1062,9 @@ namespace etl /// Returns two iterators with bounding (lower bound, upper bound) the key /// provided //************************************************************************* - ETL_PAIR equal_range(const value_type& key) + ETL_OR_STD::pair equal_range(const value_type& key) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, key)), iterator(*this, find_upper_node(root_node, key))); } @@ -1073,9 +1073,9 @@ namespace etl /// Returns two const iterators with bounding (lower bound, upper bound) /// the key provided. //************************************************************************* - ETL_PAIR equal_range(const value_type& key) const + ETL_OR_STD::pair equal_range(const value_type& key) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, key)), const_iterator(*this, find_upper_node(root_node, key))); } @@ -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..bb15c259 100644 --- a/include/etl/murmur3.h +++ b/include/etl/murmur3.h @@ -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 etl::iterator_traits::value_type) == 1, "Incompatible type"); reset(); while (begin != end) @@ -119,7 +119,7 @@ namespace etl template void add(TIterator begin, const TIterator end) { - ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits::value_type) == 1, "Incompatible type"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Incompatible type"); ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised)); while (begin != end) diff --git a/include/etl/observer.h b/include/etl/observer.h index 9de10a64..188ecc87 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 = etl::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 = etl::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/parameter_type.h b/include/etl/parameter_type.h index 019daaea..1150c86b 100644 --- a/include/etl/parameter_type.h +++ b/include/etl/parameter_type.h @@ -43,9 +43,9 @@ namespace etl struct parameter_type { /// By default fundamental and pointer types are passed by value. - typedef typename etl::conditional::value || is_pointer::value, - T, - const T&>::type type; + typedef typename etl::conditional::value || etl::is_pointer::value, + T, + const T&>::type type; }; } diff --git a/include/etl/pearson.h b/include/etl/pearson.h index ab06cfa0..d7379c78 100644 --- a/include/etl/pearson.h +++ b/include/etl/pearson.h @@ -81,7 +81,7 @@ namespace etl pearson(TIterator begin, const TIterator end) : first(true) { - ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Type not supported"); reset(); add(begin, end); @@ -103,7 +103,7 @@ namespace etl template void add(TIterator begin, const TIterator end) { - ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits::value_type) == 1, "Type not supported"); + ETL_STATIC_ASSERT(sizeof(typename etl::iterator_traits::value_type) == 1, "Type not supported"); while (begin != end) { diff --git a/include/etl/platform.h b/include/etl/platform.h index c2e9cd14..eaf3ae58 100644 --- a/include/etl/platform.h +++ b/include/etl/platform.h @@ -72,7 +72,7 @@ SOFTWARE. #endif // The macros below are dependent on the profile. -#if ETL_CPP11_SUPPORTED +#if ETL_CPP11_SUPPORTED && !defined(ETL_FORCE_NO_ADVANCED_CPP) #define ETL_CONSTEXPR constexpr #define ETL_CONST_OR_CONSTEXPR constexpr #define ETL_DELETE = delete @@ -86,7 +86,7 @@ SOFTWARE. #define ETL_NOEXCEPT_EXPR(expression) #endif -#if ETL_CPP17_SUPPORTED +#if ETL_CPP17_SUPPORTED && !defined(ETL_FORCE_NO_ADVANCED_CPP) #define ETL_CONSTEXPR17 constexpr #define ETL_IF_CONSTEXPR constexpr #define ETL_NODISCARD [[nodiscard]] @@ -102,4 +102,7 @@ SOFTWARE. #define ETL_EXPLICIT_STRING_FROM_CHAR #endif +// Sort out namespaces for STL/No STL options. +#include "private/choose_namespace.h" + #endif diff --git a/include/etl/pool.h b/include/etl/pool.h index a70d4b6d..8f051420 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(etl::forward(args)...); } return p; @@ -571,7 +571,7 @@ namespace etl { ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT_, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); - return ipool::create(ETL_STD::forward(args)...); + return ipool::create(etl::forward(args)...); } #endif @@ -724,7 +724,7 @@ namespace etl { ETL_STATIC_ASSERT(etl::alignment_of::value <= ALIGNMENT, "Type has incompatible alignment"); ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool"); - return base_t::template create(ETL_STD::forward(args)...); + return base_t::template create(etl::forward(args)...); } #endif diff --git a/include/etl/priority_queue.h b/include/etl/priority_queue.h index 9904c908..8f1174ed 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 etl::iterator_traits::difference_type difference_type; private: @@ -165,7 +165,7 @@ namespace etl // Put element at end container.push_back(value); // Make elements in container into heap - ETL_STD::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } #if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_PRIORITY_QUEUE_FORCE_CPP03) @@ -181,9 +181,9 @@ namespace etl ETL_ASSERT(!full(), ETL_ERROR(etl::priority_queue_full)); // Put element at end - container.emplace_back(ETL_STD::forward(args)...); + container.emplace_back(etl::forward(args)...); // Make elements in container into heap - ETL_STD::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } #else //************************************************************************* @@ -200,7 +200,7 @@ namespace etl // Put element at end container.emplace_back(value1); // Make elements in container into heap - ETL_STD::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -217,7 +217,7 @@ namespace etl // Put element at end container.emplace_back(value1, value2); // Make elements in container into heap - ETL_STD::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -234,7 +234,7 @@ namespace etl // Put element at end container.emplace_back(value1, value2, value3); // Make elements in container into heap - ETL_STD::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -251,7 +251,7 @@ namespace etl // Put element at end container.emplace_back(value1, value2, value3, value4); // Make elements in container into heap - ETL_STD::push_heap(container.begin(), container.end(), compare); + etl::push_heap(container.begin(), container.end(), compare); } #endif @@ -268,14 +268,14 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d >= 0, ETL_ERROR(etl::priority_queue_iterator)); ETL_ASSERT(static_cast(d) <= max_size(), ETL_ERROR(etl::priority_queue_full)); #endif clear(); container.assign(first, last); - ETL_STD::make_heap(container.begin(), container.end(), compare); + etl::make_heap(container.begin(), container.end(), compare); } //************************************************************************* @@ -285,7 +285,7 @@ namespace etl void pop() { // Move largest element to end - ETL_STD::pop_heap(container.begin(), container.end(), compare); + etl::pop_heap(container.begin(), container.end(), compare); // Actually remove largest element at end container.pop_back(); } @@ -386,7 +386,7 @@ namespace etl /// \tparam T The type this queue should support. /// \tparam SIZE The maximum capacity of the queue. //*************************************************************************** - template , typename TCompare = ETL_STD::less > + template , typename TCompare = etl::less > class priority_queue : public etl::ipriority_queue { public: diff --git a/include/etl/private/choose_namespace.h b/include/etl/private/choose_namespace.h index 935b72ac..a36a0984 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 etl namespace + #define ETL_OR_STD etl #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..9093eaf1 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 etl::iterator_traits::difference_type difference_type; protected: @@ -441,7 +441,7 @@ namespace etl //********************************************************************* void initialise_source_external_buffer_after_move() { - ETL_SUBTRACT_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -451,7 +451,7 @@ namespace etl //********************************************************************* void initialise_destination_external_buffer_after_move() { - ETL_ADD_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etl::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 etl::iterator_traits::difference_type difference_type; protected: @@ -852,7 +852,7 @@ namespace etl //********************************************************************* void initialise_source_external_buffer_after_move() { - ETL_SUBTRACT_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -862,7 +862,7 @@ namespace etl //********************************************************************* void initialise_destination_external_buffer_after_move() { - ETL_ADD_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) } }; diff --git a/include/etl/private/minmax_pop.h b/include/etl/private/minmax_pop.h index 778f63b4..f46e46a1 100644 --- a/include/etl/private/minmax_pop.h +++ b/include/etl/private/minmax_pop.h @@ -33,7 +33,7 @@ SOFTWARE. * This file is intended to evaluated multiple times by design. */ -#ifdef ETL_COMPILER_MICROSOFT -#pragma pop_macro("min") -#pragma pop_macro("max") +#if defined(ETL_COMPILER_MICROSOFT) + #pragma pop_macro("min") + #pragma pop_macro("max") #endif diff --git a/include/etl/private/minmax_push.h b/include/etl/private/minmax_push.h index 4b009771..290a2024 100644 --- a/include/etl/private/minmax_push.h +++ b/include/etl/private/minmax_push.h @@ -33,9 +33,9 @@ SOFTWARE. * This file is intended to evaluated multiple times by design. */ -#ifdef ETL_COMPILER_MICROSOFT -#pragma push_macro("min") -#pragma push_macro("max") -#undef min -#undef max +#if defined(ETL_COMPILER_MICROSOFT) + #pragma push_macro("min") + #pragma push_macro("max") + #undef min + #undef max #endif diff --git a/include/etl/private/pvoidvector.h b/include/etl/private/pvoidvector.h index 7277b299..58963d8a 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 etl::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); + etl::fill(p_end, p_new_end, value); } p_end = p_new_end; @@ -326,7 +326,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(static_cast(d) <= CAPACITY, ETL_ERROR(vector_full)); #endif @@ -402,7 +402,7 @@ namespace etl if (position != end()) { ++p_end; - ETL_STD::copy_backward(position, end() - 1, end()); + etl::copy_backward(position, end() - 1, end()); *position = value; } else @@ -424,8 +424,8 @@ namespace etl { ETL_ASSERT((size() + 1) <= CAPACITY, ETL_ERROR(vector_full)); - ETL_STD::copy_backward(position, p_end, p_end + n); - ETL_STD::fill_n(position, n, value); + etl::copy_backward(position, p_end, p_end + n); + etl::fill_n(position, n, value); p_end += n; } @@ -441,12 +441,12 @@ namespace etl template void insert(iterator position, TIterator first, TIterator last) { - size_t count = ETL_STD::distance(first, last); + size_t count = etl::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); + etl::copy_backward(position, p_end, p_end + count); + etl::copy(first, last, position); p_end += count; } @@ -457,7 +457,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - ETL_STD::copy(i_element + 1, end(), i_element); + etl::copy(i_element + 1, end(), i_element); --p_end; return i_element; @@ -473,8 +473,8 @@ namespace etl //********************************************************************* iterator erase(iterator first, iterator last) { - ETL_STD::copy(last, end(), first); - size_t n_delete = ETL_STD::distance(first, last); + etl::copy(last, end(), first); + size_t n_delete = etl::distance(first, last); // Just adjust the count. p_end -= n_delete; @@ -580,7 +580,7 @@ namespace etl //*************************************************************************** inline bool operator ==(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -604,7 +604,7 @@ namespace etl //*************************************************************************** inline bool operator <(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** diff --git a/include/etl/private/to_string_helper.h b/include/etl/private/to_string_helper.h index 31452b86..42514d68 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(etl::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()); + etl::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 = etl::numeric_limits::digits10; etl::basic_format_spec integral_format = format; integral_format.decimal().width(0).precision(format.get_precision() > max_precision ? max_precision : format.get_precision()); diff --git a/include/etl/queue.h b/include/etl/queue.h index 143bd5b2..f669be1d 100644 --- a/include/etl/queue.h +++ b/include/etl/queue.h @@ -330,7 +330,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(!full(), ETL_ERROR(queue_full)); #endif - ::new (&p_buffer[in]) T(ETL_STD::forward(args)...); + ::new (&p_buffer[in]) T(etl::forward(args)...); add_in(); } #else diff --git a/include/etl/queue_mpmc_mutex.h b/include/etl/queue_mpmc_mutex.h index 9a52eb53..b8d220d1 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(etl::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(etl::forward(args)...); write_index = get_next_index(write_index, MAX_SIZE); diff --git a/include/etl/queue_spsc_atomic.h b/include/etl/queue_spsc_atomic.h index 08d36e1d..f0490385 100644 --- a/include/etl/queue_spsc_atomic.h +++ b/include/etl/queue_spsc_atomic.h @@ -239,7 +239,7 @@ namespace etl if (next_index != read.load(etl::memory_order_acquire)) { - ::new (&p_buffer[write_index]) T(ETL_STD::forward(args)...); + ::new (&p_buffer[write_index]) T(etl::forward(args)...); write.store(next_index, etl::memory_order_release); diff --git a/include/etl/queue_spsc_isr.h b/include/etl/queue_spsc_isr.h index e2b449d3..aadd8420 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(etl::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(etl::forward(args)...); write_index = get_next_index(write_index, MAX_SIZE); @@ -440,7 +440,7 @@ namespace etl { TAccess::lock(); - bool result = this->emplace_implementation(ETL_STD::forward(args)...); + bool result = this->emplace_implementation(etl::forward(args)...); TAccess::unlock(); diff --git a/include/etl/queue_spsc_locked.h b/include/etl/queue_spsc_locked.h index 2f62dee5..75053fd1 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(etl::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(etl::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(etl::forward(args)...); unlock(); diff --git a/include/etl/reference_flat_map.h b/include/etl/reference_flat_map.h index 4f95009d..c5ac11c8 100644 --- a/include/etl/reference_flat_map.h +++ b/include/etl/reference_flat_map.h @@ -103,12 +103,12 @@ 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: - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; protected: @@ -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 etl::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((etl::is_same::value_type>::value), "Incompatible data for assign"); #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_map_full)); #endif @@ -545,7 +545,7 @@ namespace etl /// If asserts or exceptions are enabled, emits flat_map_full if the reference_flat_map is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(reference value) + ETL_OR_STD::pair insert(reference value) { iterator i_element = lower_bound(value.first); @@ -693,7 +693,7 @@ namespace etl //********************************************************************* iterator lower_bound(key_parameter_t key) { - return ETL_STD::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -703,7 +703,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(key_parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -713,7 +713,7 @@ namespace etl //********************************************************************* iterator upper_bound(key_parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -723,7 +723,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(key_parameter_t key) const { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -731,11 +731,11 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { - iterator i_lower = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator i_lower = etl::lower_bound(begin(), end(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, end(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, end(), key, compare)); } //********************************************************************* @@ -743,11 +743,11 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { - const_iterator i_lower = ETL_STD::lower_bound(cbegin(), cend(), key, compare); + const_iterator i_lower = etl::lower_bound(cbegin(), cend(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, cend(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, cend(), key, compare)); } //************************************************************************* @@ -819,9 +819,9 @@ namespace etl ///\param i_element The place to insert. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert_at(iterator i_element, value_type& value) + ETL_OR_STD::pair insert_at(iterator i_element, value_type& value) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); if (i_element == end()) { @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -906,11 +906,11 @@ namespace etl /// A reference_flat_map implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup reference_flat_map //*************************************************************************** - template > + template > class reference_flat_map : public ireference_flat_map { public: diff --git a/include/etl/reference_flat_multimap.h b/include/etl/reference_flat_multimap.h index b8c58f68..8a170cfa 100644 --- a/include/etl/reference_flat_multimap.h +++ b/include/etl/reference_flat_multimap.h @@ -78,12 +78,12 @@ 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: - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; protected: @@ -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 etl::iterator_traits::difference_type difference_type; protected: @@ -443,7 +443,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multimap_full)); #endif @@ -460,11 +460,11 @@ namespace etl /// If asserts or exceptions are enabled, emits reference_flat_multimap_full if the reference_flat_multimap is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(value_type& value) + ETL_OR_STD::pair insert(value_type& value) { ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_multimap_full)); - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); iterator i_element = lower_bound(value.first); @@ -505,7 +505,7 @@ namespace etl //********************************************************************* size_t erase(key_parameter_t key) { - ETL_PAIR range = equal_range(key); + ETL_OR_STD::pair range = equal_range(key); if (range.first == end()) { @@ -513,7 +513,7 @@ namespace etl } else { - size_t d = ETL_STD::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -603,9 +603,9 @@ namespace etl //********************************************************************* size_t count(key_parameter_t key) const { - ETL_PAIR range = equal_range(key); + ETL_OR_STD::pair range = equal_range(key); - return ETL_STD::distance(range.first, range.second); + return etl::distance(range.first, range.second); } //********************************************************************* @@ -615,7 +615,7 @@ namespace etl //********************************************************************* iterator lower_bound(key_parameter_t key) { - return ETL_STD::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -625,7 +625,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(key_parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -635,7 +635,7 @@ namespace etl //********************************************************************* iterator upper_bound(key_parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -645,7 +645,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(key_parameter_t key) const { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -653,11 +653,11 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { - iterator i_lower = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator i_lower = etl::lower_bound(begin(), end(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, end(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, end(), key, compare)); } //********************************************************************* @@ -665,11 +665,11 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { - const_iterator i_lower = ETL_STD::lower_bound(cbegin(), cend(), key, compare); + const_iterator i_lower = etl::lower_bound(cbegin(), cend(), key, compare); - return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, cend(), key, compare)); + return ETL_OR_STD::make_pair(i_lower, etl::upper_bound(i_lower, cend(), key, compare)); } //************************************************************************* @@ -741,9 +741,9 @@ namespace etl ///\param i_element The place to insert. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert_at(iterator i_element, value_type& value) + ETL_OR_STD::pair insert_at(iterator i_element, value_type& value) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); if (i_element == end()) { @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -819,11 +819,11 @@ namespace etl /// A reference_flat_multimap implementation that uses a fixed size buffer. ///\tparam TKey The key type. ///\tparam TValue The value type. - ///\tparam TCompare The type to compare keys. Default = ETL_STD::less + ///\tparam TCompare The type to compare keys. Default = etl::less ///\tparam MAX_SIZE_ The maximum number of elements that can be stored. ///\ingroup reference_flat_multimap //*************************************************************************** - template > + template > class reference_flat_multimap : public ireference_flat_multimap { public: diff --git a/include/etl/reference_flat_multiset.h b/include/etl/reference_flat_multiset.h index 5832da70..47d390e6 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 etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the reference_flat_multiset. @@ -439,7 +439,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multiset_full)); #endif @@ -456,13 +456,13 @@ namespace etl /// If asserts or exceptions are enabled, emits reference_flat_multiset_full if the reference_flat_multiset is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(value_type& value) + ETL_OR_STD::pair insert(value_type& value) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_multiset_full)); - iterator i_element = ETL_STD::lower_bound(begin(), end(), value, compare); + iterator i_element = etl::lower_bound(begin(), end(), value, compare); if (i_element == end()) { @@ -516,7 +516,7 @@ namespace etl //********************************************************************* size_t erase(parameter_t key) { - ETL_PAIR range = equal_range(key); + ETL_OR_STD::pair range = equal_range(key); if (range.first == end()) { @@ -524,7 +524,7 @@ namespace etl } else { - size_t d = ETL_STD::distance(range.first, range.second); + size_t d = etl::distance(range.first, range.second); erase(range.first, range.second); return d; } @@ -566,7 +566,7 @@ namespace etl //********************************************************************* iterator find(parameter_t key) { - iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -590,7 +590,7 @@ namespace etl //********************************************************************* const_iterator find(parameter_t key) const { - const_iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare); + const_iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -614,9 +614,9 @@ namespace etl //********************************************************************* size_t count(parameter_t key) const { - ETL_PAIR range = equal_range(key); + ETL_OR_STD::pair range = equal_range(key); - return ETL_STD::distance(range.first, range.second); + return etl::distance(range.first, range.second); } //********************************************************************* @@ -626,7 +626,7 @@ namespace etl //********************************************************************* iterator lower_bound(parameter_t key) { - return ETL_STD::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -636,7 +636,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -646,7 +646,7 @@ namespace etl //********************************************************************* iterator upper_bound(parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -656,7 +656,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(parameter_t key) const { - return ETL_STD::upper_bound(cbegin(), cend(), key, compare); + return etl::upper_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -664,9 +664,9 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) + ETL_OR_STD::pair equal_range(parameter_t key) { - return ETL_STD::equal_range(begin(), end(), key, compare); + return etl::equal_range(begin(), end(), key, compare); } //********************************************************************* @@ -674,9 +674,9 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) const + ETL_OR_STD::pair equal_range(parameter_t key) const { - return ETL_STD::equal_range(begin(), end(), key, compare); + return etl::equal_range(begin(), end(), key, compare); } //************************************************************************* @@ -748,9 +748,9 @@ namespace etl ///\param i_element The place to insert. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert_at(iterator i_element, reference value) + ETL_OR_STD::pair insert_at(iterator i_element, reference value) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); if (i_element == end()) { @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** diff --git a/include/etl/reference_flat_set.h b/include/etl/reference_flat_set.h index 816255e8..94003f97 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 etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the reference_flat_set. @@ -440,7 +440,7 @@ namespace etl void assign(TIterator first, TIterator last) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full)); #endif @@ -457,7 +457,7 @@ namespace etl /// If asserts or exceptions are enabled, emits reference_flat_set_full if the reference_flat_set is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(reference value) + ETL_OR_STD::pair insert(reference value) { iterator i_element = lower_bound(value); @@ -547,7 +547,7 @@ namespace etl //********************************************************************* iterator find(parameter_t key) { - iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare); + iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -571,7 +571,7 @@ namespace etl //********************************************************************* const_iterator find(parameter_t key) const { - const_iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare); + const_iterator itr = etl::lower_bound(begin(), end(), key, compare); if (itr != end()) { @@ -605,7 +605,7 @@ namespace etl //********************************************************************* iterator lower_bound(parameter_t key) { - return ETL_STD::lower_bound(begin(), end(), key, compare); + return etl::lower_bound(begin(), end(), key, compare); } //********************************************************************* @@ -615,7 +615,7 @@ namespace etl //********************************************************************* const_iterator lower_bound(parameter_t key) const { - return ETL_STD::lower_bound(cbegin(), cend(), key, compare); + return etl::lower_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -625,7 +625,7 @@ namespace etl //********************************************************************* iterator upper_bound(parameter_t key) { - return ETL_STD::upper_bound(begin(), end(), key, compare); + return etl::upper_bound(begin(), end(), key, compare); } //********************************************************************* @@ -635,7 +635,7 @@ namespace etl //********************************************************************* const_iterator upper_bound(parameter_t key) const { - return ETL_STD::upper_bound(cbegin(), cend(), key, compare); + return etl::upper_bound(cbegin(), cend(), key, compare); } //********************************************************************* @@ -643,9 +643,9 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) + ETL_OR_STD::pair equal_range(parameter_t key) { - return ETL_STD::equal_range(begin(), end(), key, compare); + return etl::equal_range(begin(), end(), key, compare); } //********************************************************************* @@ -653,9 +653,9 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair. //********************************************************************* - ETL_PAIR equal_range(parameter_t key) const + ETL_OR_STD::pair equal_range(parameter_t key) const { - return ETL_STD::upper_bound(cbegin(), cend(), key, compare); + return etl::upper_bound(cbegin(), cend(), key, compare); } //************************************************************************* @@ -727,9 +727,9 @@ namespace etl ///\param i_element The place to insert. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert_at(iterator i_element, reference value) + ETL_OR_STD::pair insert_at(iterator i_element, reference value) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); if (i_element == end()) { @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** diff --git a/include/etl/scheduler.h b/include/etl/scheduler.h index bd54a32f..3a6f9e85 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 = etl::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..92b24109 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 etl::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. @@ -911,9 +911,9 @@ namespace etl /// Returns two iterators with bounding (lower bound, upper bound) the /// value provided //************************************************************************* - ETL_PAIR equal_range(const value_type& value) + ETL_OR_STD::pair equal_range(const value_type& value) { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( iterator(*this, find_lower_node(root_node, value)), iterator(*this, find_upper_node(root_node, value))); } @@ -922,9 +922,9 @@ namespace etl /// Returns two const iterators with bounding (lower bound, upper bound) /// the value provided. //************************************************************************* - ETL_PAIR equal_range(const value_type& value) const + ETL_OR_STD::pair equal_range(const value_type& value) const { - return ETL_MAKE_PAIR( + return ETL_OR_STD::make_pair( const_iterator(*this, find_lower_node(root_node, value)), const_iterator(*this, find_upper_node(root_node, value))); } @@ -1015,7 +1015,7 @@ namespace etl /// If asserts or exceptions are enabled, emits set_full if the set is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(value_type& value) + ETL_OR_STD::pair insert(value_type& value) { // Default to no inserted node Node* inserted_node = nullptr; @@ -1031,7 +1031,7 @@ namespace etl inserted = inserted_node == &node; // Insert node into tree and return iterator to new node location in tree - return ETL_MAKE_PAIR(iterator(*this, inserted_node), inserted); + return ETL_OR_STD::make_pair(iterator(*this, inserted_node), inserted); } //********************************************************************* @@ -1950,7 +1950,7 @@ namespace etl //************************************************************************* /// A templated set implementation that uses a fixed size buffer. //************************************************************************* - template > + template > class set : public etl::iset { public: @@ -2037,7 +2037,7 @@ namespace etl template bool operator ==(const etl::iset& lhs, const etl::iset& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/smallest.h b/include/etl/smallest.h index b0e79020..87a59af0 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 etl::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..6290b65d 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 etl::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/stack.h b/include/etl/stack.h index beba0899..a12618c1 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(etl::forward(args)...); } #else //************************************************************************* @@ -408,7 +408,7 @@ namespace etl //************************************************************************* void reverse() { - ETL_STD::reverse(p_buffer, p_buffer + current_size); + etl::reverse(p_buffer, p_buffer + current_size); } //************************************************************************* diff --git a/include/etl/state_chart.h b/include/etl/state_chart.h index 800c7545..449e5aa0 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 etl::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 = etl::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/limits.h b/include/etl/stl/alternate/limits.h deleted file mode 100644 index 2b73be81..00000000 --- a/include/etl/stl/alternate/limits.h +++ /dev/null @@ -1,453 +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_LIMITS_INCLUDED -#define ETL_STL_ALTERNATE_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 -#include -#include - -#define ETL_LOG2(x) (((x) * 301) / 1000) - -namespace etlstd -{ - template class numeric_limits; - - enum float_round_style - { - round_indeterminate = -1, - round_toward_zero = 0, - round_to_nearest = 1, - round_toward_infinity = 2, - round_toward_neg_infinity = 3, - }; - - enum float_denorm_style - { - denorm_indeterminate = -1, - denorm_absent = 0, - denorm_present = 1 - }; - - //*************************************************************************** - // Base for integral types. - template - class etl_integral_type - { - public: - static ETL_CONST_OR_CONSTEXPR bool is_specialized = true; - - static ETL_CONST_OR_CONSTEXPR int max_digits10 = 0; - - static ETL_CONST_OR_CONSTEXPR bool is_integer = true; - static ETL_CONST_OR_CONSTEXPR bool is_exact = true; - - static ETL_CONST_OR_CONSTEXPR int radix = 2; - static ETL_CONSTEXPR T epsilon() { return 0; } - static ETL_CONSTEXPR T round_error() { return 0; } - - static ETL_CONST_OR_CONSTEXPR int digits = (CHAR_BIT * sizeof(T)) - (etl::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 int min_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = 0; - - static ETL_CONST_OR_CONSTEXPR bool has_infinity = false; - static ETL_CONST_OR_CONSTEXPR bool has_quiet_NaN = false; - static ETL_CONST_OR_CONSTEXPR bool has_signaling_NaN = false; - static ETL_CONST_OR_CONSTEXPR float_denorm_style has_denorm = denorm_absent; - static ETL_CONST_OR_CONSTEXPR bool has_denorm_loss = false; - - static ETL_CONSTEXPR T infinity() { return 0; } - static ETL_CONSTEXPR T quiet_NaN() { return 0; } - static ETL_CONSTEXPR T signaling_NaN() { return 0; } - static ETL_CONSTEXPR T denorm_min() { return 0; } - - static ETL_CONST_OR_CONSTEXPR bool is_iec559 = false; - static ETL_CONST_OR_CONSTEXPR bool is_bounded = true; - static ETL_CONST_OR_CONSTEXPR bool is_modulo = etl::is_unsigned::value; - - static ETL_CONST_OR_CONSTEXPR bool traps = false; - static ETL_CONST_OR_CONSTEXPR bool tinyness_before = false; - static ETL_CONST_OR_CONSTEXPR float_round_style round_style = round_toward_zero; - }; - - //*************************************************************************** - // Base for floating point types. - template - class etl_floating_point_type - { - public: - static ETL_CONST_OR_CONSTEXPR bool is_specialized = true; - - static ETL_CONST_OR_CONSTEXPR bool is_signed = true; - static ETL_CONST_OR_CONSTEXPR bool is_integer = false; - static ETL_CONST_OR_CONSTEXPR bool is_exact = false; - - static ETL_CONST_OR_CONSTEXPR int radix = 2; - - static ETL_CONST_OR_CONSTEXPR bool has_infinity = false; - static ETL_CONST_OR_CONSTEXPR bool has_quiet_NaN = false; - static ETL_CONST_OR_CONSTEXPR bool has_signaling_NaN = false; - static ETL_CONST_OR_CONSTEXPR float_denorm_style has_denorm = denorm_present; - static ETL_CONST_OR_CONSTEXPR bool has_denorm_loss = true; - - static ETL_CONST_OR_CONSTEXPR bool is_iec559 = true; - static ETL_CONST_OR_CONSTEXPR bool is_bounded = true; - static ETL_CONST_OR_CONSTEXPR bool is_modulo = false; - - static ETL_CONSTEXPR T round_error() { return T(0.5); } - static ETL_CONSTEXPR T infinity() { return 0; } - static ETL_CONSTEXPR T quiet_NaN() { return 0; } - static ETL_CONSTEXPR T signaling_NaN() { return 0; } - - static ETL_CONST_OR_CONSTEXPR bool traps = false; - static ETL_CONST_OR_CONSTEXPR bool tinyness_before = true; - static ETL_CONST_OR_CONSTEXPR float_round_style round_style = round_to_nearest; - }; - - //*************************************************************************** - // Default - template - class numeric_limits; - - template - class numeric_limits : public numeric_limits { }; - - template - class numeric_limits : public numeric_limits { }; - - template - class numeric_limits : public numeric_limits { }; - - //*************************************************************************** - // bool - template<> - class numeric_limits - { - public: - - static ETL_CONST_OR_CONSTEXPR bool is_specialized = true; - - static ETL_CONSTEXPR bool min() { return false; } - static ETL_CONSTEXPR bool max() { return true; } - static ETL_CONSTEXPR bool lowest() { return false; } - - static ETL_CONST_OR_CONSTEXPR int digits = 1; - static ETL_CONST_OR_CONSTEXPR int digits10 = 0; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = 0; - - static ETL_CONST_OR_CONSTEXPR bool is_signed = false; - static ETL_CONST_OR_CONSTEXPR bool is_integer = true; - static ETL_CONST_OR_CONSTEXPR bool is_exact = true; - - static ETL_CONST_OR_CONSTEXPR int radix = 2; - static ETL_CONST_OR_CONSTEXPR bool epsilon() { return false; } - static ETL_CONST_OR_CONSTEXPR bool round_error() { return false; } - - static ETL_CONST_OR_CONSTEXPR int min_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent = 0; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = 0; - - static ETL_CONST_OR_CONSTEXPR bool has_infinity = false; - static ETL_CONST_OR_CONSTEXPR bool has_quiet_NaN = false; - static ETL_CONST_OR_CONSTEXPR bool has_signaling_NaN = false; - static ETL_CONST_OR_CONSTEXPR float_denorm_style has_denorm = denorm_absent; - static ETL_CONST_OR_CONSTEXPR bool has_denorm_loss = false; - - static ETL_CONSTEXPR bool infinity() { return false; } - static ETL_CONSTEXPR bool quiet_NaN() { return false; } - static ETL_CONSTEXPR bool signaling_NaN() { return false; } - static ETL_CONSTEXPR bool denorm_min() { return false; } - - static ETL_CONST_OR_CONSTEXPR bool is_iec559 = false; - static ETL_CONST_OR_CONSTEXPR bool is_bounded = true; - static ETL_CONST_OR_CONSTEXPR bool is_modulo = false; - - static ETL_CONST_OR_CONSTEXPR bool traps = false; - static ETL_CONST_OR_CONSTEXPR bool tinyness_before = false; - static ETL_CONST_OR_CONSTEXPR float_round_style round_style = round_toward_zero; - }; - - //*************************************************************************** - // char - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR char min() { return char(CHAR_MIN); } - static ETL_CONSTEXPR char max() { return char(CHAR_MAX); } - static ETL_CONSTEXPR char lowest() { return char(CHAR_MIN); } - }; - - //*************************************************************************** - // unsigned char - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR unsigned char min() { return 0; } - static ETL_CONSTEXPR unsigned char max() { return UCHAR_MAX; } - static ETL_CONSTEXPR unsigned char lowest() { return 0; } - }; - - //*************************************************************************** - // signed char - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR signed char min() { return SCHAR_MIN; } - static ETL_CONSTEXPR signed char max() { return SCHAR_MAX; } - static ETL_CONSTEXPR signed char lowest() { return SCHAR_MIN; } - }; - -#if (ETL_NO_LARGE_CHAR_SUPPORT == false) - //*************************************************************************** - // char16_t - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR char16_t min() { return 0; } - static ETL_CONSTEXPR char16_t max() { return UINT_LEAST16_MAX; } - static ETL_CONSTEXPR char16_t lowest() { return 0; } - }; - - //*************************************************************************** - // char32_t - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR char32_t min() { return 0; } - static ETL_CONSTEXPR char32_t max() { return UINT_LEAST32_MAX; } - static ETL_CONSTEXPR char32_t lowest() { return 0; } - }; -#endif - - //*************************************************************************** - // wchar_t - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR wchar_t min() { return WCHAR_MIN; } - static ETL_CONSTEXPR wchar_t max() { return WCHAR_MAX; } - static ETL_CONSTEXPR wchar_t lowest() { return WCHAR_MIN; } - }; - - //*************************************************************************** - // short - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR short min() { return SHRT_MIN; } - static ETL_CONSTEXPR short max() { return SHRT_MAX; } - static ETL_CONSTEXPR short lowest() { return SHRT_MIN; } - }; - - //*************************************************************************** - // unsigned short - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR unsigned short min() { return 0; } - static ETL_CONSTEXPR unsigned short max() { return USHRT_MAX; } - static ETL_CONSTEXPR unsigned short lowest() { return 0; } - }; - - //*************************************************************************** - // int - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR int min() { return INT_MIN; } - static ETL_CONSTEXPR int max() { return INT_MAX; } - static ETL_CONSTEXPR int lowest() { return INT_MIN; } - }; - - //*************************************************************************** - // unsigned int - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR unsigned int min() { return 0; } - static ETL_CONSTEXPR unsigned int max() { return UINT_MAX; } - static ETL_CONSTEXPR unsigned int lowest() { return 0; } - }; - - //*************************************************************************** - // long - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR long min() { return LONG_MIN; } - static ETL_CONSTEXPR long max() { return LONG_MAX; } - static ETL_CONSTEXPR long lowest() { return LONG_MIN; } - }; - - //*************************************************************************** - // unsigned long - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR unsigned long min() { return 0; } - static ETL_CONSTEXPR unsigned long max() { return ULONG_MAX; } - static ETL_CONSTEXPR unsigned long lowest() { return 0; } - }; - - //*************************************************************************** - // long long - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR long long min() { return LLONG_MIN; } - static ETL_CONSTEXPR long long max() { return LLONG_MAX; } - static ETL_CONSTEXPR long long lowest() { return LLONG_MIN; } - }; - - //*************************************************************************** - // unsigned long long - template<> - class numeric_limits : public etl_integral_type - { - public: - - static ETL_CONSTEXPR unsigned long long min() { return 0; } - static ETL_CONSTEXPR unsigned long long max() { return ULLONG_MAX; } - static ETL_CONSTEXPR unsigned long long lowest() { return 0; } - }; - - //*************************************************************************** - // float - template<> - class numeric_limits : public etl_floating_point_type - { - public: - - static ETL_CONSTEXPR float min() { return FLT_MIN; } - static ETL_CONSTEXPR float max() { return FLT_MAX; } - static ETL_CONSTEXPR float lowest() { return -FLT_MAX; } - static ETL_CONSTEXPR float epsilon() { return FLT_EPSILON; } - static ETL_CONSTEXPR float denorm_min() { return FLT_MIN; } - - static ETL_CONST_OR_CONSTEXPR int digits = FLT_MANT_DIG; - static ETL_CONST_OR_CONSTEXPR int digits10 = FLT_DIG; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = ETL_LOG2(FLT_MANT_DIG) + 2; - - static ETL_CONST_OR_CONSTEXPR int min_exponent = FLT_MIN_EXP; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = FLT_MIN_10_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent = FLT_MAX_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = FLT_MAX_10_EXP; - }; - - //*************************************************************************** - // double - template<> - class numeric_limits : public etl_floating_point_type - { - public: - - static ETL_CONSTEXPR double min() { return DBL_MIN; } - static ETL_CONSTEXPR double max() { return DBL_MAX; } - static ETL_CONSTEXPR double lowest() { return -DBL_MAX; } - static ETL_CONSTEXPR double epsilon() { return DBL_EPSILON; } - static ETL_CONSTEXPR double denorm_min() { return DBL_MIN; } - - static ETL_CONST_OR_CONSTEXPR int digits = DBL_MANT_DIG; - static ETL_CONST_OR_CONSTEXPR int digits10 = DBL_DIG; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = ETL_LOG2(DBL_MANT_DIG) + 2; - - static ETL_CONST_OR_CONSTEXPR int min_exponent = DBL_MIN_EXP; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = DBL_MIN_10_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent = DBL_MAX_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = DBL_MAX_10_EXP; - }; - - //*************************************************************************** - // long double - template<> - class numeric_limits : public etl_floating_point_type - { - public: - - static ETL_CONSTEXPR long double min() { return LDBL_MIN; } - static ETL_CONSTEXPR long double max() { return LDBL_MAX; } - static ETL_CONSTEXPR long double lowest() { return -LDBL_MAX; } - static ETL_CONSTEXPR long double epsilon() { return LDBL_EPSILON; } - static ETL_CONSTEXPR long double denorm_min() { return LDBL_MIN; } - - static ETL_CONST_OR_CONSTEXPR int digits = LDBL_MANT_DIG; - static ETL_CONST_OR_CONSTEXPR int digits10 = LDBL_DIG; - static ETL_CONST_OR_CONSTEXPR int max_digits10 = ETL_LOG2(LDBL_MANT_DIG) + 2; - - static ETL_CONST_OR_CONSTEXPR int min_exponent = LDBL_MIN_EXP; - static ETL_CONST_OR_CONSTEXPR int min_exponent10 = LDBL_MIN_10_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent = LDBL_MAX_EXP; - static ETL_CONST_OR_CONSTEXPR int max_exponent10 = LDBL_MAX_10_EXP; - }; -} - -#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..5a690632 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 { @@ -310,10 +310,10 @@ namespace etl //************************************************************************* template ::value, void>::type> - void assign(TIterator begin_, TIterator end_) + void assign(TIterator begin_, TIterator end_) { mbegin = etl::addressof(*begin_); - mend = etl::addressof(*begin_) + ETL_STD::distance(begin_, end_); + mend = etl::addressof(*begin_) + etl::distance(begin_, end_); } //************************************************************************* @@ -321,8 +321,8 @@ namespace etl //************************************************************************* template ::value, void>::type> - void assign(TIterator begin_, TSize size_) + typename TDummy = typename etl::enable_if::value, void>::type> + void assign(TIterator begin_, TSize size_) { mbegin = etl::addressof(*begin_); mend = etl::addressof(*begin_) + size_; @@ -351,8 +351,10 @@ namespace etl //************************************************************************* void swap(basic_string_view& other) { - ETL_STD::swap(mbegin, other.mbegin); - ETL_STD::swap(mend, other.mend); + using ETL_OR_STD::swap; // Allow ADL + + swap(mbegin, other.mbegin); + swap(mend, other.mend); } //************************************************************************* @@ -364,9 +366,9 @@ namespace etl if (position < size()) { - n = ETL_STD::min(count, size() - position); + n = etl::min(count, size() - position); - ETL_STD::copy(mbegin + position, mbegin + position + n, destination); + etl::copy(mbegin + position, mbegin + position + n, destination); } return n; @@ -381,7 +383,7 @@ namespace etl if (position < size()) { - size_t n = ETL_STD::min(count, size() - position); + size_t n = etl::min(count, size() - position); view = basic_string_view(mbegin + position, mbegin + position + n); } @@ -495,7 +497,7 @@ namespace etl return npos; } - const_iterator iposition = ETL_STD::search(begin() + position, end(), view.begin(), view.end()); + const_iterator iposition = etl::search(begin() + position, end(), view.begin(), view.end()); if (iposition == end()) { @@ -503,7 +505,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -532,9 +534,9 @@ namespace etl return npos; } - position = ETL_STD::min(position, size()); + position = etl::min(position, size()); - const_iterator iposition = ETL_STD::find_end(begin(), + const_iterator iposition = etl::find_end(begin(), begin() + position, view.begin(), view.end()); @@ -545,7 +547,7 @@ namespace etl } else { - return ETL_STD::distance(begin(), iposition); + return etl::distance(begin(), iposition); } } @@ -615,7 +617,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -711,7 +713,7 @@ namespace etl return npos; } - position = ETL_STD::min(position, size() - 1); + position = etl::min(position, size() - 1); const_reverse_iterator it = rbegin() + size() - position - 1; @@ -762,7 +764,7 @@ namespace etl friend bool operator == (const etl::basic_string_view& lhs, const etl::basic_string_view& rhs) { return (lhs.size() == rhs.size()) && - ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //************************************************************************* @@ -778,7 +780,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 etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //************************************************************************* diff --git a/include/etl/type_lookup.h b/include/etl/type_lookup.h index c95bfe41..4d5b780b 100644 --- a/include/etl/type_lookup.h +++ b/include/etl/type_lookup.h @@ -117,7 +117,7 @@ namespace etl typename etl::conditional>::type>::type>::type>::type> + etl::null_type<0> >::type>::type>::type>::type> ::type>::type>::type>::type> ::type>::type>::type>::type> ::type>::type>::type>::type type; @@ -218,7 +218,7 @@ namespace etl 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> + 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"); diff --git a/include/etl/type_traits.h b/include/etl/type_traits.h index ebd296b8..f1fdbc58 100644 --- a/include/etl/type_traits.h +++ b/include/etl/type_traits.h @@ -60,18 +60,24 @@ SOFTWARE. #include "nullptr.h" #include "static_assert.h" -#if (ETL_CPP11_SUPPORTED) && !defined(ETL_NO_STL) +///\defgroup type_traits type_traits +/// A set of type traits definitions. +/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined. +/// \ingroup utilities + +#if !defined(ETL_NO_STL) && ETL_CPP11_SUPPORTED #include #endif -///\defgroup type_traits type_traits -/// A set of type traits definitions for compilers that do not support the standard header. -/// \ingroup utilities - namespace etl { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //***************************************************************************** + // Traits are defined by the ETL + //***************************************************************************** + //*************************************************************************** /// integral_constant - ///\ingroup type_traits template struct integral_constant { @@ -82,27 +88,34 @@ 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; + template + const T integral_constant::value; + +#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 +126,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,8 +246,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))> {}; @@ -193,15 +261,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)> {}; @@ -215,8 +288,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,119 +303,983 @@ 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_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> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_lvalue_reference_v = etl::is_lvalue_reference::value; +#endif + + //*************************************************************************** + /// is_rvalue_reference + 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 || etl::is_pointer::value> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pod_v = etl::is_pod::value; +#endif + + //*************************************************************************** + /// is_trivially_constructible + /// Only POD types are recognised. + template struct is_trivially_constructible : etl::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible::value; +#endif + + //*************************************************************************** + /// is_trivially_copy_constructible + /// Only POD types are recognised. + template struct is_trivially_copy_constructible : etl::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 : etl::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 : etl::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 : etl::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable::value; +#endif + + //*************************************************************************** + /// conditional + template struct conditional { typedef T type; }; + template struct conditional { typedef F type; }; + + //*************************************************************************** + /// make_signed + 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; + }; + + template <> struct make_signed { typedef short type; }; + template <> struct make_signed { typedef int type; }; + template <> struct make_signed { typedef long type; }; + template <> struct make_signed { typedef long long type; }; + template struct make_signed : add_const::type> {}; + 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 + template struct make_unsigned { typedef T type; }; + template <> struct make_unsigned { typedef unsigned char type; }; + template <> struct make_unsigned { typedef unsigned char type; }; + template <> struct make_unsigned { typedef unsigned short type; }; + + template <> struct make_unsigned + { + typedef etl::conditional::type>::type type; + }; + + template <> struct make_unsigned { typedef unsigned int type; }; + template <> struct make_unsigned { typedef unsigned long type; }; + template <> struct make_unsigned { typedef unsigned long long type; }; + template struct make_unsigned : add_const::type> {}; + 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 + 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 + template + struct extent : integral_constant {}; + + template + struct extent : integral_constant {}; + + template + struct extent : integral_constant::value> {}; + + template + struct extent : integral_constant {}; + + template + struct extent : integral_constant::value> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t extent_v = extent::value; +#endif + + //*************************************************************************** + /// remove_extent + 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 + 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 + 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 + 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; + }; + +#if ETL_CPP14_SUPPORTED + template + using decay_t = typename decay::type; +#endif + + //*************************************************************************** + /// is_base_of + template::value || etl::is_fundamental::value)> + struct is_base_of + { + private: + + template struct dummy {}; + struct internal: TDerived, dummy{}; + + static TBase* check(TBase*); + template static char check(dummy*); + + public: + + static const bool value = (sizeof(check((internal*)0)) == sizeof(TBase*)); + }; + + // For when TBase or TDerived is a fundamental type. + template + struct is_base_of + { + 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 etl::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 etl::add_rvalue_reference::type; +#endif + + //*************************************************************************** + /// decval +#if ETL_CPP11_SUPPORTED + template + typename etl::add_rvalue_reference::type declval() ETL_NOEXCEPT; +#endif + + //*************************************************************************** + /// is_convertible +#if ETL_CPP11_SUPPORTED + namespace private_type_traits + { + template + using true_type_for = etl::true_type; + + template + auto returnable(int)->true_type_for; + + template + auto returnable(...)->etl::false_type; + + template + auto nonvoid_convertible(int)->true_type_for()(etl::declval())) + >; + template + auto nonvoid_convertible(...)->etl::false_type; + } + + template + struct is_convertible : etl::integral_constant(0))::value && + decltype(private_type_traits::nonvoid_convertible(0))::value) || + (etl::is_void::value && etl::is_void::value)> {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_convertible_v = etl::is_convertible::value; +#endif + + //*************************************************************************** + /// Alignment templates. + /// These require compiler specific intrinsics. +#if ETL_CPP11_SUPPORTED + template struct alignment_of : integral_constant { }; +#elif 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 + + /// Specialisation of 'alignment_of' for 'void'. + ///\ingroup type_traits + template <> struct alignment_of : integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t alignment_of_v = etl::alignment_of::value; +#endif + +#else // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //***************************************************************************** + // Traits are derived from the STL + //***************************************************************************** + + //*************************************************************************** + /// 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::bool_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 - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_constructible : etl::is_pod {}; + //*************************************************************************** + /// is_trivially_constructible + ///\ingroup type_traits + template struct is_trivially_constructible : std::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 {}; + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = std::is_pod_v; + #endif - /// 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_constructible + ///\ingroup type_traits + template struct is_trivially_copy_constructible : std::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 {}; + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_constructible_v = std::is_pod_v; + #endif - /// is_trivially_copyable - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copyable : etl::is_pod {}; -#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 {}; + //*************************************************************************** + /// is_trivially_destructible + ///\ingroup type_traits + template struct is_trivially_destructible : std::is_pod {}; + + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_destructible_v = std::is_pod_v; + #endif + + //*************************************************************************** + /// is_trivially_copy_assignable + ///\ingroup type_traits + template struct is_trivially_copy_assignable : std::is_pod {}; + + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_assignable_v = std::is_pod_v; + #endif + + //*************************************************************************** + /// is_trivially_copyable + ///\ingroup type_traits + template struct is_trivially_copyable : std::is_pod {}; + + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = std::is_pod_v; + #endif #endif + //*************************************************************************** /// conditional ///\ingroup type_traits template struct conditional { typedef T type; }; template struct conditional { typedef F type; }; - /// conditional_integral_constant + //*************************************************************************** + /// 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 // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //*************************************************************************** + // ETL extended type traits. + //*************************************************************************** + + //*************************************************************************** + /// conditional_integral_constant + // /\ingroup type_traits template struct conditional_integral_constant; @@ -355,160 +1297,16 @@ namespace etl 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; - }; - - template <> struct make_signed { typedef short type; }; - template <> struct make_signed { typedef int type; }; - template <> struct make_signed { typedef long type; }; - template <> struct make_signed { typedef long long type; }; - template struct make_signed : add_const::type> {}; - template struct make_signed : add_volatile::type> {}; - template struct make_signed : add_const::type>::type> {}; - - /// 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; }; - template <> struct make_unsigned { typedef unsigned short type; }; - - template <> struct make_unsigned - { - typedef etl::conditional::type>::type type; - }; - - template <> struct make_unsigned { typedef unsigned int type; }; - template <> struct make_unsigned { typedef unsigned long type; }; - template <> struct make_unsigned { typedef unsigned long long type; }; - template struct make_unsigned : add_const::type> {}; - template struct make_unsigned : add_volatile::type> {}; - template struct make_unsigned : add_const::type>::type> {}; - - /// enable_if - ///\ingroup type_traits - template struct enable_if {}; - template struct enable_if { typedef T type; }; - - /// extent - ///\ingroup type_traits - template - struct extent : integral_constant {}; - - template - struct extent : integral_constant {}; - - template - struct extent : integral_constant::value> {}; - - template - struct extent : integral_constant {}; - - template - struct extent : integral_constant::value> {}; - - /// 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;}; - - /// remove_all_extents - ///\ingroup type_traits - 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; }; - - /// 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> {}; - - /// 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; - }; - - /// is_base_of - ///\ingroup type_traits - template::value || etl::is_fundamental::value)> - struct is_base_of - { - private: - - template struct dummy {}; - struct internal: TDerived, dummy{}; - - static TBase* check(TBase*); - template static char check(dummy*); - - public: - - static const bool value = (sizeof(check((internal*)0)) == sizeof(TBase*)); - }; - - // For when TBase or TDerived is a fundamental type. - template - struct is_base_of - { - static const bool value = false; - }; - - /// Alignment templates. - /// These require compiler specific intrinsics. - ///\ingroup type_traits -#if ETL_CPP11_SUPPORTED - 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 -#endif - - /// Specialisation of 'alignment_of' for 'void'. - ///\ingroup type_traits - template <> struct alignment_of : integral_constant {}; #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; + etl::is_one_of::value; }; template @@ -516,46 +1314,46 @@ namespace etl { static const bool value = etl::is_same::value; }; - #else - //*************************************************************************** /// Template to determine if a type is one of a specified list. ///\ingroup types - //*************************************************************************** template + typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void> 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; + 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 @@ -628,22 +1426,56 @@ 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 etl::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 : etl::integral_constant {}; + template <> struct size_of : etl::integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t size_of_v = etl::size_of::value; #endif } -#endif +#endif // ETL_TYPE_TRAITS_INCLUDED diff --git a/include/etl/type_traits_generator.h b/include/etl/type_traits_generator.h index f090f469..e1ebc66b 100644 --- a/include/etl/type_traits_generator.h +++ b/include/etl/type_traits_generator.h @@ -72,18 +72,24 @@ cog.outl("//******************************************************************** #include "nullptr.h" #include "static_assert.h" -#if (ETL_CPP11_SUPPORTED) && !defined(ETL_NO_STL) +///\defgroup type_traits type_traits +/// A set of type traits definitions. +/// Derived from either the standard or alternate definitions, dependant on whether or not ETL_NO_STL is defined. +/// \ingroup utilities + +#if !defined(ETL_NO_STL) && ETL_CPP11_SUPPORTED #include #endif -///\defgroup type_traits type_traits -/// A set of type traits definitions for compilers that do not support the standard header. -/// \ingroup utilities - namespace etl { +#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //***************************************************************************** + // Traits are defined by the ETL + //***************************************************************************** + //*************************************************************************** /// integral_constant - ///\ingroup type_traits template struct integral_constant { @@ -94,27 +100,34 @@ 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; + template + const T integral_constant::value; + +#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 +138,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 +258,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 +273,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 +300,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,119 +315,983 @@ 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_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> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_lvalue_reference_v = etl::is_lvalue_reference::value; +#endif + + //*************************************************************************** + /// is_rvalue_reference + 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 || etl::is_pointer::value> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_pod_v = etl::is_pod::value; +#endif + + //*************************************************************************** + /// is_trivially_constructible + /// Only POD types are recognised. + template struct is_trivially_constructible : etl::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible::value; +#endif + + //*************************************************************************** + /// is_trivially_copy_constructible + /// Only POD types are recognised. + template struct is_trivially_copy_constructible : etl::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 : etl::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 : etl::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 : etl::is_pod {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable::value; +#endif + + //*************************************************************************** + /// conditional + template struct conditional { typedef T type; }; + template struct conditional { typedef F type; }; + + //*************************************************************************** + /// make_signed + 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; + }; + + template <> struct make_signed { typedef short type; }; + template <> struct make_signed { typedef int type; }; + template <> struct make_signed { typedef long type; }; + template <> struct make_signed { typedef long long type; }; + template struct make_signed : add_const::type> {}; + 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 + template struct make_unsigned { typedef T type; }; + template <> struct make_unsigned { typedef unsigned char type; }; + template <> struct make_unsigned { typedef unsigned char type; }; + template <> struct make_unsigned { typedef unsigned short type; }; + + template <> struct make_unsigned + { + typedef etl::conditional::type>::type type; + }; + + template <> struct make_unsigned { typedef unsigned int type; }; + template <> struct make_unsigned { typedef unsigned long type; }; + template <> struct make_unsigned { typedef unsigned long long type; }; + template struct make_unsigned : add_const::type> {}; + 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 + 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 + template + struct extent : integral_constant {}; + + template + struct extent : integral_constant {}; + + template + struct extent : integral_constant::value> {}; + + template + struct extent : integral_constant {}; + + template + struct extent : integral_constant::value> {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t extent_v = extent::value; +#endif + + //*************************************************************************** + /// remove_extent + 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 + 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 + 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 + 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; + }; + +#if ETL_CPP14_SUPPORTED + template + using decay_t = typename decay::type; +#endif + + //*************************************************************************** + /// is_base_of + template::value || etl::is_fundamental::value)> + struct is_base_of + { + private: + + template struct dummy {}; + struct internal: TDerived, dummy{}; + + static TBase* check(TBase*); + template static char check(dummy*); + + public: + + static const bool value = (sizeof(check((internal*)0)) == sizeof(TBase*)); + }; + + // For when TBase or TDerived is a fundamental type. + template + struct is_base_of + { + 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 etl::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 etl::add_rvalue_reference::type; +#endif + + //*************************************************************************** + /// decval +#if ETL_CPP11_SUPPORTED + template + typename etl::add_rvalue_reference::type declval() ETL_NOEXCEPT; +#endif + + //*************************************************************************** + /// is_convertible +#if ETL_CPP11_SUPPORTED + namespace private_type_traits + { + template + using true_type_for = etl::true_type; + + template + auto returnable(int)->true_type_for; + + template + auto returnable(...)->etl::false_type; + + template + auto nonvoid_convertible(int)->true_type_for()(etl::declval())) + >; + template + auto nonvoid_convertible(...)->etl::false_type; + } + + template + struct is_convertible : etl::integral_constant(0))::value && + decltype(private_type_traits::nonvoid_convertible(0))::value) || + (etl::is_void::value && etl::is_void::value)> {}; +#endif + +#if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_convertible_v = etl::is_convertible::value; +#endif + + //*************************************************************************** + /// Alignment templates. + /// These require compiler specific intrinsics. +#if ETL_CPP11_SUPPORTED + template struct alignment_of : integral_constant { }; +#elif 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 + + /// Specialisation of 'alignment_of' for 'void'. + ///\ingroup type_traits + template <> struct alignment_of : integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t alignment_of_v = etl::alignment_of::value; +#endif + +#else // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //***************************************************************************** + // Traits are derived from the STL + //***************************************************************************** + + //*************************************************************************** + /// 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::bool_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 - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_constructible : etl::is_pod {}; + //*************************************************************************** + /// is_trivially_constructible + ///\ingroup type_traits + template struct is_trivially_constructible : std::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 {}; + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_constructible_v = std::is_pod_v; + #endif - /// 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_constructible + ///\ingroup type_traits + template struct is_trivially_copy_constructible : std::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 {}; + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_constructible_v = std::is_pod_v; + #endif - /// is_trivially_copyable - /// For C++03, only POD types are recognised. - ///\ingroup type_traits - template struct is_trivially_copyable : etl::is_pod {}; -#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 {}; + //*************************************************************************** + /// is_trivially_destructible + ///\ingroup type_traits + template struct is_trivially_destructible : std::is_pod {}; + + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_destructible_v = std::is_pod_v; + #endif + + //*************************************************************************** + /// is_trivially_copy_assignable + ///\ingroup type_traits + template struct is_trivially_copy_assignable : std::is_pod {}; + + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copy_assignable_v = std::is_pod_v; + #endif + + //*************************************************************************** + /// is_trivially_copyable + ///\ingroup type_traits + template struct is_trivially_copyable : std::is_pod {}; + + #if ETL_CPP17_SUPPORTED + template + inline constexpr bool is_trivially_copyable_v = std::is_pod_v; + #endif #endif + //*************************************************************************** /// conditional ///\ingroup type_traits template struct conditional { typedef T type; }; template struct conditional { typedef F type; }; - /// conditional_integral_constant + //*************************************************************************** + /// 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 // defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED + + //*************************************************************************** + // ETL extended type traits. + //*************************************************************************** + + //*************************************************************************** + /// conditional_integral_constant + // /\ingroup type_traits template struct conditional_integral_constant; @@ -367,160 +1309,16 @@ namespace etl 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; - }; - - template <> struct make_signed { typedef short type; }; - template <> struct make_signed { typedef int type; }; - template <> struct make_signed { typedef long type; }; - template <> struct make_signed { typedef long long type; }; - template struct make_signed : add_const::type> {}; - template struct make_signed : add_volatile::type> {}; - template struct make_signed : add_const::type>::type> {}; - - /// 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; }; - template <> struct make_unsigned { typedef unsigned short type; }; - - template <> struct make_unsigned - { - typedef etl::conditional::type>::type type; - }; - - template <> struct make_unsigned { typedef unsigned int type; }; - template <> struct make_unsigned { typedef unsigned long type; }; - template <> struct make_unsigned { typedef unsigned long long type; }; - template struct make_unsigned : add_const::type> {}; - template struct make_unsigned : add_volatile::type> {}; - template struct make_unsigned : add_const::type>::type> {}; - - /// enable_if - ///\ingroup type_traits - template struct enable_if {}; - template struct enable_if { typedef T type; }; - - /// extent - ///\ingroup type_traits - template - struct extent : integral_constant {}; - - template - struct extent : integral_constant {}; - - template - struct extent : integral_constant::value> {}; - - template - struct extent : integral_constant {}; - - template - struct extent : integral_constant::value> {}; - - /// 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;}; - - /// remove_all_extents - ///\ingroup type_traits - 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; }; - - /// 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> {}; - - /// 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; - }; - - /// is_base_of - ///\ingroup type_traits - template::value || etl::is_fundamental::value)> - struct is_base_of - { - private: - - template struct dummy {}; - struct internal: TDerived, dummy{}; - - static TBase* check(TBase*); - template static char check(dummy*); - - public: - - static const bool value = (sizeof(check((internal*)0)) == sizeof(TBase*)); - }; - - // For when TBase or TDerived is a fundamental type. - template - struct is_base_of - { - static const bool value = false; - }; - - /// Alignment templates. - /// These require compiler specific intrinsics. - ///\ingroup type_traits -#if ETL_CPP11_SUPPORTED - 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 -#endif - - /// Specialisation of 'alignment_of' for 'void'. - ///\ingroup type_traits - template <> struct alignment_of : integral_constant {}; #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; + etl::is_one_of::value; }; template @@ -528,15 +1326,12 @@ namespace etl { static const bool value = etl::is_same::value; }; - #else - /*[[[cog import cog 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 @@ -633,22 +1433,56 @@ 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 etl::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 : etl::integral_constant {}; + template <> struct size_of : etl::integral_constant {}; + +#if ETL_CPP17_SUPPORTED + template + inline constexpr size_t size_of_v = etl::size_of::value; #endif } -#endif +#endif // ETL_TYPE_TRAITS_INCLUDED diff --git a/include/etl/u16string.h b/include/etl/u16string.h index c571ebab..377d29e8 100644 --- a/include/etl/u16string.h +++ b/include/etl/u16string.h @@ -191,7 +191,7 @@ namespace etl { ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds)); - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/include/etl/u32string.h b/include/etl/u32string.h index 8e152ae8..ee4ebabd 100644 --- a/include/etl/u32string.h +++ b/include/etl/u32string.h @@ -191,7 +191,7 @@ namespace etl { ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds)); - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/include/etl/unordered_map.h b/include/etl/unordered_map.h index 8f27ffaf..c0a3bbf7 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,12 +127,12 @@ 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 = etl::equal_to > class iunordered_map { public: - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; typedef TKey key_type; typedef T mapped_type; @@ -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 etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_map. @@ -609,7 +609,7 @@ namespace etl { size_t index = bucket(key); - return ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -752,7 +752,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_map_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_map_full)); #endif @@ -770,9 +770,9 @@ namespace etl /// If asserts or exceptions are enabled, emits unordered_map_full if the unordered_map is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(const value_type& key_value_pair) + ETL_OR_STD::pair insert(const value_type& key_value_pair) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); ETL_ASSERT(!full(), ETL_ERROR(unordered_map_full)); @@ -1082,7 +1082,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { iterator f = find(key); iterator l = f; @@ -1092,7 +1092,7 @@ namespace etl ++l; } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //********************************************************************* @@ -1103,7 +1103,7 @@ namespace etl ///\param key The key to search for. ///\return A const iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { const_iterator f = find(key); const_iterator l = f; @@ -1113,7 +1113,7 @@ namespace etl ++l; } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //************************************************************************* @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1389,7 +1389,7 @@ namespace etl //************************************************************************* /// A templated unordered_map implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = ETL_STD::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_map : public etl::iunordered_map { private: diff --git a/include/etl/unordered_multimap.h b/include/etl/unordered_multimap.h index 7a4edc26..2e622058 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,12 +127,12 @@ 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 = etl::equal_to > class iunordered_multimap { public: - typedef ETL_PAIR value_type; + typedef ETL_OR_STD::pair value_type; typedef TKey key_type; typedef T mapped_type; @@ -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 etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_multimap. @@ -609,7 +609,7 @@ namespace etl { size_t index = bucket(key); - return ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -641,7 +641,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_multimap_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_multimap_full)); #endif @@ -982,7 +982,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { iterator f = find(key); iterator l = f; @@ -997,7 +997,7 @@ namespace etl } } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //********************************************************************* @@ -1008,7 +1008,7 @@ namespace etl ///\param key The key to search for. ///\return A const iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { const_iterator f = find(key); const_iterator l = f; @@ -1023,7 +1023,7 @@ namespace etl } } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //************************************************************************* @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1298,7 +1298,7 @@ namespace etl //************************************************************************* /// A templated unordered_multimap implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = ETL_STD::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_multimap : public etl::iunordered_multimap { private: diff --git a/include/etl/unordered_multiset.h b/include/etl/unordered_multiset.h index 3b634a7b..b8793407 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 = etl::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 etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_multiset. @@ -604,7 +604,7 @@ namespace etl { size_t index = bucket(key); - return ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -636,7 +636,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_multiset_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_multiset_full)); #endif @@ -654,9 +654,9 @@ namespace etl /// If asserts or exceptions are enabled, emits unordered_multiset_full if the unordered_multiset is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(const value_type& key) + ETL_OR_STD::pair insert(const value_type& key) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); ETL_ASSERT(!full(), ETL_ERROR(unordered_multiset_full)); @@ -977,7 +977,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { iterator f = find(key); iterator l = f; @@ -992,7 +992,7 @@ namespace etl } } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //********************************************************************* @@ -1003,7 +1003,7 @@ namespace etl ///\param key The key to search for. ///\return A const iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { const_iterator f = find(key); const_iterator l = f; @@ -1018,7 +1018,7 @@ namespace etl } } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //************************************************************************* @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1293,7 +1293,7 @@ namespace etl //************************************************************************* /// A templated unordered_multiset implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = ETL_STD::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_multiset : public etl::iunordered_multiset { private: diff --git a/include/etl/unordered_set.h b/include/etl/unordered_set.h index 1babd690..9fbc3586 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 = etl::equal_to > class iunordered_set { public: @@ -169,7 +169,7 @@ namespace etl typedef typename bucket_t::const_iterator local_const_iterator; //********************************************************************* - class iterator : public etl::iterator + class iterator : public etl::iterator { public: @@ -328,7 +328,7 @@ namespace etl }; //********************************************************************* - class const_iterator : public etl::iterator + class const_iterator : public etl::iterator { public: @@ -478,7 +478,7 @@ namespace etl local_iterator inode; }; - typedef typename ETL_STD::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::difference_type difference_type; //********************************************************************* /// Returns an iterator to the beginning of the unordered_set. @@ -605,7 +605,7 @@ namespace etl { size_t index = bucket(key); - return ETL_STD::distance(pbuckets[index].begin(), pbuckets[index].end()); + return etl::distance(pbuckets[index].begin(), pbuckets[index].end()); } //********************************************************************* @@ -637,7 +637,7 @@ namespace etl void assign(TIterator first_, TIterator last_) { #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first_, last_); + difference_type d = etl::distance(first_, last_); ETL_ASSERT(d >= 0, ETL_ERROR(unordered_set_iterator)); ETL_ASSERT(size_t(d) <= max_size(), ETL_ERROR(unordered_set_full)); #endif @@ -655,9 +655,9 @@ namespace etl /// If asserts or exceptions are enabled, emits unordered_set_full if the unordered_set is already full. ///\param value The value to insert. //********************************************************************* - ETL_PAIR insert(const value_type& key) + ETL_OR_STD::pair insert(const value_type& key) { - ETL_PAIR result(end(), false); + ETL_OR_STD::pair result(end(), false); ETL_ASSERT(!full(), ETL_ERROR(unordered_set_full)); @@ -964,7 +964,7 @@ namespace etl ///\param key The key to search for. ///\return An iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) + ETL_OR_STD::pair equal_range(key_parameter_t key) { iterator f = find(key); iterator l = f; @@ -974,7 +974,7 @@ namespace etl ++l; } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //********************************************************************* @@ -985,7 +985,7 @@ namespace etl ///\param key The key to search for. ///\return A const iterator pair to the range of elements if the key exists, otherwise end(). //********************************************************************* - ETL_PAIR equal_range(key_parameter_t key) const + ETL_OR_STD::pair equal_range(key_parameter_t key) const { const_iterator f = find(key); const_iterator l = f; @@ -995,7 +995,7 @@ namespace etl ++l; } - return ETL_PAIR(f, l); + return ETL_OR_STD::pair(f, l); } //************************************************************************* @@ -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()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1270,7 +1270,7 @@ namespace etl //************************************************************************* /// A templated unordered_set implementation that uses a fixed size buffer. //************************************************************************* - template , typename TKeyEqual = ETL_STD::equal_to > + template , typename TKeyEqual = etl::equal_to > class unordered_set : public etl::iunordered_set { private: diff --git a/include/etl/utility.h b/include/etl/utility.h index 1743c01c..5f600f2f 100644 --- a/include/etl/utility.h +++ b/include/etl/utility.h @@ -34,11 +34,136 @@ SOFTWARE. #include "platform.h" #include "type_traits.h" +#if !defined(ETL_NO_STL) + #include +#endif + ///\defgroup utility utility ///\ingroup utilities namespace etl { + //****************************************************************************** + 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 + +#if defined(ETL_NO_STL) //*************************************************************************** /// exchange (const) //*************************************************************************** @@ -49,6 +174,16 @@ namespace etl object = new_value; return old_value; } +#else + //*************************************************************************** + /// exchange (const) + //*************************************************************************** + template + T exchange(T& object, const U& new_value) + { + return std::exchange(object, new_value); + } +#endif //*************************************************************************** /// as_const diff --git a/include/etl/variant.h b/include/etl/variant.h index dd84fc72..624c2310 100644 --- a/include/etl/variant.h +++ b/include/etl/variant.h @@ -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(etl::forward(args)...); type_id = Type_Id_Lookup::type_id; return *static_cast(data); diff --git a/include/etl/variant_pool.h b/include/etl/variant_pool.h index f9823f6c..48c34a62 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(etl::forward(args)...); } } diff --git a/include/etl/variant_pool_generator.h b/include/etl/variant_pool_generator.h index 47d305e7..a00f1748 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)...); } } diff --git a/include/etl/vector.h b/include/etl/vector.h index 4cc0f656..03305767 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 etl::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((etl::is_same::type, typename etl::remove_cv::value_type>::type>::value), "Iterator type does not match container type"); #if defined(ETL_DEBUG) - difference_type d = ETL_STD::distance(first, last); + difference_type d = etl::distance(first, last); ETL_ASSERT(static_cast(d) <= CAPACITY, ETL_ERROR(vector_full)); #endif initialise(); p_end = etl::uninitialized_copy(first, last, p_buffer); - ETL_ADD_DEBUG_COUNT(uint32_t(ETL_STD::distance(first, last))) + ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last))) } //********************************************************************* @@ -426,7 +426,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full)); #endif - create_back(ETL_STD::move(value)); + create_back(etl::move(value)); } #endif @@ -442,7 +442,7 @@ namespace etl #if defined(ETL_CHECK_PUSH_POP) ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full)); #endif - ::new (p_end) T(ETL_STD::forward(args)...); + ::new (p_end) T(etl::forward(args)...); ++p_end; ETL_INCREMENT_DEBUG_COUNT } @@ -541,7 +541,7 @@ namespace etl else { create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); *position = value; } @@ -561,13 +561,13 @@ namespace etl if (position == end()) { - create_back(ETL_STD::move(value)); + create_back(etl::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(etl::move(back())); + etl::move_backward(position, p_end - 2, p_end - 1); + *position = etl::move(value); } return position; @@ -594,11 +594,11 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } - ::new (p) T(ETL_STD::forward(args)...); + ::new (p) T(etl::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); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -644,7 +644,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -669,7 +669,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -694,7 +694,7 @@ namespace etl { p = etl::addressof(*position); create_back(back()); - ETL_STD::copy_backward(position, p_end - 2, p_end - 1); + etl::copy_backward(position, p_end - 2, p_end - 1); (*position).~T(); } @@ -716,7 +716,7 @@ namespace etl ETL_ASSERT((size() + n) <= CAPACITY, ETL_ERROR(vector_full)); size_t insert_n = n; - size_t insert_begin = ETL_STD::distance(begin(), position); + size_t insert_begin = etl::distance(begin(), position); size_t insert_end = insert_begin + insert_n; // Copy old data. @@ -745,14 +745,14 @@ namespace etl ETL_ADD_DEBUG_COUNT(construct_old_n) // Copy old. - ETL_STD::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); + etl::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); // Construct new. etl::uninitialized_fill_n(p_end, construct_new_n, value); ETL_ADD_DEBUG_COUNT(construct_new_n) // Copy new. - ETL_STD::fill_n(p_buffer + insert_begin, copy_new_n, value); + etl::fill_n(p_buffer + insert_begin, copy_new_n, value); p_end += n; } @@ -768,12 +768,12 @@ namespace etl template void insert(iterator position, TIterator first, TIterator last) { - size_t count = ETL_STD::distance(first, last); + size_t count = etl::distance(first, last); ETL_ASSERT((size() + count) <= CAPACITY, ETL_ERROR(vector_full)); size_t insert_n = count; - size_t insert_begin = ETL_STD::distance(begin(), position); + size_t insert_begin = etl::distance(begin(), position); size_t insert_end = insert_begin + insert_n; // Copy old data. @@ -802,7 +802,7 @@ namespace etl ETL_ADD_DEBUG_COUNT(construct_old_n) // Copy old. - ETL_STD::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); + etl::copy_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n); // Construct new. etl::uninitialized_copy_n(first + copy_new_n, construct_new_n, p_end); @@ -821,7 +821,7 @@ namespace etl //********************************************************************* iterator erase(iterator i_element) { - ETL_STD::copy(i_element + 1, end(), i_element); + etl::copy(i_element + 1, end(), i_element); destroy_back(); return i_element; @@ -843,8 +843,8 @@ namespace etl } else { - ETL_STD::copy(last, end(), first); - size_t n_delete = ETL_STD::distance(first, last); + etl::copy(last, end(), first); + size_t n_delete = etl::distance(first, last); // Destroy the elements left over at the end. etl::destroy(p_end - n_delete, p_end); @@ -880,7 +880,7 @@ namespace etl iterator itr = rhs.begin(); while (itr != rhs.end()) { - push_back(ETL_STD::move(*itr)); + push_back(etl::move(*itr)); ++itr; } @@ -952,7 +952,7 @@ namespace etl void initialise() { etl::destroy(p_buffer, p_end); - ETL_SUBTRACT_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -962,7 +962,7 @@ namespace etl //********************************************************************* void initialise_source_external_buffer_after_move() { - ETL_SUBTRACT_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) p_end = p_buffer; } @@ -972,7 +972,7 @@ namespace etl //********************************************************************* void initialise_destination_external_buffer_after_move() { - ETL_ADD_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end))) + ETL_ADD_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end))) } //************************************************************************* @@ -1018,7 +1018,7 @@ namespace etl //********************************************************************* inline void create_back(rvalue_reference value) { - etl::create_copy_at(p_end, ETL_STD::move(value)); + etl::create_copy_at(p_end, etl::move(value)); ETL_INCREMENT_DEBUG_COUNT ++p_end; @@ -1065,7 +1065,7 @@ namespace etl template bool operator ==(const etl::ivector& lhs, const etl::ivector& rhs) { - return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin()); + return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin()); } //*************************************************************************** @@ -1091,7 +1091,7 @@ namespace etl template bool operator <(const etl::ivector& lhs, const etl::ivector& rhs) { - return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); + return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } //*************************************************************************** @@ -1243,7 +1243,7 @@ namespace etl typename etl::ivector::iterator itr = other.begin(); while (itr != other.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -1262,7 +1262,7 @@ namespace etl typename etl::ivector::iterator itr = rhs.begin(); while (itr != rhs.end()) { - this->push_back(ETL_STD::move(*itr)); + this->push_back(etl::move(*itr)); ++itr; } @@ -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(etl::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(etl::move(*itr)); ++itr; } diff --git a/include/etl/version.h b/include/etl/version.h index 69cbc002..44270f57 100644 --- a/include/etl/version.h +++ b/include/etl/version.h @@ -37,8 +37,8 @@ SOFTWARE. /// Definitions of the ETL version ///\ingroup utilities -#define ETL_VERSION_MAJOR 15 -#define ETL_VERSION_MINOR 5 +#define ETL_VERSION_MAJOR 16 +#define ETL_VERSION_MINOR 0 #define ETL_VERSION_PATCH 0 #define ETL_VERSION ETL_STRINGIFY(ETL_VERSION_MAJOR) "." ETL_STRINGIFY(ETL_VERSION_MINOR) "." ETL_STRINGIFY(ETL_VERSION_PATCH) diff --git a/include/etl/wstring.h b/include/etl/wstring.h index ebe0c455..7447d962 100644 --- a/include/etl/wstring.h +++ b/include/etl/wstring.h @@ -192,7 +192,7 @@ namespace etl { ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds)); - length_ = ETL_STD::min(length_, size() - position); + length_ = etl::min(length_, size() - position); new_string.assign(buffer + position, buffer + position + length_); } diff --git a/library.json b/library.json index 9bcfadfb..689d3608 100644 --- a/library.json +++ b/library.json @@ -1,6 +1,6 @@ { "name": "Embedded Template Library", - "version": "15.5.0", + "version": "16.0.0", "authors": { "name": "John Wellbelove", "email": "" diff --git a/library.properties b/library.properties index 84d0db75..13083571 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=Embedded Template Library -version=15.5.0 +version=16.0.0 author= John Wellbelove maintainer=John Wellbelove license=MIT diff --git a/support/Release notes.txt b/support/Release notes.txt index 742a4cdd..81833538 100644 --- a/support/Release notes.txt +++ b/support/Release notes.txt @@ -1,3 +1,11 @@ +=============================================================================== +16.0.0 +Refactored the ETL's relationship with the STL +Many reverse engineered STL algorithms and traits are now available through the +ETL namespace. +When ETL_NO_STL is defined, the ETL implements its own versions of the STL code. +When ETL_NO_STL is *not* defined, the ETL act as a wrapper around the STL implementations. + =============================================================================== 15.5.0 Added the ability to self determine the compiler type, version and language support diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index af18f98b..0aaac6e9 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -8,15 +8,6 @@ if(NOT UnitTest++_FOUND) # Add unittest-cpp as an ExternalProject include(cmake/unit-test_external_project.cmake) add_unittest_cpp() -else() - include(${UnitTest++_CONFIG}) - # The CMake install of UnitTest++ puts the include directory to ${CMAKE_INSTALL_PREFIX}/include - # under the assumptions that clients will consume the headers via - # #include - # However the tests in etl include the headers directly, e.g. - # #include "UnitTest++.h" - # Therefore we update the provide UTPP_INCLUDE_DIRS here - set(UTPP_INCLUDE_DIRS "${UTPP_INCLUDE_DIRS}/UnitTest++") endif() include_directories(${UTPP_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR}/../include) diff --git a/test/ExtraCheckMacros.h b/test/ExtraCheckMacros.h index 17fcd51a..be2df4c1 100644 --- a/test/ExtraCheckMacros.h +++ b/test/ExtraCheckMacros.h @@ -1,14 +1,14 @@ -#ifndef UNITTEST_EXTRA_CHECKMACROS_H +#ifndef UNITTEST_EXTRA_CHECKMACROS_H #define UNITTEST_EXTRA_CHECKMACROS_H -#include "HelperMacros.h" -#include "ExceptionMacros.h" -#include "Checks.h" -#include "AssertException.h" -#include "MemoryOutStream.h" -#include "TestDetails.h" -#include "CurrentTest.h" -#include "ReportAssertImpl.h" +#include "UnitTest++/HelperMacros.h" +#include "UnitTest++/ExceptionMacros.h" +#include "UnitTest++/Checks.h" +#include "UnitTest++/AssertException.h" +#include "UnitTest++/MemoryOutStream.h" +#include "UnitTest++/TestDetails.h" +#include "UnitTest++/CurrentTest.h" +#include "UnitTest++/ReportAssertImpl.h" #ifndef CHECK_NO_THROW #define CHECK_NO_THROW(expression) \ diff --git a/test/codeblocks/ETL.cbp b/test/codeblocks/ETL.cbp index 7221311a..e0014fc3 100644 --- a/test/codeblocks/ETL.cbp +++ b/test/codeblocks/ETL.cbp @@ -100,16 +100,37 @@ + + + + - - - + @@ -183,12 +204,14 @@