coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Work in progress

Browse Source
This commit is contained in:
John Wellbelove 2020-01-04 11:20:29 +00:00
parent c947ba3c7e
commit fc50557003
135 changed files with 8256 additions and 6028 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/etl/absolute.h
View File

@ -39,7 +39,7 @@ namespace etl
// For signed types.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_signed<T>::value, T>::type
typename etlstd::enable_if<etlstd::is_signed<T>::value, T>::type
absolute(T value)
{
return (value < T(0)) ? -value : value;
@ -49,7 +49,7 @@ namespace etl
// For unsigned types.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
typename etlstd::enable_if<etlstd::is_unsigned<T>::value, T>::type
absolute(T value)
{
return value;

2429
include/etl/algorithm.h
View File

File diff suppressed because it is too large Load Diff

22
include/etl/alignment.h
View File

@ -66,7 +66,7 @@ namespace etl
{
public:
typedef typename type_with_alignment_matcher<ALIGNMENT <= etl::alignment_of<T2>::value, ALIGNMENT, T2, T3, T4, T5, T6, T7, T8, void>::type type;
typedef typename type_with_alignment_matcher<ALIGNMENT <= etlstd::alignment_of<T2>::value, ALIGNMENT, T2, T3, T4, T5, T6, T7, T8, void>::type type;
};
// Non-matching alignment, none left.
@ -86,7 +86,7 @@ namespace etl
{
public:
typedef typename type_with_alignment_matcher<ALIGNMENT <= etl::alignment_of<T1>::value, ALIGNMENT, T1, T2, T3, T4, T5, T6, T7, T8>::type type;
typedef typename type_with_alignment_matcher<ALIGNMENT <= etlstd::alignment_of<T1>::value, ALIGNMENT, T1, T2, T3, T4, T5, T6, T7, T8>::type type;
};
}
@ -116,7 +116,7 @@ namespace etl
template <typename T>
operator T& ()
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
T* t = *this;
return *t;
}
@ -125,7 +125,7 @@ namespace etl
template <typename T>
operator const T& () const
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
const T* t = *this;
return *t;
}
@ -134,7 +134,7 @@ namespace etl
template <typename T>
operator T* ()
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
return reinterpret_cast<T*>(data);
}
@ -142,7 +142,7 @@ namespace etl
template <typename T>
operator const T* () const
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
return reinterpret_cast<const T*>(data);
}
@ -150,7 +150,7 @@ namespace etl
template <typename T>
T& get_reference()
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
T* t = *this;
return *t;
}
@ -159,7 +159,7 @@ namespace etl
template <typename T>
const T& get_reference() const
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
const T* t = *this;
return *t;
}
@ -168,7 +168,7 @@ namespace etl
template <typename T>
T* get_address()
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
return reinterpret_cast<T*>(data);
}
@ -176,7 +176,7 @@ namespace etl
template <typename T>
const T* get_address() const
{
ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((ALIGNMENT % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
ETL_STATIC_ASSERT((etlstd::is_same<T*, void*>:: value || ((ALIGNMENT % etlstd::alignment_of<T>::value) == 0)), "Incompatible alignment");
return reinterpret_cast<const T*>(data);
}
@ -197,7 +197,7 @@ namespace etl
///\ingroup alignment
//***************************************************************************
template <const size_t LENGTH, typename T>
struct aligned_storage_as : public etl::aligned_storage<LENGTH, etl::alignment_of<T>::value>
struct aligned_storage_as : public etl::aligned_storage<LENGTH, etlstd::alignment_of<T>::value>
{
};
}

52
include/etl/array.h
View File

@ -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<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
// Element access
@ -342,7 +342,7 @@ namespace etl
//*************************************************************************
void fill(parameter_t value)
{
ETL_STD::fill(begin(), end(), value);
etlstd::fill(begin(), end(), value);
}
//*************************************************************************
@ -351,9 +351,15 @@ namespace etl
//*************************************************************************
void swap(array& other)
{
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
for (size_t i = 0; i < SIZE; ++i)
{
ETL_STD::swap(_buffer[i], other._buffer[i]);
swap(_buffer[i], other._buffer[i]);
}
}
@ -367,7 +373,7 @@ namespace etl
template <typename TIterator>
void assign(TIterator first, const TIterator last)
{
etl::copy(first, last, begin(), end());
etlstd::copy(first, last, begin(), end());
}
//*************************************************************************
@ -381,10 +387,10 @@ namespace etl
void assign(TIterator first, const TIterator last, parameter_t value)
{
// Copy from the range.
iterator p = etl::copy(first, last, begin(), end());
iterator p = etlstd::copy(first, last, begin(), end());
// Default initialise any that are left.
ETL_STD::fill(p, end(), value);
etlstd::fill(p, end(), value);
}
//*************************************************************************
@ -406,7 +412,7 @@ namespace etl
{
iterator p = const_cast<iterator>(position);
ETL_STD::copy_backward(p, end() - 1, end());
etlstd::copy_backward(p, end() - 1, end());
*p = value;
return p;
@ -436,18 +442,18 @@ namespace etl
iterator p = const_cast<iterator>(position);
iterator result(p);
size_t source_size = ETL_STD::distance(first, last);
size_t destination_space = ETL_STD::distance(position, cend());
size_t source_size = etlstd::distance(first, last);
size_t destination_space = etlstd::distance(position, cend());
// Do we need to move anything?
if (source_size < destination_space)
{
size_t length = SIZE - (ETL_STD::distance(begin(), p) + source_size);
ETL_STD::copy_backward(p, p + length, end());
size_t length = SIZE - (etlstd::distance(begin(), p) + source_size);
etlstd::copy_backward(p, p + length, end());
}
// Copy from the range.
etl::copy(first, last, p, end());
etlstd::copy(first, last, p, end());
return result;
}
@ -470,7 +476,7 @@ namespace etl
iterator erase(const_iterator position)
{
iterator p = const_cast<iterator>(position);
ETL_STD::copy(p + 1, end(), p);
etlstd::copy(p + 1, end(), p);
return p;
}
@ -495,7 +501,7 @@ namespace etl
iterator erase(const_iterator first, const_iterator last)
{
iterator p = const_cast<iterator>(first);
ETL_STD::copy(last, cend(), p);
etlstd::copy(last, cend(), p);
return p;
}
@ -518,7 +524,7 @@ namespace etl
{
iterator p = const_cast<iterator>(position);
ETL_STD::copy(p + 1, end(), p);
etlstd::copy(p + 1, end(), p);
back() = value;
return p;
@ -544,8 +550,8 @@ namespace etl
{
iterator p = const_cast<iterator>(first);
p = ETL_STD::copy(last, cend(), p);
ETL_STD::fill(p, end(), value);
p = etlstd::copy(last, cend(), p);
etlstd::fill(p, end(), value);
return const_cast<iterator>(first);
}
@ -574,7 +580,7 @@ namespace etl
template <typename T, size_t SIZE>
bool operator ==(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return ETL_STD::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin());
return etlstd::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin());
}
//*************************************************************************
@ -598,7 +604,7 @@ namespace etl
template <typename T, size_t SIZE>
bool operator <(const etl::array<T, SIZE>& lhs, const etl::array<T, SIZE>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.cbegin(),
return etlstd::lexicographical_compare(lhs.cbegin(),
lhs.cend(),
rhs.cbegin(),
rhs.cend());

24
include/etl/array_view.h
View File

@ -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<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Default constructor.
@ -137,7 +137,7 @@ namespace etl
template <typename TIterator>
ETL_CONSTEXPR array_view(const TIterator begin_, const TIterator end_)
: mbegin(etl::addressof(*begin_)),
mend(etl::addressof(*begin_) + ETL_STD::distance(begin_, end_))
mend(etl::addressof(*begin_) + etlstd::distance(begin_, end_))
{
}
@ -356,7 +356,7 @@ namespace etl
void assign(const TIterator begin_, const TIterator end_)
{
mbegin = etl::addressof(*begin_);
mend = etl::addressof(*begin_) + ETL_STD::distance(begin_, end_);
mend = etl::addressof(*begin_) + etlstd::distance(begin_, end_);
}
//*************************************************************************
@ -411,8 +411,14 @@ namespace etl
//*************************************************************************
void swap(array_view& other)
{
ETL_STD::swap(mbegin, other.mbegin);
ETL_STD::swap(mend, other.mend);
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
swap(mbegin, other.mbegin);
swap(mend, other.mend);
}
//*************************************************************************
@ -437,7 +443,7 @@ namespace etl
friend bool operator == (const array_view<T>& lhs, const array_view<T>& rhs)
{
return (lhs.size() == rhs.size()) &&
ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
@ -453,7 +459,7 @@ namespace etl
//*************************************************************************
friend bool operator < (const array_view<T>& lhs, const array_view<T>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

20
include/etl/array_wrapper.h
View File

@ -93,8 +93,8 @@ namespace etl
typedef const T* const_pointer;
typedef T* iterator;
typedef const T* const_iterator;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etl::parameter_type<T>::type parameter_t;
@ -310,19 +310,25 @@ namespace etl
//*************************************************************************
void fill(parameter_t value)
{
ETL_STD::fill(begin(), end(), value);
etlstd::fill(begin(), end(), value);
}
//*************************************************************************
/// Swaps the contents of arrays.
//*************************************************************************
template <typename U, U(&ARRAYOTHER)[SIZE_]>
typename etl::enable_if<etl::is_same<T, U>::value, void>::type
typename etlstd::enable_if<etlstd::is_same<T, U>::value, void>::type
swap(etl::array_wrapper<U, SIZE_, ARRAYOTHER>& other)
{
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
for (size_t i = 0; i < SIZE; ++i)
{
ETL_STD::swap(ARRAY_[i], other.begin()[i]);
swap(ARRAY_[i], other.begin()[i]);
}
}
};
@ -334,7 +340,7 @@ namespace etl
bool operator == (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
{
return (SIZEL == SIZER) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (SIZEL == SIZER) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
@ -354,7 +360,7 @@ namespace etl
bool operator < (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

2
include/etl/atomic/atomic_gcc_sync.h
View File

@ -66,7 +66,7 @@ namespace etl
{
public:
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Only integral types are supported");
atomic()
: value(0)

2
include/etl/atomic/atomic_llvm_sync.h
View File

@ -59,7 +59,7 @@ SOFTWARE.
// {
// public:
//
// ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
// ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Only integral types are supported");
//
// atomic()
// : value(0)

126
include/etl/basic_string.h
View File

@ -37,9 +37,9 @@ SOFTWARE.
#include "platform.h"
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "stl/functional.h"
#include "algorithm.h"
#include "iterator.h"
#include "functional.h"
#include "char_traits.h"
#include "container.h"
@ -282,11 +282,11 @@ namespace etl
typedef const T* const_pointer;
typedef T* iterator;
typedef const T* const_iterator;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t size_type;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
//*********************************************************************
/// Returns an iterator to the beginning of the string.
@ -418,12 +418,12 @@ namespace etl
is_truncated = true;
}
new_size = ETL_STD::min(new_size, CAPACITY);
new_size = etlstd::min(new_size, CAPACITY);
// Size up?
if (new_size > current_size)
{
ETL_STD::fill(p_buffer + current_size, p_buffer + new_size, value);
etlstd::fill(p_buffer + current_size, p_buffer + new_size, value);
}
current_size = new_size;
@ -596,7 +596,7 @@ namespace etl
is_truncated = (length_ > CAPACITY);
length_ = ETL_STD::min(length_, CAPACITY);
length_ = etlstd::min(length_, CAPACITY);
etl::copy_n(other, length_, begin());
@ -615,7 +615,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d >= 0, ETL_ERROR(string_iterator));
#endif
@ -643,9 +643,9 @@ namespace etl
is_truncated = (n > CAPACITY);
n = ETL_STD::min(n, CAPACITY);
n = etlstd::min(n, CAPACITY);
ETL_STD::fill_n(begin(), n, value);
etlstd::fill_n(begin(), n, value);
current_size = n;
p_buffer[current_size] = 0;
}
@ -780,7 +780,7 @@ namespace etl
{
// Insert in the middle.
++current_size;
ETL_STD::copy_backward(insert_position, end() - 1, end());
etlstd::copy_backward(insert_position, end() - 1, end());
*insert_position = value;
}
else
@ -796,7 +796,7 @@ namespace etl
if (position != end())
{
// Insert in the middle.
ETL_STD::copy_backward(insert_position, end() - 1, end());
etlstd::copy_backward(insert_position, end() - 1, end());
*insert_position = value;
}
@ -823,7 +823,7 @@ namespace etl
// Quick hack, as iterators are pointers.
iterator insert_position = const_cast<iterator>(position);
const size_t start = ETL_STD::distance(cbegin(), position);
const size_t start = etlstd::distance(cbegin(), position);
// No effect.
if (start >= CAPACITY)
@ -841,7 +841,7 @@ namespace etl
}
current_size = CAPACITY;
ETL_STD::fill(insert_position, end(), value);
etlstd::fill(insert_position, end(), value);
}
else
{
@ -850,7 +850,7 @@ namespace etl
const size_t to_position = start + shift_amount;
const size_t remaining_characters = current_size - start;
const size_t max_shift_characters = CAPACITY - start - shift_amount;
const size_t characters_to_shift = ETL_STD::min(max_shift_characters, remaining_characters);
const size_t characters_to_shift = etlstd::min(max_shift_characters, remaining_characters);
// Will the string truncate?
if ((start + shift_amount + remaining_characters) > CAPACITY)
@ -863,8 +863,8 @@ namespace etl
current_size += shift_amount;
}
ETL_STD::copy_backward(insert_position, insert_position + characters_to_shift, begin() + to_position + characters_to_shift);
ETL_STD::fill(insert_position, insert_position + shift_amount, value);
etlstd::copy_backward(insert_position, insert_position + characters_to_shift, begin() + to_position + characters_to_shift);
etlstd::fill(insert_position, insert_position + shift_amount, value);
}
p_buffer[current_size] = 0;
@ -885,8 +885,8 @@ namespace etl
return;
}
const size_t start = ETL_STD::distance(begin(), position);
const size_t n = ETL_STD::distance(first, last);
const size_t start = etlstd::distance(begin(), position);
const size_t n = etlstd::distance(first, last);
// No effect.
if (start >= CAPACITY)
@ -917,7 +917,7 @@ namespace etl
const size_t to_position = start + shift_amount;
const size_t remaining_characters = current_size - start;
const size_t max_shift_characters = CAPACITY - start - shift_amount;
const size_t characters_to_shift = ETL_STD::min(max_shift_characters, remaining_characters);
const size_t characters_to_shift = etlstd::min(max_shift_characters, remaining_characters);
// Will the string truncate?
if ((start + shift_amount + remaining_characters) > CAPACITY)
@ -930,7 +930,7 @@ namespace etl
current_size += shift_amount;
}
ETL_STD::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift);
etlstd::copy_backward(position, position + characters_to_shift, begin() + to_position + characters_to_shift);
while (first != last)
{
@ -1037,7 +1037,7 @@ namespace etl
etl::ibasic_string<T>& erase(size_t position, size_t length_ = npos)
{
// Limit the length.
length_ = ETL_STD::min(length_, size() - position);
length_ = etlstd::min(length_, size() - position);
erase(begin() + position, begin() + position + length_);
@ -1051,7 +1051,7 @@ namespace etl
//*********************************************************************
iterator erase(iterator i_element)
{
ETL_STD::copy(i_element + 1, end(), i_element);
etlstd::copy(i_element + 1, end(), i_element);
p_buffer[--current_size] = 0;
return i_element;
@ -1067,8 +1067,8 @@ namespace etl
//*********************************************************************
iterator erase(iterator first, iterator last)
{
ETL_STD::copy(last, end(), first);
size_t n_delete = ETL_STD::distance(first, last);
etlstd::copy(last, end(), first);
size_t n_delete = etlstd::distance(first, last);
current_size -= n_delete;
p_buffer[current_size] = 0;
@ -1098,7 +1098,7 @@ namespace etl
is_truncated = true;
}
size_t endpos = ETL_STD::min(pos + len, size());
size_t endpos = etlstd::min(pos + len, size());
for (size_t i = pos; i < endpos; ++i)
{
@ -1120,7 +1120,7 @@ namespace etl
return npos;
}
const_iterator iposition = ETL_STD::search(begin() + pos, end(), str.begin(), str.end());
const_iterator iposition = etlstd::search(begin() + pos, end(), str.begin(), str.end());
if (iposition == end())
{
@ -1128,7 +1128,7 @@ namespace etl
}
else
{
return ETL_STD::distance(begin(), iposition);
return etlstd::distance(begin(), iposition);
}
}
@ -1146,7 +1146,7 @@ namespace etl
}
#endif
const_iterator iposition = ETL_STD::search(begin() + pos, end(), s, s + etl::strlen(s));
const_iterator iposition = etlstd::search(begin() + pos, end(), s, s + etl::strlen(s));
if (iposition == end())
{
@ -1154,7 +1154,7 @@ namespace etl
}
else
{
return ETL_STD::distance(begin(), iposition);
return etlstd::distance(begin(), iposition);
}
}
@ -1173,7 +1173,7 @@ namespace etl
}
#endif
const_iterator iposition = ETL_STD::search(begin() + pos, end(), s, s + n);
const_iterator iposition = etlstd::search(begin() + pos, end(), s, s + n);
if (iposition == end())
{
@ -1181,7 +1181,7 @@ namespace etl
}
else
{
return ETL_STD::distance(begin(), iposition);
return etlstd::distance(begin(), iposition);
}
}
@ -1192,11 +1192,11 @@ namespace etl
//*********************************************************************
size_t find(T c, size_t position = 0) const
{
const_iterator i = ETL_STD::find(begin() + position, end(), c);
const_iterator i = etlstd::find(begin() + position, end(), c);
if (i != end())
{
return ETL_STD::distance(begin(), i);
return etlstd::distance(begin(), i);
}
else
{
@ -1223,7 +1223,7 @@ namespace etl
position = size() - position;
const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), str.rbegin(), str.rend());
const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), str.rbegin(), str.rend());
if (iposition == rend())
{
@ -1231,7 +1231,7 @@ namespace etl
}
else
{
return size() - str.size() - ETL_STD::distance(rbegin(), iposition);
return size() - str.size() - etlstd::distance(rbegin(), iposition);
}
}
@ -1259,7 +1259,7 @@ namespace etl
const_reverse_iterator srbegin(s + len);
const_reverse_iterator srend(s);
const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), srbegin, srend);
const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), srbegin, srend);
if (iposition == rend())
{
@ -1267,7 +1267,7 @@ namespace etl
}
else
{
return size() - len - ETL_STD::distance(rbegin(), iposition);
return size() - len - etlstd::distance(rbegin(), iposition);
}
}
@ -1293,7 +1293,7 @@ namespace etl
const_reverse_iterator srbegin(s + length_);
const_reverse_iterator srend(s);
const_reverse_iterator iposition = ETL_STD::search(rbegin() + position, rend(), srbegin, srend);
const_reverse_iterator iposition = etlstd::search(rbegin() + position, rend(), srbegin, srend);
if (iposition == rend())
{
@ -1301,7 +1301,7 @@ namespace etl
}
else
{
return size() - length_ - ETL_STD::distance(rbegin(), iposition);
return size() - length_ - etlstd::distance(rbegin(), iposition);
}
}
@ -1319,11 +1319,11 @@ namespace etl
position = size() - position;
const_reverse_iterator i = ETL_STD::find(rbegin() + position, rend(), c);
const_reverse_iterator i = etlstd::find(rbegin() + position, rend(), c);
if (i != rend())
{
return size() - ETL_STD::distance(rbegin(), i) - 1;
return size() - etlstd::distance(rbegin(), i) - 1;
}
else
{
@ -1342,7 +1342,7 @@ namespace etl
ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds));
// Limit the length.
length_ = ETL_STD::min(length_, size() - position);
length_ = etlstd::min(length_, size() - position);
// Erase the bit we want to replace.
erase(position, length_);
@ -1388,8 +1388,8 @@ namespace etl
ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds));
// Limit the lengths.
length_ = ETL_STD::min(length_, size() - position);
sublength = ETL_STD::min(sublength, str.size() - subposition);
length_ = etlstd::min(length_, size() - position);
sublength = etlstd::min(sublength, str.size() - subposition);
// Erase the bit we want to replace.
erase(position, length_);
@ -1413,7 +1413,7 @@ namespace etl
ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds));
// Limit the length.
length_ = ETL_STD::min(length_, size() - position);
length_ = etlstd::min(length_, size() - position);
// Erase the bit we want to replace.
erase(position, length_);
@ -1450,7 +1450,7 @@ namespace etl
ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds));
// Limit the length.
length_ = ETL_STD::min(length_, size() - position);
length_ = etlstd::min(length_, size() - position);
// Erase the bit we want to replace.
erase(position, length_);
@ -1487,7 +1487,7 @@ namespace etl
ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds));
// Limit the length.
length_ = ETL_STD::min(length_, size() - position);
length_ = etlstd::min(length_, size() - position);
// Erase the bit we want to replace.
erase(position, length_);
@ -1554,7 +1554,7 @@ namespace etl
ETL_ASSERT(position <= size(), ETL_ERROR(string_out_of_bounds));
// Limit the length.
length_ = ETL_STD::min(length_, size() - position);
length_ = etlstd::min(length_, size() - position);
return compare(p_buffer + position,
p_buffer + position + length_,
@ -1571,8 +1571,8 @@ namespace etl
ETL_ASSERT(subposition <= str.size(), ETL_ERROR(string_out_of_bounds));
// Limit the lengths.
length_ = ETL_STD::min(length_, size() - position);
sublength = ETL_STD::min(sublength, str.size() - subposition);
length_ = etlstd::min(length_, size() - position);
sublength = etlstd::min(sublength, str.size() - subposition);
return compare(p_buffer + position,
p_buffer + position + length_,
@ -1712,7 +1712,7 @@ namespace etl
return npos;
}
position = ETL_STD::min(position, size() - 1);
position = etlstd::min(position, size() - 1);
const_reverse_iterator it = rbegin() + size() - position - 1;
@ -1745,7 +1745,7 @@ namespace etl
return npos;
}
position = ETL_STD::min(position, size() - 1);
position = etlstd::min(position, size() - 1);
const_reverse_iterator it = rbegin() + size() - position - 1;
@ -1869,7 +1869,7 @@ namespace etl
return npos;
}
position = ETL_STD::min(position, size() - 1);
position = etlstd::min(position, size() - 1);
const_reverse_iterator it = rbegin() + size() - position - 1;
@ -1907,7 +1907,7 @@ namespace etl
return npos;
}
position = ETL_STD::min(position, size() - 1);
position = etlstd::min(position, size() - 1);
const_reverse_iterator it = rbegin() + size() - position - 1;
@ -2106,7 +2106,7 @@ namespace etl
template <typename T>
bool operator ==(const etl::ibasic_string<T>& lhs, const etl::ibasic_string<T>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -2119,7 +2119,7 @@ namespace etl
template <typename T>
bool operator ==(const etl::ibasic_string<T>& lhs, const T* rhs)
{
return (lhs.size() == etl::strlen(rhs)) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs);
return (lhs.size() == etl::strlen(rhs)) && etlstd::equal(lhs.begin(), lhs.end(), rhs);
}
//***************************************************************************
@ -2132,7 +2132,7 @@ namespace etl
template <typename T>
bool operator ==(const T* lhs, const etl::ibasic_string<T>& rhs)
{
return (rhs.size() == etl::strlen(lhs)) && ETL_STD::equal(rhs.begin(), rhs.end(), lhs);
return (rhs.size() == etl::strlen(lhs)) && etlstd::equal(rhs.begin(), rhs.end(), lhs);
}
@ -2185,7 +2185,7 @@ namespace etl
template <typename T>
bool operator <(const etl::ibasic_string<T>& lhs, const etl::ibasic_string<T>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//***************************************************************************
@ -2198,7 +2198,7 @@ namespace etl
template <typename T>
bool operator <(const etl::ibasic_string<T>& lhs, const T* rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs));
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs, rhs + etl::strlen(rhs));
}
//***************************************************************************
@ -2211,7 +2211,7 @@ namespace etl
template <typename T>
bool operator <(const T* lhs, const etl::ibasic_string<T>& rhs)
{
return ETL_STD::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end());
return etlstd::lexicographical_compare(lhs, lhs + etl::strlen(lhs), rhs.begin(), rhs.end());
}

52
include/etl/binary.h
View File

@ -45,7 +45,7 @@ SOFTWARE.
#include "exception.h"
#include "error_handler.h"
#include "stl/limits.h"
#include "limits.h"
#undef ETL_FILE
#define ETL_FILE "50"
@ -110,7 +110,7 @@ namespace etl
template <typename T>
T rotate_left(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Not an integral type");
const size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1;
@ -124,7 +124,7 @@ namespace etl
template <typename T>
T rotate_left(T value, size_t distance)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Not an integral type");
const size_t BITS = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits;
distance %= BITS;
@ -140,7 +140,7 @@ namespace etl
template <typename T>
T rotate_right(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Not an integral type");
const size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1;
@ -154,7 +154,7 @@ namespace etl
template <typename T>
T rotate_right(T value, size_t distance)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Not an integral type");
const size_t BITS = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits;
distance %= BITS;
@ -171,7 +171,7 @@ namespace etl
template <typename T>
T rotate(T value, typename etl::make_signed<size_t>::type distance)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Not an integral type");
T result;
@ -194,7 +194,7 @@ namespace etl
template <typename T>
T binary_to_gray(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Not an integral type");
return (value >> 1) ^ value;
}
@ -235,10 +235,10 @@ namespace etl
template <typename TReturn, const size_t NBITS, typename TValue>
TReturn sign_extend(TValue value)
{
ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etl::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_STATIC_ASSERT(NBITS <= ETL_STD::numeric_limits<TReturn>::digits, "NBITS too large for return type");
ETL_STATIC_ASSERT(etlstd::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etlstd::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_STATIC_ASSERT(NBITS <= etlstd::numeric_limits<TReturn>::digits, "NBITS too large for return type");
struct S
{
@ -257,11 +257,11 @@ namespace etl
template <typename TReturn, const size_t NBITS, const size_t SHIFT, typename TValue>
TReturn sign_extend(TValue value)
{
ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etl::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_STATIC_ASSERT(NBITS <= ETL_STD::numeric_limits<TReturn>::digits, "NBITS too large for return type");
ETL_STATIC_ASSERT(SHIFT <= ETL_STD::numeric_limits<TReturn>::digits, "SHIFT too large");
ETL_STATIC_ASSERT(etlstd::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etlstd::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_STATIC_ASSERT(NBITS <= etlstd::numeric_limits<TReturn>::digits, "NBITS too large for return type");
ETL_STATIC_ASSERT(SHIFT <= etlstd::numeric_limits<TReturn>::digits, "SHIFT too large");
struct S
{
@ -279,11 +279,11 @@ namespace etl
template <typename TReturn, typename TValue>
TReturn sign_extend(TValue value, const size_t NBITS)
{
ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etl::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_STATIC_ASSERT(etlstd::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etlstd::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_ASSERT((NBITS <= ETL_STD::numeric_limits<TReturn>::digits), ETL_ERROR(binary_out_of_range));
ETL_ASSERT((NBITS <= etlstd::numeric_limits<TReturn>::digits), ETL_ERROR(binary_out_of_range));
TReturn mask = TReturn(1) << (NBITS - 1);
value = value & static_cast<TValue>((TReturn(1) << NBITS) - 1);
@ -300,11 +300,11 @@ namespace etl
template <typename TReturn, typename TValue>
TReturn sign_extend(TValue value, const size_t NBITS, const size_t SHIFT)
{
ETL_STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etl::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_STATIC_ASSERT(etlstd::is_integral<TValue>::value, "TValue not an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<TReturn>::value, "TReturn not an integral type");
ETL_STATIC_ASSERT(etlstd::is_signed<TReturn>::value, "TReturn not a signed type");
ETL_ASSERT((NBITS <= ETL_STD::numeric_limits<TReturn>::digits), ETL_ERROR(binary_out_of_range));
ETL_ASSERT((NBITS <= etlstd::numeric_limits<TReturn>::digits), ETL_ERROR(binary_out_of_range));
TReturn mask = TReturn(1) << (NBITS - 1);
value = (value >> SHIFT) & static_cast<TValue>((TReturn(1) << NBITS) - 1);
@ -1207,7 +1207,7 @@ namespace etl
///\ingroup binary
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value, bool>::type
is_odd(const T value)
{
return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) != 0U);
@ -1218,7 +1218,7 @@ namespace etl
///\ingroup binary
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value, bool>::type
is_even(const T value)
{
return ((static_cast<typename etl::make_unsigned<T>::type>(value) & 1U) == 0U);

37
include/etl/bit_stream.h
View File

@ -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<unsigned char*>(begin_)),
length(ETL_STD::distance(begin_, end_))
length(etlstd::distance(begin_, end_))
{
restart();
}
@ -78,7 +77,7 @@ namespace etl
//***************************************************************************
bit_stream(unsigned char* begin_, unsigned char* end_)
: pdata(begin_),
length(ETL_STD::distance(begin_, end_))
length(etlstd::distance(begin_, end_))
{
restart();
}
@ -128,7 +127,7 @@ namespace etl
//***************************************************************************
void set_stream(char* begin_, char* end_)
{
set_stream(begin_, ETL_STD::distance(begin_, end_));
set_stream(begin_, etlstd::distance(begin_, end_));
}
//***************************************************************************
@ -136,7 +135,7 @@ namespace etl
//***************************************************************************
void set_stream(unsigned char* begin_, unsigned char* end_)
{
set_stream(begin_, ETL_STD::distance(begin_, end_));
set_stream(begin_, etlstd::distance(begin_, end_));
}
//***************************************************************************
@ -181,7 +180,7 @@ namespace etl
/// For integral types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value, bool>::type
put(T value, uint_least8_t width = CHAR_BIT * sizeof(T))
{
return put_integral(static_cast<uint32_t>(value), width);
@ -207,7 +206,7 @@ namespace etl
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, bool>::type
typename etlstd::enable_if<etlstd::is_floating_point<T>::value, bool>::type
put(T value)
{
bool success = true;
@ -250,7 +249,7 @@ namespace etl
/// For integral types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value, bool>::type
get(T& value, uint_least8_t width = CHAR_BIT * sizeof(T))
{
bool success = false;
@ -266,7 +265,7 @@ namespace etl
// Get the bits from the stream.
while (width != 0)
{
unsigned char mask_width = static_cast<unsigned char>(ETL_STD::min(width, bits_in_byte));
unsigned char mask_width = static_cast<unsigned char>(etlstd::min(width, bits_in_byte));
unsigned char chunk = get_chunk(mask_width);
width -= mask_width;
@ -278,7 +277,7 @@ namespace etl
}
// Sign extend if signed type and not already full bit width.
if (etl::is_signed<T>::value && (bits != (CHAR_BIT * sizeof(T))))
if (etlstd::is_signed<T>::value && (bits != (CHAR_BIT * sizeof(T))))
{
typedef typename etl::make_signed<T>::type ST;
value = etl::sign_extend<ST, ST>(value, bits);
@ -291,7 +290,7 @@ namespace etl
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, bool>::type
typename etlstd::enable_if<etlstd::is_floating_point<T>::value, bool>::type
get(T& value)
{
bool success = false;
@ -379,7 +378,7 @@ namespace etl
// Send the bits to the stream.
while (width != 0)
{
unsigned char mask_width = static_cast<unsigned char>(ETL_STD::min(width, bits_in_byte));
unsigned char mask_width = static_cast<unsigned char>(etlstd::min(width, bits_in_byte));
width -= mask_width;
uint32_t mask = ((uint32_t(1U) << mask_width) - 1U) << width;
@ -412,7 +411,7 @@ namespace etl
// Send the bits to the stream.
while (width != 0)
{
unsigned char mask_width = static_cast<unsigned char>(ETL_STD::min(width, bits_in_byte));
unsigned char mask_width = static_cast<unsigned char>(etlstd::min(width, bits_in_byte));
width -= mask_width;
uint64_t mask = ((uint64_t(1U) << mask_width) - 1U) << width;
@ -495,11 +494,11 @@ namespace etl
// Network to host.
if (etl::endianness::value() == etl::endian::little)
{
ETL_STD::reverse_copy(data, data + sizeof(T), temp);
etlstd::reverse_copy(data, data + sizeof(T), temp);
}
else
{
ETL_STD::copy(data, data + sizeof(T), temp);
etlstd::copy(data, data + sizeof(T), temp);
}
value = *reinterpret_cast<T*>(temp);
@ -516,11 +515,11 @@ namespace etl
// Host to network.
if (etl::endianness::value() == etl::endian::little)
{
ETL_STD::reverse_copy(pf, pf + sizeof(T), data);
etlstd::reverse_copy(pf, pf + sizeof(T), data);
}
else
{
ETL_STD::copy(pf, pf + sizeof(T), data);
etlstd::copy(pf, pf + sizeof(T), data);
}
}

22
include/etl/bitset.h
View File

@ -37,8 +37,8 @@ SOFTWARE.
#include "platform.h"
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "algorithm.h"
#include "iterator.h"
#include "integral_limits.h"
#include "algorithm.h"
@ -312,7 +312,7 @@ namespace etl
{
reset();
size_t i = ETL_STD::min(NBITS, etl::strlen(text));
size_t i = etlstd::min(NBITS, etl::strlen(text));
while (i > 0)
{
@ -329,7 +329,7 @@ namespace etl
{
reset();
size_t i = ETL_STD::min(NBITS, etl::strlen(text));
size_t i = etlstd::min(NBITS, etl::strlen(text));
while (i > 0)
{
@ -346,7 +346,7 @@ namespace etl
{
reset();
size_t i = ETL_STD::min(NBITS, etl::strlen(text));
size_t i = etlstd::min(NBITS, etl::strlen(text));
while (i > 0)
{
@ -363,7 +363,7 @@ namespace etl
{
reset();
size_t i = ETL_STD::min(NBITS, etl::strlen(text));
size_t i = etlstd::min(NBITS, etl::strlen(text));
while (i > 0)
{
@ -380,7 +380,7 @@ namespace etl
{
reset();
size_t i = ETL_STD::min(NBITS, etl::strlen(text));
size_t i = etlstd::min(NBITS, etl::strlen(text));
while (i > 0)
{
@ -394,7 +394,7 @@ namespace etl
/// Put to a value.
//*************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, T>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value, T>::type
value() const
{
T v = T(0);
@ -746,7 +746,7 @@ namespace etl
//*************************************************************************
void swap(ibitset& other)
{
ETL_STD::swap_ranges(pdata, pdata + SIZE, other.pdata);
etl::swap_ranges(pdata, pdata + SIZE, other.pdata);
}
protected:
@ -818,7 +818,7 @@ namespace etl
//*************************************************************************
static bool is_equal(const ibitset& lhs, const ibitset&rhs)
{
return ETL_STD::equal(lhs.pdata, lhs.pdata + lhs.SIZE, rhs.pdata);
return etlstd::equal(lhs.pdata, lhs.pdata + lhs.SIZE, rhs.pdata);
}
element_t TOP_MASK;
@ -976,7 +976,7 @@ namespace etl
/// Put to a value.
//*************************************************************************
template <typename T>
typename etl::enable_if<etl::is_integral<T>::value, T>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value, T>::type
value() const
{
ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (ARRAY_SIZE * BITS_PER_ELEMENT), "Type too small");

8
include/etl/bloom_filter.h
View File

@ -104,12 +104,12 @@ namespace etl
{
flags.set(get_hash<THash1>(key));
if (!etl::is_same<THash2, null_hash>::value)
if (!etlstd::is_same<THash2, null_hash>::value)
{
flags.set(get_hash<THash2>(key));
}
if (!etl::is_same<THash3, null_hash>::value)
if (!etlstd::is_same<THash3, null_hash>::value)
{
flags.set(get_hash<THash3>(key));
}
@ -127,13 +127,13 @@ namespace etl
bool exists3 = true;
// Do we have a second hash?
if (!etl::is_same<THash2, null_hash>::value)
if (!etlstd::is_same<THash2, null_hash>::value)
{
exists2 = flags[get_hash<THash2>(key)];
}
// Do we have a third hash?
if (!etl::is_same<THash3, null_hash>::value)
if (!etlstd::is_same<THash3, null_hash>::value)
{
exists3 = flags[get_hash<THash3>(key)];
}

15
include/etl/char_traits.h
View File

@ -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 <stdint.h>
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "platform.h"
#include "algorithm.h"
#include "iterator.h"
//*****************************************************************************
///\defgroup char_traits char_traits
@ -141,7 +140,7 @@ namespace etl
{
if (p != 0)
{
ETL_STD::fill_n(p, n, c);
etlstd::fill_n(p, n, c);
}
return p;
@ -156,9 +155,9 @@ namespace etl
}
else
{
etl::copy_n(ETL_STD::reverse_iterator<char_type*>(src + count),
etl::copy_n(ETL_OR_STD::reverse_iterator<char_type*>(src + count),
count,
ETL_STD::reverse_iterator<char_type*>(dest + count));
ETL_OR_STD::reverse_iterator<char_type*>(dest + count));
}
return dest;

5
include/etl/compare.h
View File

@ -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 <typename T, typename TLess = ETL_STD::less<T> >
template <typename T, typename TLess = etlstd::less<T> >
struct compare
{
typedef typename etl::parameter_type<T>::type first_argument_type;

41
include/etl/container.h
View File

@ -34,8 +34,7 @@ SOFTWARE.
#include <stddef.h>
#include "platform.h"
#include "stl/iterator.h"
#include "iterator.h"
///\defgroup container container
///\ingroup utilities
@ -177,9 +176,9 @@ namespace etl
///\ingroup container
//*****************************************************************************
template<typename TValue, const size_t ARRAY_SIZE>
ETL_CONSTEXPR ETL_STD::reverse_iterator<TValue*> rbegin(const TValue(&data)[ARRAY_SIZE])
ETL_OR_STD::reverse_iterator<TValue*> rbegin(const TValue(&data)[ARRAY_SIZE])
{
return ETL_STD::reverse_iterator<TValue*>(&data[ARRAY_SIZE]);
return ETL_OR_STD::reverse_iterator<TValue*>(&data[ARRAY_SIZE]);
}
//*****************************************************************************
@ -187,9 +186,9 @@ namespace etl
///\ingroup container
//*****************************************************************************
template<typename TValue, const size_t ARRAY_SIZE>
ETL_CONSTEXPR ETL_STD::reverse_iterator<const TValue*> crbegin(const TValue(&data)[ARRAY_SIZE])
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator<const TValue*> crbegin(const TValue(&data)[ARRAY_SIZE])
{
return ETL_STD::reverse_iterator<const TValue*>(&data[ARRAY_SIZE]);
return ETL_OR_STD::reverse_iterator<const TValue*>(&data[ARRAY_SIZE]);
}
//*****************************************************************************
@ -227,9 +226,9 @@ namespace etl
///\ingroup container
//*****************************************************************************
template<typename TValue, const size_t ARRAY_SIZE>
ETL_CONSTEXPR ETL_STD::reverse_iterator<TValue*> rend(const TValue(&data)[ARRAY_SIZE])
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator<TValue*> rend(const TValue(&data)[ARRAY_SIZE])
{
return ETL_STD::reverse_iterator<TValue*>(&data[0]);
return ETL_OR_STD::reverse_iterator<TValue*>(&data[0]);
}
//*****************************************************************************
@ -237,31 +236,9 @@ namespace etl
///\ingroup container
//*****************************************************************************
template<typename TValue, const size_t ARRAY_SIZE>
ETL_CONSTEXPR ETL_STD::reverse_iterator<const TValue*> crend(const TValue(&data)[ARRAY_SIZE])
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator<const TValue*> crend(const TValue(&data)[ARRAY_SIZE])
{
return ETL_STD::reverse_iterator<const TValue*>(&data[0]);
}
//*****************************************************************************
/// Get the next iterator.
///\ingroup container
//*****************************************************************************
template<class TIterator>
TIterator next(TIterator iterator, ptrdiff_t n = 1)
{
ETL_STD::advance(iterator, n);
return iterator;
}
//*****************************************************************************
/// Get the previous iterator.
///\ingroup container
//*****************************************************************************
template<class TIterator>
TIterator prev(TIterator iterator, ptrdiff_t n = 1)
{
ETL_STD::advance(iterator, -n);
return iterator;
return ETL_OR_STD::reverse_iterator<const TValue*>(&data[0]);
}
///**************************************************************************

2
include/etl/cstring.h
View File

@ -191,7 +191,7 @@ namespace etl
{
ETL_ASSERT(position < this->size(), ETL_ERROR(string_out_of_bounds));
length_ = ETL_STD::min(length_, this->size() - position);
length_ = etlstd::min(length_, this->size() - position);
new_string.assign(buffer + position, buffer + position + length_);
}

12
include/etl/cumulative_moving_average.h
View File

@ -44,8 +44,8 @@ namespace etl
template <typename T,
const size_t SAMPLE_SIZE,
const size_t SCALING = 1U,
const bool IsIntegral = etl::is_integral<T>::value,
const bool IsFloat = etl::is_floating_point<T>::value>
const bool IsIntegral = etlstd::is_integral<T>::value,
const bool IsFloat = etlstd::is_floating_point<T>::value>
class cumulative_moving_average;
//***************************************************************************
@ -58,8 +58,8 @@ namespace etl
template <typename T, const size_t SAMPLE_SIZE_, const size_t SCALING_>
class cumulative_moving_average<T, SAMPLE_SIZE_, SCALING_, true, false>
{
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type scale_t;
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type sample_t;
typedef typename etlstd::conditional<etlstd::is_signed<T>::value, int32_t, uint32_t>::type scale_t;
typedef typename etlstd::conditional<etlstd::is_signed<T>::value, int32_t, uint32_t>::type sample_t;
static const sample_t SAMPLES = static_cast<sample_t>(SAMPLE_SIZE_);
static const scale_t SCALE = static_cast<scale_t>(SCALING_);
@ -121,8 +121,8 @@ namespace etl
template <typename T, const size_t SCALING_>
class cumulative_moving_average<T, 0, SCALING_, true, false>
{
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type scale_t;
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type sample_t;
typedef typename etlstd::conditional<etlstd::is_signed<T>::value, int32_t, uint32_t>::type scale_t;
typedef typename etlstd::conditional<etlstd::is_signed<T>::value, int32_t, uint32_t>::type sample_t;
static const scale_t SCALE = static_cast<scale_t>(SCALING_);

24
include/etl/cyclic_value.h
View File

@ -43,7 +43,7 @@ SOFTWARE.
#include "static_assert.h"
#include "type_traits.h"
#include "stl/algorithm.h"
#include "algorithm.h"
namespace etl
{
@ -257,7 +257,13 @@ namespace etl
//*************************************************************************
void swap(cyclic_value<T, FIRST, LAST>& other)
{
ETL_STD::swap(value, other.value);
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
swap(value, other.value);
}
//*************************************************************************
@ -298,7 +304,7 @@ namespace etl
///\ingroup cyclic_value
//***************************************************************************
template <typename T, const T FIRST, const T LAST>
class cyclic_value<T, FIRST, LAST, typename etl::enable_if<(FIRST == 0) && (LAST == 0)>::type>
class cyclic_value<T, FIRST, LAST, typename etlstd::enable_if<(FIRST == 0) && (LAST == 0)>::type>
{
public:
@ -531,9 +537,15 @@ namespace etl
//*************************************************************************
void swap(cyclic_value<T, FIRST, LAST>& other)
{
ETL_STD::swap(first_value, other.first_value);
ETL_STD::swap(last_value, other.last_value);
ETL_STD::swap(value, other.value);
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
swap(first_value, other.first_value);
swap(last_value, other.last_value);
swap(value, other.value);
}
//*************************************************************************

154
include/etl/deque.h
View File

@ -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<pointer>::difference_type difference_type;
typedef typename etlstd::iterator_traits<pointer>::difference_type difference_type;
protected:
@ -247,7 +247,7 @@ namespace etl
/// Test for an iterator.
//*************************************************************************
template <typename TIterator>
struct is_iterator : public etl::integral_constant<bool, !etl::is_integral<TIterator>::value && !etl::is_floating_point<TIterator>::value>
struct is_iterator : public etl::integral_constant<bool, !etlstd::is_integral<TIterator>::value && !etlstd::is_floating_point<TIterator>::value>
{
};
@ -256,7 +256,7 @@ namespace etl
//*************************************************************************
/// Iterator
//*************************************************************************
struct iterator : public etl::iterator<ETL_RANDOM_ACCESS_ITERATOR_TAG, T>
struct iterator : public etl::iterator<ETL_OR_STD::random_access_iterator_tag, T>
{
friend class ideque;
@ -421,7 +421,13 @@ namespace etl
//***************************************************
void swap(iterator& other)
{
ETL_STD::swap(index, other.index);
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
swap(index, other.index);
}
private:
@ -442,7 +448,7 @@ namespace etl
//*************************************************************************
/// Const Iterator
//*************************************************************************
struct const_iterator : public etl::iterator<ETL_RANDOM_ACCESS_ITERATOR_TAG, const T>
struct const_iterator : public etl::iterator<ETL_OR_STD::random_access_iterator_tag, const T>
{
friend class ideque;
@ -603,7 +609,7 @@ namespace etl
//***************************************************
void swap(const_iterator& other)
{
ETL_STD::swap(index, other.index);
swap(index, other.index);
}
private:
@ -634,14 +640,14 @@ namespace etl
pointer p_buffer;
};
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Assigns a range to the deque.
//*************************************************************************
template<typename TIterator>
typename etl::enable_if<is_iterator<TIterator>::value, void>::type
typename etlstd::enable_if<is_iterator<TIterator>::value, void>::type
assign(TIterator range_begin, TIterator range_end)
{
initialise();
@ -893,13 +899,13 @@ namespace etl
else
{
// Are we closer to the front?
if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1))
if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1))
{
// Construct the _begin.
create_element_front(*_begin);
// Move the values.
ETL_STD::copy(_begin + 1, position, _begin);
etlstd::copy(_begin + 1, position, _begin);
// Write the new value.
*--position = value;
@ -910,7 +916,7 @@ namespace etl
create_element_back(*(_end - 1));
// Move the values.
ETL_STD::copy_backward(position, _end - 2, _end - 1);
etlstd::copy_backward(position, _end - 2, _end - 1);
// Write the new value.
*position = value;
@ -935,38 +941,38 @@ namespace etl
if (insert_position == begin())
{
create_element_front(ETL_STD::move(value));
create_element_front(etlstd::move(value));
position = _begin;
}
else if (insert_position == end())
{
create_element_back(ETL_STD::move(value));
create_element_back(etlstd::move(value));
position = _end - 1;
}
else
{
// Are we closer to the front?
if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1))
if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1))
{
// Construct the _begin.
create_element_front(ETL_STD::move(*_begin));
create_element_front(etlstd::move(*_begin));
// Move the values.
ETL_STD::move(_begin + 1, position, _begin);
etlstd::move(_begin + 1, position, _begin);
// Write the new value.
*--position = ETL_STD::move(value);
*--position = etlstd::move(value);
}
else
{
// Construct the _end.
create_element_back(ETL_STD::move(*(_end - 1)));
create_element_back(etlstd::move(*(_end - 1)));
// Move the values.
ETL_STD::move_backward(position, _end - 2, _end - 1);
etlstd::move_backward(position, _end - 2, _end - 1);
// Write the new value.
*position = ETL_STD::move(value);
*position = etlstd::move(value);
}
}
@ -1008,13 +1014,13 @@ namespace etl
else
{
// Are we closer to the front?
if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1))
if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1))
{
// Construct the _begin.
create_element_front(*_begin);
// Move the values.
ETL_STD::copy(_begin + 1, position, _begin);
etlstd::copy(_begin + 1, position, _begin);
// Write the new value.
--position;
@ -1027,7 +1033,7 @@ namespace etl
create_element_back(*(_end - 1));
// Move the values.
ETL_STD::copy_backward(position, _end - 2, _end - 1);
etlstd::copy_backward(position, _end - 2, _end - 1);
// Write the new value.
(*position).~T();
@ -1035,7 +1041,7 @@ namespace etl
}
}
::new (p) T(ETL_STD::forward<Args>(args)...);
::new (p) T(etlstd::forward<Args>(args)...);
return position;
}
@ -1075,13 +1081,13 @@ namespace etl
else
{
// Are we closer to the front?
if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1))
if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1))
{
// Construct the _begin.
create_element_front(*_begin);
// Move the values.
ETL_STD::copy(_begin + 1, position, _begin);
etlstd::copy(_begin + 1, position, _begin);
// Write the new value.
--position;
@ -1094,7 +1100,7 @@ namespace etl
create_element_back(*(_end - 1));
// Move the values.
ETL_STD::copy_backward(position, _end - 2, _end - 1);
etlstd::copy_backward(position, _end - 2, _end - 1);
// Write the new value.
(*position).~T();
@ -1140,13 +1146,13 @@ namespace etl
else
{
// Are we closer to the front?
if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1))
if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1))
{
// Construct the _begin.
create_element_front(*_begin);
// Move the values.
ETL_STD::copy(_begin + 1, position, _begin);
etlstd::copy(_begin + 1, position, _begin);
// Write the new value.
--position;
@ -1159,7 +1165,7 @@ namespace etl
create_element_back(*(_end - 1));
// Move the values.
ETL_STD::copy_backward(position, _end - 2, _end - 1);
etlstd::copy_backward(position, _end - 2, _end - 1);
// Write the new value.
(*position).~T();
@ -1205,13 +1211,13 @@ namespace etl
else
{
// Are we closer to the front?
if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1))
if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1))
{
// Construct the _begin.
create_element_front(*_begin);
// Move the values.
ETL_STD::copy(_begin + 1, position, _begin);
etlstd::copy(_begin + 1, position, _begin);
// Write the new value.
--position;
@ -1224,7 +1230,7 @@ namespace etl
create_element_back(*(_end - 1));
// Move the values.
ETL_STD::copy_backward(position, _end - 2, _end - 1);
etlstd::copy_backward(position, _end - 2, _end - 1);
// Write the new value.
(*position).~T();
@ -1270,13 +1276,13 @@ namespace etl
else
{
// Are we closer to the front?
if (ETL_STD::distance(_begin, position) < ETL_STD::distance(position, _end - 1))
if (etlstd::distance(_begin, position) < etlstd::distance(position, _end - 1))
{
// Construct the _begin.
create_element_front(*_begin);
// Move the values.
ETL_STD::copy(_begin + 1, position, _begin);
etlstd::copy(_begin + 1, position, _begin);
// Write the new value.
--position;
@ -1289,7 +1295,7 @@ namespace etl
create_element_back(*(_end - 1));
// Move the values.
ETL_STD::copy_backward(position, _end - 2, _end - 1);
etlstd::copy_backward(position, _end - 2, _end - 1);
// Write the new value.
(*position).~T();
@ -1343,8 +1349,8 @@ namespace etl
if (distance(_begin, insert_position) <= difference_type(current_size / 2))
{
size_t n_insert = n;
size_t n_move = ETL_STD::distance(begin(), position);
size_t n_create_copy = ETL_STD::min(n_insert, n_move);
size_t n_move = etlstd::distance(begin(), position);
size_t n_create_copy = etlstd::min(n_insert, n_move);
size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
size_t n_copy_old = n_move - n_create_copy;
@ -1372,15 +1378,15 @@ namespace etl
// Copy new.
to = position - n_create_copy;
ETL_STD::fill_n(to, n_copy_new, value);
etlstd::fill_n(to, n_copy_new, value);
position = _begin + n_move;
}
else
{
size_t n_insert = n;
size_t n_move = ETL_STD::distance(position, end());
size_t n_create_copy = ETL_STD::min(n_insert, n_move);
size_t n_move = etlstd::distance(position, end());
size_t n_create_copy = etlstd::min(n_insert, n_move);
size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
size_t n_copy_old = n_move - n_create_copy;
@ -1400,10 +1406,10 @@ namespace etl
}
// Copy old.
ETL_STD::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
etlstd::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
// Copy new.
ETL_STD::fill_n(position, n_copy_new, value);
etlstd::fill_n(position, n_copy_new, value);
}
}
@ -1423,7 +1429,7 @@ namespace etl
{
iterator position;
difference_type n = ETL_STD::distance(range_begin, range_end);
difference_type n = etlstd::distance(range_begin, range_end);
ETL_ASSERT((current_size + n) <= CAPACITY, ETL_ERROR(deque_full));
@ -1451,8 +1457,8 @@ namespace etl
if (distance(_begin, insert_position) < difference_type(current_size / 2))
{
size_t n_insert = n;
size_t n_move = ETL_STD::distance(begin(), position);
size_t n_create_copy = ETL_STD::min(n_insert, n_move);
size_t n_move = etlstd::distance(begin(), position);
size_t n_create_copy = etlstd::min(n_insert, n_move);
size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
size_t n_copy_old = n_move - n_create_copy;
@ -1482,8 +1488,8 @@ namespace etl
else
{
size_t n_insert = n;
size_t n_move = ETL_STD::distance(position, end());
size_t n_create_copy = ETL_STD::min(n_insert, n_move);
size_t n_move = etlstd::distance(position, end());
size_t n_create_copy = etlstd::min(n_insert, n_move);
size_t n_create_new = (n_insert > n_create_copy) ? n_insert - n_create_copy : 0;
size_t n_copy_new = (n_insert > n_create_new) ? n_insert - n_create_new : 0;
size_t n_copy_old = n_move - n_create_copy;
@ -1504,7 +1510,7 @@ namespace etl
}
// Copy old.
ETL_STD::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
etlstd::copy_backward(position, position + n_copy_old, position + n_insert + n_copy_old);
// Copy new.
item = range_begin;
@ -1541,13 +1547,13 @@ namespace etl
// Are we closer to the front?
if (distance(_begin, position) < difference_type(current_size / 2))
{
ETL_STD::copy_backward(_begin, position, position + 1);
etlstd::copy_backward(_begin, position, position + 1);
destroy_element_front();
++position;
}
else
{
ETL_STD::copy(position + 1, _end, position);
etlstd::copy(position + 1, _end, position);
destroy_element_back();
}
}
@ -1568,7 +1574,7 @@ namespace etl
ETL_ASSERT((distance(range_begin) <= difference_type(current_size)) && (distance(range_end) <= difference_type(current_size)), ETL_ERROR(deque_out_of_bounds));
// How many to erase?
size_t length = ETL_STD::distance(range_begin, range_end);
size_t length = etlstd::distance(range_begin, range_end);
// At the beginning?
if (position == _begin)
@ -1597,7 +1603,7 @@ namespace etl
if (distance(_begin, position) < difference_type(current_size / 2))
{
// Move the items.
ETL_STD::copy_backward(_begin, position, position + length);
etlstd::copy_backward(_begin, position, position + length);
for (size_t i = 0; i < length; ++i)
{
@ -1610,7 +1616,7 @@ namespace etl
// Must be closer to the back.
{
// Move the items.
ETL_STD::copy(position + length, _end, position);
etlstd::copy(position + length, _end, position);
for (size_t i = 0; i < length; ++i)
{
@ -1646,7 +1652,7 @@ namespace etl
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(!full(), ETL_ERROR(deque_full));
#endif
create_element_back(ETL_STD::move(item));
create_element_back(etlstd::move(item));
}
#endif
@ -1662,7 +1668,7 @@ namespace etl
ETL_ASSERT(!full(), ETL_ERROR(deque_full));
#endif
::new (&(*_end)) T(ETL_STD::forward<Args>(args)...);
::new (&(*_end)) T(etlstd::forward<Args>(args)...);
++_end;
++current_size;
ETL_INCREMENT_DEBUG_COUNT
@ -1774,7 +1780,7 @@ namespace etl
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(!full(), ETL_ERROR(deque_full));
#endif
create_element_front(ETL_STD::move(item));
create_element_front(etlstd::move(item));
}
#endif
@ -1791,7 +1797,7 @@ namespace etl
#endif
--_begin;
::new (&(*_begin)) T(ETL_STD::forward<Args>(args)...);
::new (&(*_begin)) T(etlstd::forward<Args>(args)...);
++current_size;
ETL_INCREMENT_DEBUG_COUNT
}
@ -1965,7 +1971,7 @@ namespace etl
iterator itr = rhs.begin();
while (itr != rhs.end())
{
push_back(ETL_STD::move(*itr));
push_back(etlstd::move(*itr));
++itr;
}
@ -2117,7 +2123,7 @@ namespace etl
void create_element_front(rvalue_reference value)
{
--_begin;
::new (&(*_begin)) T(ETL_STD::move(value));
::new (&(*_begin)) T(etlstd::move(value));
++current_size;
ETL_INCREMENT_DEBUG_COUNT
}
@ -2127,7 +2133,7 @@ namespace etl
//*********************************************************************
void create_element_back(rvalue_reference value)
{
::new (&(*_end)) T(ETL_STD::move(value));
::new (&(*_end)) T(etlstd::move(value));
++_end;
++current_size;
ETL_INCREMENT_DEBUG_COUNT
@ -2233,7 +2239,7 @@ namespace etl
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
typedef typename ETL_STD::iterator_traits<pointer>::difference_type difference_type;
typedef typename etlstd::iterator_traits<pointer>::difference_type difference_type;
//*************************************************************************
/// Default constructor.
@ -2278,7 +2284,7 @@ namespace etl
typename etl::ideque<T>::iterator itr = other.begin();
while (itr != other.end())
{
this->push_back(ETL_STD::move(*itr));
this->push_back(etlstd::move(*itr));
++itr;
}
@ -2342,7 +2348,7 @@ namespace etl
typename etl::ideque<T>::iterator itr = rhs.begin();
while (itr != rhs.end())
{
this->push_back(ETL_STD::move(*itr));
this->push_back(etlstd::move(*itr));
++itr;
}
@ -2371,7 +2377,7 @@ namespace etl
private:
/// The uninitialised buffer of T used in the deque.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[BUFFER_SIZE];
typename etl::aligned_storage<sizeof(T), etlstd::alignment_of<T>::value>::type buffer[BUFFER_SIZE];
};
//***************************************************************************
@ -2384,7 +2390,7 @@ namespace etl
template <typename T>
bool operator ==(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -2410,10 +2416,10 @@ namespace etl
template <typename T>
bool operator <(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
return etlstd::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
}
//***************************************************************************

18
include/etl/fixed_iterator.h
View File

@ -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 <typename TIterator>
class fixed_iterator : etl::iterator<typename ETL_STD::iterator_traits<TIterator>::iterator_category, typename ETL_STD::iterator_traits<TIterator>::value_type>
class fixed_iterator : etl::iterator<typename etlstd::iterator_traits<TIterator>::iterator_category, typename etlstd::iterator_traits<TIterator>::value_type>
{
public:
@ -100,7 +100,7 @@ namespace etl
//***************************************************************************
/// Dereference operator.
//***************************************************************************
typename ETL_STD::iterator_traits<TIterator>::value_type operator *()
typename etlstd::iterator_traits<TIterator>::value_type operator *()
{
return *it;
}
@ -108,7 +108,7 @@ namespace etl
//***************************************************************************
/// Dereference operator.
//***************************************************************************
const typename ETL_STD::iterator_traits<TIterator>::value_type operator *() const
const typename etlstd::iterator_traits<TIterator>::value_type operator *() const
{
return *it;
}
@ -140,7 +140,7 @@ namespace etl
//***************************************************************************
/// += operator.
//***************************************************************************
fixed_iterator& operator +=(typename ETL_STD::iterator_traits<TIterator>::difference_type /*offset*/)
fixed_iterator& operator +=(typename etlstd::iterator_traits<TIterator>::difference_type /*offset*/)
{
return *this;
}
@ -148,7 +148,7 @@ namespace etl
//***************************************************************************
/// -= operator.
//***************************************************************************
fixed_iterator& operator -=(typename ETL_STD::iterator_traits<TIterator>::difference_type /*offset*/)
fixed_iterator& operator -=(typename etlstd::iterator_traits<TIterator>::difference_type /*offset*/)
{
return *this;
}
@ -181,7 +181,7 @@ namespace etl
//*****************************************************************************
template <typename TIterator>
etl::fixed_iterator<TIterator>& operator +(etl::fixed_iterator<TIterator>& lhs,
typename ETL_STD::iterator_traits<TIterator>::difference_type /*rhs*/)
typename etlstd::iterator_traits<TIterator>::difference_type /*rhs*/)
{
return lhs;
}
@ -191,7 +191,7 @@ namespace etl
//*****************************************************************************
template <typename TIterator>
etl::fixed_iterator<TIterator>& operator -(etl::fixed_iterator<TIterator>& lhs,
typename ETL_STD::iterator_traits<TIterator>::difference_type /*rhs*/)
typename etlstd::iterator_traits<TIterator>::difference_type /*rhs*/)
{
return lhs;
}
@ -200,7 +200,7 @@ namespace etl
/// - fixed_iterator operator.
//*****************************************************************************
template <typename TIterator>
typename ETL_STD::iterator_traits<TIterator>::difference_type operator -(etl::fixed_iterator<TIterator>& lhs,
typename etlstd::iterator_traits<TIterator>::difference_type operator -(etl::fixed_iterator<TIterator>& lhs,
etl::fixed_iterator<TIterator>& rhs)
{
return TIterator(lhs) - TIterator(rhs);

20
include/etl/flat_map.h
View File

@ -40,7 +40,7 @@ SOFTWARE.
#if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_NO_STL)
#include <initializer_list>
#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 <typename TKey, typename TMapped, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TMapped, typename TKeyCompare = etlstd::less<TKey> >
class iflat_map : private etl::ireference_flat_map<TKey, TMapped, TKeyCompare>
{
private:
@ -85,9 +85,9 @@ namespace etl
typedef typename refmap_t::iterator iterator;
typedef typename refmap_t::const_iterator const_iterator;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -268,7 +268,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_map_full));
#endif
@ -352,7 +352,7 @@ namespace etl
// Create it.
value_type* pvalue = storage.allocate<value_type>();
::new ((void*)etl::addressof(pvalue->first)) key_type(key);
::new ((void*)etl::addressof(pvalue->second)) mapped_type(ETL_STD::forward<Args>(args)...);
::new ((void*)etl::addressof(pvalue->second)) mapped_type(etlstd::forward<Args>(args)...);
iterator i_element = lower_bound(key);
@ -793,7 +793,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator ==(const etl::iflat_map<TKey, TMapped, TKeyCompare>& lhs, const etl::iflat_map<TKey, TMapped, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -813,11 +813,11 @@ namespace etl
/// A flat_map implementation that uses a fixed size buffer.
///\tparam TKey The key type.
///\tparam TValue The value type.
///\tparam TCompare The type to compare keys. Default = ETL_STD::less<TKey>
///\tparam TCompare The type to compare keys. Default = etlstd::less<TKey>
///\tparam MAX_SIZE_ The maximum number of elements that can be stored.
///\ingroup flat_map
//***************************************************************************
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = etlstd::less<TKey> >
class flat_map : public etl::iflat_map<TKey, TValue, TCompare>
{
public:

20
include/etl/flat_multimap.h
View File

@ -59,7 +59,7 @@ namespace etl
/// Can be used as a reference type for all flat_multimaps containing a specific type.
///\ingroup flat_multimap
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TMapped, typename TKeyCompare = etlstd::less<TKey> >
class iflat_multimap : public etl::ireference_flat_multimap<TKey, TMapped, TKeyCompare>
{
public:
@ -86,9 +86,9 @@ namespace etl
typedef typename refmap_t::iterator iterator;
typedef typename refmap_t::const_iterator const_iterator;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -237,7 +237,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multimap_full));
#endif
@ -334,7 +334,7 @@ namespace etl
// Create it.
value_type* pvalue = storage.allocate<value_type>();
::new ((void*)etl::addressof(pvalue->first)) key_type(key);
::new ((void*)etl::addressof(pvalue->second)) mapped_type(ETL_STD::forward<Args>(args)...);
::new ((void*)etl::addressof(pvalue->second)) mapped_type(etlstd::forward<Args>(args)...);
iterator i_element = lower_bound(key);
ETL_INCREMENT_DEBUG_COUNT
@ -431,7 +431,7 @@ namespace etl
}
else
{
size_t d = ETL_STD::distance(range.first, range.second);
size_t d = etlstd::distance(range.first, range.second);
erase(range.first, range.second);
return d;
}
@ -700,7 +700,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator ==(const etl::iflat_multimap<TKey, TMapped, TKeyCompare>& lhs, const etl::iflat_multimap<TKey, TMapped, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -720,11 +720,11 @@ namespace etl
/// A flat_multimap implementation that uses a fixed size buffer.
///\tparam TKey The key type.
///\tparam TValue The value type.
///\tparam TCompare The type to compare keys. Default = ETL_STD::less<TKey>
///\tparam TCompare The type to compare keys. Default = etlstd::less<TKey>
///\tparam MAX_SIZE_ The maximum number of elements that can be stored.
///\ingroup flat_multimap
//***************************************************************************
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = etlstd::less<TKey> >
class flat_multimap : public etl::iflat_multimap<TKey, TValue, TCompare>
{
public:

22
include/etl/flat_multiset.h
View File

@ -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 <typename T, typename TKeyCompare = ETL_STD::less<T> >
template <typename T, typename TKeyCompare = etlstd::less<T> >
class iflat_multiset : private etl::ireference_flat_multiset<T, TKeyCompare>
{
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<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -209,7 +209,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multiset_full));
#endif
@ -232,7 +232,7 @@ namespace etl
ETL_ASSERT(!full(), ETL_ERROR(flat_multiset_full));
iterator i_element = ETL_STD::lower_bound(begin(), end(), value, compare);
iterator i_element = etlstd::lower_bound(begin(), end(), value, compare);
value_type* pvalue = storage.allocate<value_type>();
::new (pvalue) value_type(value);
@ -289,7 +289,7 @@ namespace etl
// Create it.
value_type* pvalue = storage.allocate<value_type>();
::new (pvalue) value_type(ETL_STD::forward<Args>(args)...);
::new (pvalue) value_type(etlstd::forward<Args>(args)...);
iterator i_element = lower_bound(*pvalue);
@ -385,7 +385,7 @@ namespace etl
}
else
{
size_t d = ETL_STD::distance(range.first, range.second);
size_t d = etlstd::distance(range.first, range.second);
erase(range.first, range.second);
return d;
}
@ -656,7 +656,7 @@ namespace etl
template <typename T, typename TKeyCompare>
bool operator ==(const etl::iflat_multiset<T, TKeyCompare>& lhs, const etl::iflat_multiset<T, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -675,11 +675,11 @@ namespace etl
//***************************************************************************
/// A flat_multiset implementation that uses a fixed size buffer.
///\tparam T The value type.
///\tparam TCompare The type to compare keys. Default = ETL_STD::less<T>
///\tparam TCompare The type to compare keys. Default = etlstd::less<T>
///\tparam MAX_SIZE_ The maximum number of elements that can be stored.
///\ingroup flat_multiset
//***************************************************************************
template <typename T, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<T> >
template <typename T, const size_t MAX_SIZE_, typename TCompare = etlstd::less<T> >
class flat_multiset : public etl::iflat_multiset<T, TCompare>
{
public:

18
include/etl/flat_set.h
View File

@ -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 <typename T, typename TKeyCompare = ETL_STD::less<T> >
template <typename T, typename TKeyCompare = etlstd::less<T> >
class iflat_set : private etl::ireference_flat_set<T, TKeyCompare>
{
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<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -211,7 +211,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full));
#endif
@ -296,7 +296,7 @@ namespace etl
// Create it.
value_type* pvalue = storage.allocate<value_type>();
::new (pvalue) value_type(ETL_STD::forward<Args>(args)...);
::new (pvalue) value_type(etlstd::forward<Args>(args)...);
iterator i_element = lower_bound(*pvalue);
@ -739,7 +739,7 @@ namespace etl
template <typename T, typename TKeyCompare>
bool operator ==(const etl::iflat_set<T, TKeyCompare>& lhs, const etl::iflat_set<T, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -758,11 +758,11 @@ namespace etl
//***************************************************************************
/// A flat_set implementation that uses a fixed size buffer.
///\tparam T The value type.
///\tparam TCompare The type to compare keys. Default = ETL_STD::less<T>
///\tparam TCompare The type to compare keys. Default = etlstd::less<T>
///\tparam MAX_SIZE_ The maximum number of elements that can be stored.
///\ingroup flat_set
//***************************************************************************
template <typename T, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<T> >
template <typename T, const size_t MAX_SIZE_, typename TCompare = etlstd::less<T> >
class flat_set : public etl::iflat_set<T, TCompare>
{
public:

49
include/etl/forward_list.h
View File

@ -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<ETL_FORWARD_ITERATOR_TAG, T>
class iterator : public etl::iterator<ETL_OR_STD::forward_iterator_tag, T>
{
public:
@ -492,7 +492,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_FORWARD_ITERATOR_TAG, const T>
class const_iterator : public etl::iterator<ETL_OR_STD::forward_iterator_tag, const T>
{
public:
@ -572,7 +572,7 @@ namespace etl
const node_t* p_node;
};
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
//*************************************************************************
/// Gets the beginning of the forward_list.
@ -671,7 +671,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d >= 0, ETL_ERROR(forward_list_iterator));
#endif
@ -735,7 +735,7 @@ namespace etl
ETL_ASSERT(!full(), ETL_ERROR(forward_list_full));
#endif
data_node_t& data_node = allocate_data_node(ETL_STD::move(value));
data_node_t& data_node = allocate_data_node(etlstd::move(value));
insert_node_after(start_node, data_node);
}
#endif
@ -751,7 +751,7 @@ namespace etl
ETL_ASSERT(!full(), ETL_ERROR(forward_list_full));
#endif
data_node_t* p_data_node = p_node_pool->allocate<data_node_t>();
::new (&(p_data_node->value)) T(ETL_STD::forward<Args>(args)...);
::new (&(p_data_node->value)) T(etlstd::forward<Args>(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<data_node_t>();
::new (&(p_data_node->value)) T(ETL_STD::forward<Args>(args)...);
::new (&(p_data_node->value)) T(etlstd::forward<Args>(args)...);
ETL_INCREMENT_DEBUG_COUNT
insert_node_after(*position.p_node, *p_data_node);
@ -1001,7 +1001,7 @@ namespace etl
void insert_after(iterator position, TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT((d + size()) <= MAX_SIZE, ETL_ERROR(forward_list_full));
#endif
@ -1141,7 +1141,7 @@ namespace etl
//*************************************************************************
void unique()
{
unique(ETL_STD::equal_to<T>());
unique(etlstd::equal_to<T>());
}
//*************************************************************************
@ -1182,7 +1182,7 @@ namespace etl
//*************************************************************************
void sort()
{
sort(ETL_STD::less<T>());
sort(etlstd::less<T>());
}
//*************************************************************************
@ -1386,7 +1386,7 @@ namespace etl
//*************************************************************************
iforward_list& operator = (iforward_list&& rhs)
{
move_container(ETL_STD::move(rhs));
move_container(etlstd::move(rhs));
return *this;
}
@ -1460,7 +1460,7 @@ namespace etl
data_node_t& allocate_data_node(rvalue_reference value)
{
data_node_t* p_node = p_node_pool->allocate<data_node_t>();
::new (&(p_node->value)) T(ETL_STD::move(value));
::new (&(p_node->value)) T(etlstd::move(value));
ETL_INCREMENT_DEBUG_COUNT
return *p_node;
@ -1487,7 +1487,7 @@ namespace etl
{
ETL_ASSERT(!full(), ETL_ERROR(forward_list_full));
data_node_t& data_node = this->allocate_data_node(ETL_STD::move(*first++));
data_node_t& data_node = this->allocate_data_node(etlstd::move(*first++));
join(p_last_node, &data_node);
data_node.next = nullptr;
p_last_node = &data_node;
@ -1633,7 +1633,7 @@ namespace etl
forward_list(forward_list&& other)
: etl::iforward_list<T>(node_pool, MAX_SIZE, false)
{
this->move_container(ETL_STD::move(other));
this->move_container(etlstd::move(other));
}
#endif
@ -1686,7 +1686,7 @@ namespace etl
forward_list& operator = (forward_list&& rhs)
{
this->move_container(ETL_STD::move(rhs));
this->move_container(etlstd::move(rhs));
return *this;
}
@ -1774,7 +1774,7 @@ namespace etl
typename etl::iforward_list<T>::iterator itr = other.begin();
while (itr != other.end())
{
this->push_back(ETL_STD::move(*itr));
this->push_back(etlstd::move(*itr));
++itr;
}
@ -1831,7 +1831,7 @@ namespace etl
//*************************************************************************
forward_list& operator = (forward_list&& rhs)
{
this->move_container(ETL_STD::move(rhs));
this->move_container(etlstd::move(rhs));
return *this;
}
@ -1862,7 +1862,7 @@ namespace etl
bool operator ==(const etl::iforward_list<T>& lhs, const etl::iforward_list<T>& rhs)
{
return (lhs.size() == rhs.size()) &&
ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
@ -1887,10 +1887,7 @@ namespace etl
template <typename T>
bool operator <(const etl::iforward_list<T>& lhs, const etl::iforward_list<T>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

8
include/etl/frame_check_sequence.h
View File

@ -34,7 +34,7 @@ SOFTWARE.
#include "type_traits.h"
#include "binary.h"
#include "stl/iterator.h"
#include "iterator.h"
ETL_STATIC_ASSERT(ETL_8BIT_SUPPORT, "This file does not currently support targets with no 8bit type");
@ -56,7 +56,7 @@ namespace etl
typedef TPolicy policy_type;
typedef typename policy_type::value_type value_type;
ETL_STATIC_ASSERT(etl::is_unsigned<value_type>::value, "Signed frame check type not supported");
ETL_STATIC_ASSERT(etlstd::is_unsigned<value_type>::value, "Signed frame check type not supported");
//*************************************************************************
/// Default constructor.
@ -74,7 +74,7 @@ namespace etl
template<typename TIterator>
frame_check_sequence(TIterator begin, const TIterator end)
{
ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
reset();
add(begin, end);
@ -96,7 +96,7 @@ namespace etl
template<typename TIterator>
void add(TIterator begin, const TIterator end)
{
ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
while (begin != end)
{

126
include/etl/functional.h
View File

@ -39,7 +39,7 @@ SOFTWARE.
///\defgroup reference_wrapper reference_wrapper
///\ingroup functional
namespace etl
namespace etlstd
{
//***************************************************************************
/// A definition of reference_wrapper for those that don't have C++ 0x11 support.
@ -105,6 +105,130 @@ namespace etl
{
return reference_wrapper<const T>(t.get());
}
//***************************************************************************
template <typename T = void>
struct less
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs < rhs;
}
};
//***************************************************************************
template <typename T = void>
struct greater
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs > rhs;
}
};
//***************************************************************************
template <typename T = void>
struct equal_to
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs == rhs;
}
};
//***************************************************************************
template <typename T = void>
struct not_equal_to
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs != rhs;
}
};
//***************************************************************************
template <typename TArgumentType, typename TResultType>
struct unary_function
{
typedef TArgumentType argument_type;
typedef TResultType result_type;
};
//***************************************************************************
template <typename TFirstArgumentType, typename TSecondArgumentType, typename TResultType>
struct binary_function
{
typedef TFirstArgumentType first_argument_type;
typedef TSecondArgumentType second_argument_type;
typedef TResultType result_type;
};
//***************************************************************************
template <typename TFunction>
class binder1st : public etlstd::unary_function<typename TFunction::second_argument_type, typename TFunction::result_type>
{
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 <typename F, typename T>
binder1st<F> bind1st(const F& f, const T& x)
{
return binder1st<F>(f, x);
}
//***************************************************************************
template <typename TFunction >
class binder2nd : public etlstd::unary_function<typename TFunction::first_argument_type, typename TFunction::result_type>
{
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 <typename F, typename T>
binder2nd<F> bind2nd(const F& f, const T& x)
{
return binder2nd<F>(f, x);
}
}
#endif

2
include/etl/ihash.h
View File

@ -35,7 +35,7 @@ SOFTWARE.
#include "platform.h"
#include "stl/utility.h"
#include "utility.h"
#include "exception.h"
#include "error_handler.h"

43
include/etl/indirect_vector.h
View File

@ -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 <initializer_list>
@ -183,7 +182,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_RANDOM_ACCESS_ITERATOR_TAG, T>
class iterator : public etl::iterator<ETL_OR_STD::random_access_iterator_tag, T>
{
public:
@ -329,7 +328,7 @@ namespace etl
//*************************************************************************
/// const_iterator.
//*************************************************************************
class const_iterator : public etl::iterator<ETL_RANDOM_ACCESS_ITERATOR_TAG, const T>
class const_iterator : public etl::iterator<ETL_OR_STD::random_access_iterator_tag, const T>
{
public:
@ -459,8 +458,8 @@ namespace etl
indirect_const_iterator lookup_itr;
};
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
protected:
@ -717,10 +716,10 @@ namespace etl
template <typename TIterator>
void assign(TIterator first, TIterator last)
{
ETL_STATIC_ASSERT((etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<typename ETL_STD::iterator_traits<TIterator>::value_type>::type>::value), "Iterator type does not match container type");
ETL_STATIC_ASSERT((etlstd::is_same<typename etlstd::remove_cv<T>::type, typename etlstd::remove_cv<typename etlstd::iterator_traits<TIterator>::value_type>::type>::value), "Iterator type does not match container type");
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(static_cast<size_t>(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<T>(ETL_STD::move(value));
T* p = storage.create<T>(etlstd::move(value));
lookup.push_back(p);
}
#endif
@ -800,7 +799,7 @@ namespace etl
template <typename ... Args>
void emplace_back(Args && ... args)
{
T* p = storage.create<T>(ETL_STD::forward<Args>(args)...);
T* p = storage.create<T>(etlstd::forward<Args>(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>(T(ETL_STD::move(value)));
T* p = storage.create<T>(T(etlstd::move(value)));
position = iterator(lookup.insert(position.lookup_itr, p));
return position;
@ -908,7 +907,7 @@ namespace etl
{
ETL_ASSERT(!full(), ETL_ERROR(vector_full));
T* p = storage.create<T>(T(ETL_STD::forward<Args>(args)...));
T* p = storage.create<T>(T(etlstd::forward<Args>(args)...));
position = iterator(lookup.insert(position.lookup_itr, p));
return position;
@ -991,7 +990,7 @@ namespace etl
template <class TIterator>
void insert(iterator position, TIterator first, TIterator last)
{
size_t count = size_t(ETL_STD::distance(first, last));
size_t count = size_t(etlstd::distance(first, last));
ETL_ASSERT((size() + count) <= capacity(), ETL_ERROR(vector_full));
@ -1067,7 +1066,7 @@ namespace etl
iterator itr = rhs.begin();
while (itr != rhs.end())
{
push_back(ETL_STD::move(*itr));
push_back(etlstd::move(*itr));
++itr;
}
@ -1172,7 +1171,7 @@ namespace etl
while (itr != other.end())
{
push_back(ETL_STD::move(*itr));
push_back(etlstd::move(*itr));
++itr;
}
@ -1213,7 +1212,7 @@ namespace etl
template <typename T>
bool operator ==(const etl::iindirect_vector<T>& lhs, const etl::iindirect_vector<T>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -1239,7 +1238,7 @@ namespace etl
template <typename T>
bool operator <(const etl::iindirect_vector<T>& lhs, const etl::iindirect_vector<T>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//***************************************************************************
@ -1376,7 +1375,7 @@ namespace etl
indirect_vector(indirect_vector&& other)
: etl::iindirect_vector<T>(lookup_vector, storage_pool)
{
this->move_container(ETL_STD::move(other));
this->move_container(etlstd::move(other));
}
//*************************************************************************
@ -1384,7 +1383,7 @@ namespace etl
//*************************************************************************
indirect_vector& operator = (indirect_vector&& rhs)
{
this->move_container(ETL_STD::move(rhs));
this->move_container(etlstd::move(rhs));
return *this;
}
@ -1504,7 +1503,7 @@ namespace etl
: etl::iindirect_vector<T>(lookup_, pool_)
{
ETL_ASSERT(lookup_.capacity() <= pool_.capacity(), ETL_ERROR(indirect_vector_buffer_missmatch));
this->move_container(ETL_STD::move(other));
this->move_container(etlstd::move(other));
}
//*************************************************************************
@ -1512,7 +1511,7 @@ namespace etl
//*************************************************************************
indirect_vector& operator = (indirect_vector&& rhs)
{
this->move_container(ETL_STD::move(rhs));
this->move_container(etlstd::move(rhs));
return *this;
}

26
include/etl/integral_limits.h
View File

@ -74,7 +74,7 @@ namespace etl
static const signed char min = SCHAR_MIN;
static const signed char max = SCHAR_MAX;
static const int bits = CHAR_BIT;
static const bool is_signed = etl::is_signed<signed char>::value;
static const bool is_signed = etlstd::is_signed<signed char>::value;
};
//***************************************************************************
@ -86,7 +86,7 @@ namespace etl
static const unsigned char min = 0;
static const unsigned char max = UCHAR_MAX;
static const int bits = CHAR_BIT;
static const bool is_signed = etl::is_signed<unsigned char>::value;
static const bool is_signed = etlstd::is_signed<unsigned char>::value;
};
//***************************************************************************
@ -95,10 +95,10 @@ namespace etl
template <>
struct integral_limits<char>
{
static const char min = (etl::is_signed<char>::value) ? SCHAR_MIN : 0;
static const char max = (etl::is_signed<char>::value) ? SCHAR_MAX : char(UCHAR_MAX);
static const char min = (etlstd::is_signed<char>::value) ? SCHAR_MIN : 0;
static const char max = (etlstd::is_signed<char>::value) ? SCHAR_MAX : char(UCHAR_MAX);
static const int bits = CHAR_BIT;
static const bool is_signed = etl::is_signed<char>::value;
static const bool is_signed = etlstd::is_signed<char>::value;
};
//***************************************************************************
@ -110,7 +110,7 @@ namespace etl
static const short min = SHRT_MIN;
static const short max = SHRT_MAX;
static const int bits = CHAR_BIT * (sizeof(short) / sizeof(char));
static const bool is_signed = etl::is_signed<short>::value;
static const bool is_signed = etlstd::is_signed<short>::value;
};
//***************************************************************************
@ -122,7 +122,7 @@ namespace etl
static const unsigned short min = 0;
static const unsigned short max = USHRT_MAX;
static const int bits = CHAR_BIT * (sizeof(unsigned short) / sizeof(char));
static const bool is_signed = etl::is_signed<unsigned short>::value;
static const bool is_signed = etlstd::is_signed<unsigned short>::value;
};
//***************************************************************************
@ -134,7 +134,7 @@ namespace etl
static const int min = INT_MIN;
static const int max = INT_MAX;
static const int bits = CHAR_BIT * (sizeof(int) / sizeof(char));
static const bool is_signed = etl::is_signed<int>::value;
static const bool is_signed = etlstd::is_signed<int>::value;
};
//***************************************************************************
@ -146,7 +146,7 @@ namespace etl
static const unsigned int min = 0;
static const unsigned int max = UINT_MAX;
static const int bits = CHAR_BIT * (sizeof(unsigned int) / sizeof(char));
static const bool is_signed = etl::is_signed<unsigned int>::value;
static const bool is_signed = etlstd::is_signed<unsigned int>::value;
};
//***************************************************************************
@ -158,7 +158,7 @@ namespace etl
static const long min = LONG_MIN;
static const long max = LONG_MAX;
static const int bits = CHAR_BIT * (sizeof(long) / sizeof(char));
static const bool is_signed = etl::is_signed<long>::value;
static const bool is_signed = etlstd::is_signed<long>::value;
};
//***************************************************************************
@ -170,7 +170,7 @@ namespace etl
static const unsigned long min = 0;
static const unsigned long max = ULONG_MAX;
static const int bits = CHAR_BIT * (sizeof(unsigned long) / sizeof(char));
static const bool is_signed = etl::is_signed<unsigned long>::value;
static const bool is_signed = etlstd::is_signed<unsigned long>::value;
};
#ifndef LLONG_MAX
@ -194,7 +194,7 @@ namespace etl
static const long long min = LLONG_MIN;
static const long long max = LLONG_MAX;
static const int bits = CHAR_BIT * (sizeof(long long) / sizeof(char));
static const bool is_signed = etl::is_signed<long long>::value;
static const bool is_signed = etlstd::is_signed<long long>::value;
};
//***************************************************************************
@ -206,7 +206,7 @@ namespace etl
static const unsigned long long min = 0;
static const unsigned long long max = ULLONG_MAX;
static const int bits = CHAR_BIT * (sizeof(unsigned long long) / sizeof(char));
static const bool is_signed = etl::is_signed<unsigned long long>::value;
static const bool is_signed = etlstd::is_signed<unsigned long long>::value;
};
}

22
include/etl/intrusive_forward_list.h
View File

@ -33,9 +33,9 @@ SOFTWARE.
#include "platform.h"
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "stl/functional.h"
#include "algorithm.h"
#include "iterator.h"
#include "functional.h"
#include "private/minmax_push.h"
@ -153,7 +153,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
intmax_t d = ETL_STD::distance(first, last);
intmax_t d = etlstd::distance(first, last);
ETL_ASSERT(d >= 0, ETL_ERROR(intrusive_forward_list_iterator_exception));
#endif
@ -328,7 +328,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_FORWARD_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::forward_iterator_tag, value_type>
{
public:
@ -418,7 +418,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_FORWARD_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::forward_iterator_tag, const value_type>
{
public:
@ -495,7 +495,7 @@ namespace etl
const value_type* p_value;
};
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
//*************************************************************************
/// Constructor.
@ -651,7 +651,7 @@ namespace etl
{
if (first != end() && (first != last))
{
this->current_size -= ETL_STD::distance(first, last) - 1;
this->current_size -= etlstd::distance(first, last) - 1;
link_type* p_first = first.p_value;
link_type* p_last = last.p_value;
@ -712,7 +712,7 @@ namespace etl
//*************************************************************************
void sort()
{
sort(ETL_STD::less<value_type>());
sort(etlstd::less<value_type>());
}
//*************************************************************************
@ -958,7 +958,7 @@ namespace etl
{
if (&other != this)
{
size_t n = ETL_STD::distance(begin_, end_) - 1;
size_t n = etlstd::distance(begin_, end_) - 1;
this->current_size += n;
other.current_size -= n;
}
@ -987,7 +987,7 @@ namespace etl
//*************************************************************************
void merge(list_type& other)
{
merge(other, ETL_STD::less<value_type>());
merge(other, etlstd::less<value_type>());
}
//*************************************************************************

100
include/etl/intrusive_links.h
View File

@ -39,8 +39,8 @@ SOFTWARE.
#include "exception.h"
#include "error_handler.h"
#include "stl/utility.h"
#include "stl/algorithm.h"
#include "utility.h"
#include "algorithm.h"
#undef ETL_FILE
#define ETL_FILE "22"
@ -110,7 +110,7 @@ namespace etl
// Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link(TLink& lhs, TLink& rhs)
{
lhs.etl_next = &rhs;
@ -118,7 +118,7 @@ namespace etl
// Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link_splice(TLink& lhs, TLink& rhs)
{
rhs.etl_next = lhs.etl_next;
@ -127,7 +127,7 @@ namespace etl
// Pointer, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link(TLink* lhs, TLink* rhs)
{
if (lhs != nullptr)
@ -138,7 +138,7 @@ namespace etl
// Pointer, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link_splice(TLink* lhs, TLink* rhs)
{
if (lhs != nullptr)
@ -154,7 +154,7 @@ namespace etl
// Reference, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link(TLink& lhs, TLink* rhs)
{
lhs.etl_next = rhs;
@ -162,7 +162,7 @@ namespace etl
// Reference, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link_splice(TLink& lhs, TLink* rhs)
{
if (rhs != nullptr)
@ -175,7 +175,7 @@ namespace etl
// Pointer, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link(TLink* lhs, TLink& rhs)
{
if (lhs != nullptr)
@ -186,7 +186,7 @@ namespace etl
// Pointer, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link_splice(TLink* lhs, TLink& rhs)
{
if (lhs != nullptr)
@ -198,7 +198,7 @@ namespace etl
// Reference, Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link_splice(TLink& lhs, TLink& first, TLink& last)
{
last.etl_next = lhs.etl_next;
@ -207,7 +207,7 @@ namespace etl
// Pointer, Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
link_splice(TLink* lhs, TLink& first, TLink& last)
{
if (lhs != nullptr)
@ -223,7 +223,7 @@ namespace etl
// Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
unlink_after(TLink& node)
{
if (node.etl_next != nullptr)
@ -235,7 +235,7 @@ namespace etl
// Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::forward_link<TLink::ID> >::value, void>::type
unlink_after(TLink& before, TLink& last)
{
before.etl_next = last.etl_next;
@ -265,7 +265,13 @@ namespace etl
void reverse()
{
ETL_STD::swap(etl_previous, etl_next);
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
swap(etl_previous, etl_next);
}
bidirectional_link* etl_previous;
@ -289,7 +295,7 @@ namespace etl
// Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link(TLink& lhs, TLink& rhs)
{
lhs.etl_next = &rhs;
@ -298,7 +304,7 @@ namespace etl
// Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link_splice(TLink& lhs, TLink& rhs)
{
rhs.etl_next = lhs.etl_next;
@ -314,7 +320,7 @@ namespace etl
// Pointer, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link(TLink* lhs, TLink* rhs)
{
if (lhs != nullptr)
@ -330,7 +336,7 @@ namespace etl
// Pointer, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link_splice(TLink* lhs, TLink* rhs)
{
if (rhs != nullptr)
@ -356,7 +362,7 @@ namespace etl
// Reference, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link(TLink& lhs, TLink* rhs)
{
lhs.etl_next = rhs;
@ -369,7 +375,7 @@ namespace etl
// Reference, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link_splice(TLink& lhs, TLink* rhs)
{
if (rhs != nullptr)
@ -388,7 +394,7 @@ namespace etl
// Pointer, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link(TLink* lhs, TLink& rhs)
{
if (lhs != nullptr)
@ -401,7 +407,7 @@ namespace etl
// Pointer, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link_splice(TLink* lhs, TLink& rhs)
{
if (lhs != nullptr)
@ -424,7 +430,7 @@ namespace etl
// Reference, Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link_splice(TLink& lhs, TLink& first, TLink& last)
{
last.etl_next = lhs.etl_next;
@ -440,7 +446,7 @@ namespace etl
// Pointer, Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
link_splice(TLink* lhs, TLink& first, TLink& last)
{
if (lhs != nullptr)
@ -467,7 +473,7 @@ namespace etl
// Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
unlink(TLink& node)
{
node.unlink();
@ -475,7 +481,7 @@ namespace etl
// Reference Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::bidirectional_link<TLink::ID> >::value, void>::type
unlink(TLink& first, TLink& last)
{
if (&first == &last)
@ -526,7 +532,7 @@ namespace etl
// Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_left(TLink& parent, TLink& leaf)
{
parent.etl_left = &leaf;
@ -534,7 +540,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_right(TLink& parent, TLink& leaf)
{
parent.etl_right = &leaf;
@ -543,7 +549,7 @@ namespace etl
// Pointer, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_left(TLink* parent, TLink* leaf)
{
if (parent != nullptr)
@ -558,7 +564,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_right(TLink* parent, TLink* leaf)
{
if (parent != nullptr)
@ -574,7 +580,7 @@ namespace etl
// Reference, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_left(TLink& parent, TLink* leaf)
{
parent.etl_left = leaf;
@ -586,7 +592,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_right(TLink& parent, TLink* leaf)
{
parent.etl_right = leaf;
@ -599,7 +605,7 @@ namespace etl
// Pointer, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_left(TLink* parent, TLink& leaf)
{
if (parent != nullptr)
@ -611,7 +617,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_right(TLink* parent, TLink& leaf)
{
if (parent != nullptr)
@ -624,7 +630,7 @@ namespace etl
// Reference, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_left(TLink& parent, TLink& leaf)
{
parent.etl_right = leaf.etl_left;
@ -640,7 +646,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_right(TLink& parent, TLink& leaf)
{
parent.etl_left = leaf.etl_right;
@ -657,7 +663,7 @@ namespace etl
// Pointer, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_left(TLink* parent, TLink* leaf)
{
if ((parent != nullptr) && (leaf != nullptr))
@ -667,7 +673,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_right(TLink* parent, TLink* leaf)
{
if ((parent != nullptr) && (leaf != nullptr))
@ -678,7 +684,7 @@ namespace etl
// Reference, Pointer
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_left(TLink& parent, TLink* leaf)
{
if (leaf != nullptr)
@ -688,7 +694,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_right(TLink& parent, TLink* leaf)
{
if (leaf != nullptr)
@ -699,7 +705,7 @@ namespace etl
// Pointer, Reference
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_left(TLink* parent, TLink& leaf)
{
if (parent != nullptr)
@ -709,7 +715,7 @@ namespace etl
}
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate_right(TLink* parent, TLink& leaf)
{
if (parent != nullptr)
@ -721,7 +727,7 @@ namespace etl
// Reference, Reference
/// Automatically detects whether a left or right rotate is expected.
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate(TLink& parent, TLink& leaf)
{
if (parent.etl_left == &leaf)
@ -737,7 +743,7 @@ namespace etl
// Pointer, Pointer
/// Automatically detects whether a left or right rotate is expected.
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate(TLink* parent, TLink* leaf)
{
if ((parent != nullptr) && (leaf != nullptr))
@ -756,7 +762,7 @@ namespace etl
// Reference, Pointer
/// Automatically detects whether a left or right rotate is expected.
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate(TLink& parent, TLink* leaf)
{
if (leaf != nullptr)
@ -775,7 +781,7 @@ namespace etl
// Pointer, Reference
/// Automatically detects whether a left or right rotate is expected.
template <typename TLink>
typename etl::enable_if<etl::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
typename etlstd::enable_if<etlstd::is_same<TLink, etl::tree_link<TLink::ID> >::value, void>::type
link_rotate(TLink* parent, TLink& leaf)
{
if (parent != nullptr)

22
include/etl/intrusive_list.h
View File

@ -47,9 +47,9 @@ SOFTWARE.
#include "algorithm.h"
#include "iterator.h"
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "stl/functional.h"
#include "algorithm.h"
#include "iterator.h"
#include "functional.h"
#undef ETL_FILE
#define ETL_FILE "21"
@ -133,7 +133,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
intmax_t d = ETL_STD::distance(first, last);
intmax_t d = etlstd::distance(first, last);
ETL_ASSERT(d >= 0, ETL_ERROR(intrusive_list_iterator_exception));
#endif
@ -383,7 +383,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -488,7 +488,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -580,7 +580,7 @@ namespace etl
const value_type* p_value;
};
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
//*************************************************************************
/// Constructor.
@ -734,7 +734,7 @@ namespace etl
// Join the ends.
etl::link<link_type>(p_first->etl_previous, p_last);
this->current_size -= ETL_STD::distance(first, last);
this->current_size -= etlstd::distance(first, last);
if (p_last == &this->terminal_link)
{
@ -781,7 +781,7 @@ namespace etl
//*************************************************************************
void sort()
{
sort(ETL_STD::less<value_type>());
sort(etlstd::less<value_type>());
}
//*************************************************************************
@ -1013,7 +1013,7 @@ namespace etl
{
if (&other != this)
{
size_t n = ETL_STD::distance(begin_, end_);
size_t n = etlstd::distance(begin_, end_);
this->current_size += n;
other.current_size -= n;
}
@ -1036,7 +1036,7 @@ namespace etl
//*************************************************************************
void merge(list_type& other)
{
merge(other, ETL_STD::less<value_type>());
merge(other, etlstd::less<value_type>());
}
//*************************************************************************

20
include/etl/io_port.h
View File

@ -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 <typename T, uintptr_t ADDRESS = 0>
class io_port_rw : public etl::iterator<ETL_FORWARD_ITERATOR_TAG, T>
class io_port_rw : public etl::iterator<ETL_OR_STD::forward_iterator_tag, T>
{
public:
@ -129,7 +129,7 @@ namespace etl
/// Read only port.
//***************************************************************************
template <typename T, uintptr_t ADDRESS = 0>
class io_port_ro : public etl::iterator<ETL_INPUT_ITERATOR_TAG, T>
class io_port_ro : public etl::iterator<ETL_OR_STD::input_iterator_tag, T>
{
public:
@ -193,7 +193,7 @@ namespace etl
/// Write only port.
//***************************************************************************
template <typename T, uintptr_t ADDRESS = 0>
class io_port_wo : public etl::iterator<ETL_OUTPUT_ITERATOR_TAG, T>
class io_port_wo : public etl::iterator<ETL_OR_STD::output_iterator_tag, T>
{
public:
@ -257,7 +257,7 @@ namespace etl
/// Write only port with shadow register.
//***************************************************************************
template <typename T, uintptr_t ADDRESS = 0>
class io_port_wos : public etl::iterator<ETL_FORWARD_ITERATOR_TAG, T>
class io_port_wos : public etl::iterator<ETL_OR_STD::forward_iterator_tag, T>
{
public:
@ -336,7 +336,7 @@ namespace etl
/// Specialisation for dynamic addresses.
//***************************************************************************
template <typename T>
class io_port_rw<T, 0> : public etl::iterator<ETL_FORWARD_ITERATOR_TAG, T>
class io_port_rw<T, 0> : public etl::iterator<ETL_OR_STD::forward_iterator_tag, T>
{
public:
@ -447,7 +447,7 @@ namespace etl
/// Specialisation for dynamic addresses.
//***************************************************************************
template <typename T>
class io_port_ro<T, 0> : public etl::iterator<ETL_INPUT_ITERATOR_TAG, T>
class io_port_ro<T, 0> : public etl::iterator<ETL_OR_STD::input_iterator_tag, T>
{
public:
@ -536,7 +536,7 @@ namespace etl
/// Specialisation for dynamic addresses.
//***************************************************************************
template <typename T>
class io_port_wo<T, 0> : public etl::iterator<ETL_OUTPUT_ITERATOR_TAG, T>
class io_port_wo<T, 0> : public etl::iterator<ETL_OR_STD::output_iterator_tag, T>
{
public:
@ -631,7 +631,7 @@ namespace etl
/// Specialisation for dynamic addresses.
//***************************************************************************
template <typename T>
class io_port_wos<T, 0> : public etl::iterator<ETL_FORWARD_ITERATOR_TAG, T>
class io_port_wos<T, 0> : public etl::iterator<ETL_OR_STD::forward_iterator_tag, T>
{
public:
@ -640,7 +640,7 @@ namespace etl
typedef volatile T& reference;
typedef volatile const T& const_reference;
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, T>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, T>
{
typedef io_port_wos<T, 0> iop_t;

426
include/etl/iterator.h
View File

@ -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 <iterator>
#endif
///\defgroup iterator iterator
///\ingroup utilities
namespace etl
namespace etlstd
{
//***************************************************************************
// iterator tags
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
//***************************************************************************
// iterator_traits
template <typename TIterator>
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 <typename T>
struct iterator_traits<T*>
{
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 <typename T>
struct iterator_traits<const T*>
{
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 <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::output_iterator_tag)
{
while (n--)
{
++itr;
}
}
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::forward_iterator_tag)
{
while (n--)
{
++itr;
}
}
template <typename TIterator, typename TDistance>
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 <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OR_STD::random_access_iterator_tag)
{
itr += n;
}
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance(TIterator& itr, TDistance n)
{
typedef typename etlstd::iterator_traits<TIterator>::iterator_category tag;
advance_helper(itr, n, tag());
}
#else
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance(TIterator& itr, TDistance n)
{
std::advance(itr, n);
}
#endif
//***************************************************************************
// distance
#if defined(ETL_NO_STL)
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::input_iterator_tag)
{
typename etlstd::iterator_traits<TIterator>::difference_type d = 0;
while (first != last)
{
++d;
++first;
}
return d;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::forward_iterator_tag)
{
typename etlstd::iterator_traits<TIterator>::difference_type d = 0;
while (first != last)
{
++d;
++first;
}
return d;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::bidirectional_iterator_tag)
{
typename etlstd::iterator_traits<TIterator>::difference_type d = 0;
while (first != last)
{
++d;
++first;
}
return d;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_OR_STD::random_access_iterator_tag)
{
return last - first;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance(TIterator first, TIterator last)
{
typedef typename etlstd::iterator_traits<TIterator>::iterator_category tag;
return distance_helper(first, last, tag());
}
#else
template<typename TIterator>
ETL_CONSTEXPR17 typename std::iterator_traits<TIterator>::difference_type distance(TIterator first, TIterator last)
{
return std::distance(first, last);
}
#endif
//***************************************************************************
// Previous
template<typename TIterator>
ETL_CONSTEXPR17 TIterator prev(TIterator itr, typename etlstd::iterator_traits<TIterator>::difference_type n = 1)
{
#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED
etlstd::advance(itr, -n);
#else
std::advance(itr, -n);
#endif
return itr;
}
//***************************************************************************
// Next
template<typename TIterator>
ETL_CONSTEXPR17 TIterator next(TIterator itr, typename etlstd::iterator_traits<TIterator>::difference_type n = 1)
{
#if defined(ETL_NO_STL) || !ETL_CPP11_SUPPORTED
etlstd::advance(itr, n);
#else
std::advance(itr, n);
#endif
return itr;
}
//***************************************************************************
// reverse_iterator
template <typename TIterator>
class reverse_iterator
{
public:
typedef typename iterator_traits<TIterator>::iterator_category iterator_category;
typedef typename iterator_traits<TIterator>::value_type value_type;
typedef typename iterator_traits<TIterator>::difference_type difference_type;
typedef typename iterator_traits<TIterator>::pointer pointer;
typedef typename iterator_traits<TIterator>::reference reference;
typedef TIterator iterator_type;
ETL_CONSTEXPR17 reverse_iterator()
: current()
{
}
ETL_CONSTEXPR17 explicit reverse_iterator(TIterator itr)
: current(itr)
{
}
template <typename TOther>
ETL_CONSTEXPR17 reverse_iterator(const reverse_iterator<TOther>& other)
: current(other.base())
{
}
template<class TOther>
ETL_CONSTEXPR17 reverse_iterator& operator=(const reverse_iterator<TOther>& 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 <class TIterator>
inline ETL_CONSTEXPR17 bool operator ==(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return lhs.base() == rhs.base();
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator !=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return !(lhs == rhs);
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator <(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return rhs.base() < lhs.base();
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator >(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return rhs < lhs;
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator <=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return !(rhs < lhs);
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator >=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return !(lhs < rhs);
}
template <class TIterator>
inline ETL_CONSTEXPR17 typename reverse_iterator<TIterator>::difference_type operator -(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return rhs.base() - lhs.base();
}
template <class TIterator, class TDifference>
inline ETL_CONSTEXPR17 reverse_iterator<TIterator> operator +(TDifference n, const reverse_iterator<TIterator>& itr)
{
return itr.operator +(n);
}
//***************************************************************************
/// iterator
//***************************************************************************
@ -55,78 +426,81 @@ namespace etl
typedef TCategory iterator_category;
};
}
namespace etl
{
//***************************************************************************
// Helper templates.
//***************************************************************************
// Helper templates.
//***************************************************************************
template <typename T>
struct is_input_iterator
{
static const bool value = etl::is_same<typename ETL_STD::iterator_traits<T>::iterator_category, ETL_INPUT_ITERATOR_TAG>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same<typename etlstd::iterator_traits<T>::iterator_category, ETL_OR_STD::input_iterator_tag>::value;
};
template <typename T>
struct is_output_iterator
{
static const bool value = etl::is_same<typename ETL_STD::iterator_traits<T>::iterator_category, ETL_OUTPUT_ITERATOR_TAG>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same<typename etlstd::iterator_traits<T>::iterator_category, ETL_OR_STD::output_iterator_tag>::value;
};
template <typename T>
struct is_forward_iterator
{
static const bool value = etl::is_same<typename ETL_STD::iterator_traits<T>::iterator_category, ETL_FORWARD_ITERATOR_TAG>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same<typename etlstd::iterator_traits<T>::iterator_category, ETL_OR_STD::forward_iterator_tag>::value;
};
template <typename T>
struct is_bidirectional_iterator
{
static const bool value = etl::is_same<typename ETL_STD::iterator_traits<T>::iterator_category, ETL_BIDIRECTIONAL_ITERATOR_TAG>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same<typename etlstd::iterator_traits<T>::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value;
};
template <typename T>
struct is_random_iterator
{
static const bool value = etl::is_same<typename ETL_STD::iterator_traits<T>::iterator_category, ETL_RANDOM_ACCESS_ITERATOR_TAG>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etlstd::is_same<typename etlstd::iterator_traits<T>::iterator_category, ETL_OR_STD::random_access_iterator_tag>::value;
};
template <typename T>
struct is_input_iterator_concept
{
static const bool value = etl::is_input_iterator<T>::value ||
etl::is_forward_iterator<T>::value ||
etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etl::is_input_iterator<T>::value ||
etl::is_forward_iterator<T>::value ||
etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
};
template <typename T>
struct is_output_iterator_concept
{
static const bool value = etl::is_output_iterator<T>::value ||
etl::is_forward_iterator<T>::value ||
etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etl::is_output_iterator<T>::value ||
etl::is_forward_iterator<T>::value ||
etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
};
template <typename T>
struct is_forward_iterator_concept
{
static const bool value = etl::is_forward_iterator<T>::value ||
etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etl::is_forward_iterator<T>::value ||
etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
};
template <typename T>
struct is_bidirectional_iterator_concept
{
static const bool value = etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etl::is_bidirectional_iterator<T>::value ||
etl::is_random_iterator<T>::value;
};
template <typename T>
struct is_random_iterator_concept
{
static const bool value = etl::is_random_iterator<T>::value;
static ETL_CONST_OR_CONSTEXPR bool value = etl::is_random_iterator<T>::value;
};
}
#endif

2
include/etl/jenkins.h
View File

@ -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

36
include/etl/largest.h
View File

@ -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<T1>() > etl::size_of<largest_other>()), // Boolean
T1, // TrueType
largest_other> // FalseType
::type; // The largest type of the two.
using type = typename etlstd::conditional<(etl::size_of<T1>::value > etl::size_of<largest_other>::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<type>()
size = etl::size_of<type>::value
};
};
@ -106,7 +106,7 @@ namespace etl
enum
{
size = etl::size_of<type>()
size = etl::size_of<type>::value
};
};
#else
@ -128,7 +128,7 @@ namespace etl
// Set 'type' to be the largest of the first parameter and any of the others.
// This is recursive.
typedef typename etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean
typedef typename etlstd::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean
T1, // TrueType
largest_other> // FalseType
::type type; // The largest type of the two.
@ -170,7 +170,7 @@ namespace etl
// Set 'type' to be the largest of the first parameter and any of the others.
// This is recursive.
using type = typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean
using type = typename etlstd::conditional<(etlstd::alignment_of<T1>::value > etlstd::alignment_of<largest_other>::value), // Boolean
T1, // TrueType
largest_other> // FalseType
::type; // The largest type of the two.
@ -178,7 +178,7 @@ namespace etl
// The largest alignment.
enum
{
value = etl::alignment_of<type>::value
value = etlstd::alignment_of<type>::value
};
};
@ -192,7 +192,7 @@ namespace etl
enum
{
value = etl::alignment_of<type>::value
value = etlstd::alignment_of<type>::value
};
};
#else
@ -213,7 +213,7 @@ namespace etl
// Set 'type' to be the largest of the first parameter and any of the others.
// This is recursive.
typedef typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean
typedef typename etlstd::conditional<(etlstd::alignment_of<T1>::value > etlstd::alignment_of<largest_other>::value), // Boolean
T1, // TrueType
largest_other> // FalseType
::type type; // The largest type of the two.
@ -221,7 +221,7 @@ namespace etl
// The largest alignment.
enum
{
value = etl::alignment_of<type>::value
value = etlstd::alignment_of<type>::value
};
};
@ -236,7 +236,7 @@ namespace etl
enum
{
value = etl::alignment_of<type>::value
value = etlstd::alignment_of<type>::value
};
};
#endif
@ -249,7 +249,7 @@ namespace etl
template <typename T>
struct larger_int_type
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_int_for_bits<etl::integral_limits<typename etl::make_signed<T>::type>::bits + 1>::type type;
};
@ -262,7 +262,7 @@ namespace etl
template <typename T>
struct larger_uint_type
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_uint_for_bits<etl::integral_limits<typename etl::make_unsigned<T>::type>::bits + 1>::type type;
};
@ -273,13 +273,13 @@ namespace etl
/// The returned type will be of the same sign.
///\ingroup largest
//***************************************************************************
template <typename T, bool IS_SIGNED = etl::is_signed<T>::value>
template <typename T, bool IS_SIGNED = etlstd::is_signed<T>::value>
struct larger_type;
template <typename T>
struct larger_type<T, false>
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_uint_for_bits<etl::integral_limits<T>::bits + 1>::type type;
};
@ -287,7 +287,7 @@ namespace etl
template <typename T>
struct larger_type<T, true>
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_int_for_bits<etl::integral_limits<T>::bits + 1>::type type;
};

36
include/etl/largest_generator.h
View File

@ -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<T1>() > etl::size_of<largest_other>()), // Boolean
T1, // TrueType
largest_other> // FalseType
::type; // The largest type of the two.
using type = typename etlstd::conditional<(etl::size_of<T1>::value > etl::size_of<largest_other>::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<type>()
size = etl::size_of<type>::value
};
};
@ -118,7 +118,7 @@ namespace etl
enum
{
size = etl::size_of<type>()
size = etl::size_of<type>::value
};
};
#else
@ -151,7 +151,7 @@ namespace etl
cog.outl("")
cog.outl(" // Set 'type' to be the largest of the first parameter and any of the others.")
cog.outl(" // This is recursive.")
cog.outl(" typedef typename etl::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean")
cog.outl(" typedef typename etlstd::conditional<(sizeof(T1) > sizeof(largest_other)), // Boolean")
cog.outl(" T1, // TrueType")
cog.outl(" largest_other> // FalseType")
cog.outl(" ::type type; // The largest type of the two.")
@ -200,7 +200,7 @@ namespace etl
// Set 'type' to be the largest of the first parameter and any of the others.
// This is recursive.
using type = typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean
using type = typename etlstd::conditional<(etlstd::alignment_of<T1>::value > etlstd::alignment_of<largest_other>::value), // Boolean
T1, // TrueType
largest_other> // FalseType
::type; // The largest type of the two.
@ -208,7 +208,7 @@ namespace etl
// The largest alignment.
enum
{
value = etl::alignment_of<type>::value
value = etlstd::alignment_of<type>::value
};
};
@ -222,7 +222,7 @@ namespace etl
enum
{
value = etl::alignment_of<type>::value
value = etlstd::alignment_of<type>::value
};
};
#else
@ -254,7 +254,7 @@ namespace etl
cog.outl("")
cog.outl(" // Set 'type' to be the largest of the first parameter and any of the others.")
cog.outl(" // This is recursive.")
cog.outl(" typedef typename etl::conditional<(etl::alignment_of<T1>::value > etl::alignment_of<largest_other>::value), // Boolean")
cog.outl(" typedef typename etlstd::conditional<(etlstd::alignment_of<T1>::value > etlstd::alignment_of<largest_other>::value), // Boolean")
cog.outl(" T1, // TrueType")
cog.outl(" largest_other> // FalseType")
cog.outl(" ::type type; // The largest type of the two.")
@ -262,7 +262,7 @@ namespace etl
cog.outl(" // The largest alignment.")
cog.outl(" enum")
cog.outl(" {")
cog.outl(" value = etl::alignment_of<type>::value")
cog.outl(" value = etlstd::alignment_of<type>::value")
cog.outl(" };")
cog.outl("};")
cog.outl("")
@ -282,7 +282,7 @@ namespace etl
cog.outl("")
cog.outl(" enum")
cog.outl(" {")
cog.outl(" value = etl::alignment_of<type>::value")
cog.outl(" value = etlstd::alignment_of<type>::value")
cog.outl(" };")
cog.outl("};")
]]]*/
@ -297,7 +297,7 @@ namespace etl
template <typename T>
struct larger_int_type
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_int_for_bits<etl::integral_limits<typename etl::make_signed<T>::type>::bits + 1>::type type;
};
@ -310,7 +310,7 @@ namespace etl
template <typename T>
struct larger_uint_type
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_uint_for_bits<etl::integral_limits<typename etl::make_unsigned<T>::type>::bits + 1>::type type;
};
@ -321,13 +321,13 @@ namespace etl
/// The returned type will be of the same sign.
///\ingroup largest
//***************************************************************************
template <typename T, bool IS_SIGNED = etl::is_signed<T>::value>
template <typename T, bool IS_SIGNED = etlstd::is_signed<T>::value>
struct larger_type;
template <typename T>
struct larger_type<T, false>
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_uint_for_bits<etl::integral_limits<T>::bits + 1>::type type;
};
@ -335,7 +335,7 @@ namespace etl
template <typename T>
struct larger_type<T, true>
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Must be an integral type");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Must be an integral type");
typedef typename etl::smallest_int_for_bits<etl::integral_limits<T>::bits + 1>::type type;
};

53
include/etl/stl/alternate/limits.h → include/etl/limits.h
View File

@ -28,21 +28,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_STL_ALTERNATE_LIMITS_INCLUDED
#define ETL_STL_ALTERNATE_LIMITS_INCLUDED
#ifndef ETL_LIMITS_INCLUDED
#define ETL_LIMITS_INCLUDED
#include "../../platform.h"
#include "../../type_traits.h"
#include "../../char_traits.h"
#include "../../integral_limits.h"
#include "../../private/choose_tag_types.h"
#include "../../private/choose_pair_types.h"
#include "platform.h"
#include "type_traits.h"
#include "char_traits.h"
#include "integral_limits.h"
#include <limits.h>
#include <stdint.h>
#include <float.h>
#if defined(ETL_NO_STL)
#define ETL_LOG2(x) (((x) * 301) / 1000)
namespace etlstd
@ -82,10 +80,10 @@ namespace etlstd
static ETL_CONSTEXPR T epsilon() { return 0; }
static ETL_CONSTEXPR T round_error() { return 0; }
static ETL_CONST_OR_CONSTEXPR int digits = (CHAR_BIT * sizeof(T)) - (etl::is_signed<T>::value ? 1 : 0);
static ETL_CONST_OR_CONSTEXPR int digits = (CHAR_BIT * sizeof(T)) - (etlstd::is_signed<T>::value ? 1 : 0);
static ETL_CONST_OR_CONSTEXPR int digits10 = ETL_LOG2(digits);
static ETL_CONST_OR_CONSTEXPR bool is_signed = etl::is_signed<T>::value;
static ETL_CONST_OR_CONSTEXPR bool is_signed = etlstd::is_signed<T>::value;
static ETL_CONST_OR_CONSTEXPR int min_exponent = 0;
static ETL_CONST_OR_CONSTEXPR int min_exponent10 = 0;
@ -105,7 +103,7 @@ namespace etlstd
static ETL_CONST_OR_CONSTEXPR bool is_iec559 = false;
static ETL_CONST_OR_CONSTEXPR bool is_bounded = true;
static ETL_CONST_OR_CONSTEXPR bool is_modulo = etl::is_unsigned<T>::value;
static ETL_CONST_OR_CONSTEXPR bool is_modulo = etlstd::is_unsigned<T>::value;
static ETL_CONST_OR_CONSTEXPR bool traps = false;
static ETL_CONST_OR_CONSTEXPR bool tinyness_before = false;
@ -257,6 +255,7 @@ namespace etlstd
static ETL_CONSTEXPR char16_t min() { return 0; }
static ETL_CONSTEXPR char16_t max() { return UINT_LEAST16_MAX; }
static ETL_CONSTEXPR char16_t lowest() { return 0; }
static ETL_CONST_OR_CONSTEXPR bool is_modulo = true;
};
//***************************************************************************
@ -269,6 +268,7 @@ namespace etlstd
static ETL_CONSTEXPR char32_t min() { return 0; }
static ETL_CONSTEXPR char32_t max() { return UINT_LEAST32_MAX; }
static ETL_CONSTEXPR char32_t lowest() { return 0; }
static ETL_CONST_OR_CONSTEXPR bool is_modulo = true;
};
#endif
@ -450,4 +450,33 @@ namespace etlstd
};
}
#else
#include <limits>
namespace etlstd
{
enum float_round_style
{
round_indeterminate = std::float_round_style::round_indeterminate,
round_toward_zero = std::float_round_style::round_toward_zero,
round_to_nearest = std::float_round_style::round_to_nearest,
round_toward_infinity = std::float_round_style::round_toward_infinity,
round_toward_neg_infinity = std::float_round_style::round_toward_neg_infinity,
};
enum float_denorm_style
{
denorm_indeterminate = std::float_denorm_style::denorm_indeterminate,
denorm_absent = std::float_denorm_style::denorm_absent,
denorm_present = std::float_denorm_style::denorm_present
};
template <typename T>
class numeric_limits : public std::numeric_limits<T>
{
};
}
#endif
#endif

73
include/etl/list.h
View File

@ -37,9 +37,9 @@ SOFTWARE.
#include "platform.h"
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "stl/functional.h"
#include "algorithm.h"
#include "iterator.h"
#include "functional.h"
#include "container.h"
#include "pool.h"
@ -182,7 +182,7 @@ namespace etl
//***********************************************************************
inline void reverse()
{
ETL_STD::swap(previous, next);
swap(previous, next);
}
node_t* previous;
@ -482,7 +482,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, T>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, T>
{
public:
@ -583,7 +583,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const T>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const T>
{
public:
@ -676,10 +676,10 @@ namespace etl
const node_t* p_node;
};
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Gets the beginning of the list.
@ -810,7 +810,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d >= 0, ETL_ERROR(list_iterator));
ETL_ASSERT(size_t(d) <= MAX_SIZE, ETL_ERROR(list_full));
#endif
@ -866,7 +866,7 @@ namespace etl
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(!full(), ETL_ERROR(list_full));
#endif
insert_node(get_head(), allocate_data_node(ETL_STD::move(value)));
insert_node(get_head(), allocate_data_node(etlstd::move(value)));
}
#endif
@ -883,7 +883,7 @@ namespace etl
ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool));
data_node_t* p_data_node = p_node_pool->allocate<data_node_t>();
::new (&(p_data_node->value)) T(ETL_STD::forward<Args>(args)...);
::new (&(p_data_node->value)) T(etlstd::forward<Args>(args)...);
ETL_INCREMENT_DEBUG_COUNT
insert_node(get_head(), *p_data_node);
}
@ -989,7 +989,7 @@ namespace etl
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(!full(), ETL_ERROR(list_full));
#endif
insert_node(terminal_node, allocate_data_node(ETL_STD::move(value)));
insert_node(terminal_node, allocate_data_node(etlstd::move(value)));
}
#endif
@ -1006,7 +1006,7 @@ namespace etl
ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool));
data_node_t* p_data_node = p_node_pool->allocate<data_node_t>();
::new (&(p_data_node->value)) T(ETL_STD::forward<Args>(args)...);
::new (&(p_data_node->value)) T(etlstd::forward<Args>(args)...);
ETL_INCREMENT_DEBUG_COUNT
insert_node(terminal_node, *p_data_node);
}
@ -1101,7 +1101,7 @@ namespace etl
{
ETL_ASSERT(!full(), ETL_ERROR(list_full));
data_node_t& data_node = allocate_data_node(ETL_STD::move(value));
data_node_t& data_node = allocate_data_node(etlstd::move(value));
insert_node(*position.p_node, data_node);
return iterator(data_node);
@ -1119,7 +1119,7 @@ namespace etl
ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool));
data_node_t* p_data_node = p_node_pool->allocate<data_node_t>();
::new (&(p_data_node->value)) T(ETL_STD::forward<Args>(args)...);
::new (&(p_data_node->value)) T(etlstd::forward<Args>(args)...);
ETL_INCREMENT_DEBUG_COUNT
insert_node(*position.p_node, *p_data_node);
@ -1269,7 +1269,7 @@ namespace etl
else if (n < size())
{
iterator i_start = end();
ETL_STD::advance(i_start, -difference_type(size() - n));
etlstd::advance(i_start, -difference_type(size() - n));
erase(i_start, end());
}
// Larger?
@ -1334,7 +1334,7 @@ namespace etl
//*************************************************************************
void unique()
{
unique(ETL_STD::equal_to<T>());
unique(etlstd::equal_to<T>());
}
//*************************************************************************
@ -1390,7 +1390,7 @@ namespace etl
typename ilist<T>::iterator itr = other.begin();
while (itr != other.end())
{
to = insert(to, ETL_STD::move(*itr++));
to = insert(to, etlstd::move(*itr++));
}
other.erase(other.begin(), other.end());
@ -1430,7 +1430,7 @@ namespace etl
else
{
// From another list.
insert(to, ETL_STD::move(*from));
insert(to, etlstd::move(*from));
other.erase(from);
}
}
@ -1471,7 +1471,7 @@ namespace etl
ilist::iterator itr = first;
while (itr != last)
{
to = insert(to, ETL_STD::move(*itr++));
to = insert(to, etlstd::move(*itr++));
++to;
}
@ -1485,7 +1485,7 @@ namespace etl
//*************************************************************************
void merge(ilist& other)
{
merge(other, ETL_STD::less<value_type>());
merge(other, etlstd::less<value_type>());
}
//*************************************************************************
@ -1542,7 +1542,7 @@ namespace etl
//*************************************************************************
void merge(ilist&& other)
{
merge(ETL_STD::move(other), ETL_STD::less<value_type>());
merge(etlstd::move(other), etlstd::less<value_type>());
}
//*************************************************************************
@ -1577,7 +1577,7 @@ namespace etl
{
while ((other_begin != other_end) && (compare(*other_begin, *this_begin)))
{
insert(this_begin, ETL_STD::move(*other_begin));
insert(this_begin, etlstd::move(*other_begin));
++other_begin;
}
}
@ -1588,7 +1588,7 @@ namespace etl
{
while (other_begin != other_end)
{
insert(this_end, ETL_STD::move(*other_begin++));
insert(this_end, etlstd::move(*other_begin++));
}
}
@ -1603,7 +1603,7 @@ namespace etl
//*************************************************************************
void sort()
{
sort(ETL_STD::less<T>());
sort(etlstd::less<T>());
}
//*************************************************************************
@ -1765,7 +1765,7 @@ namespace etl
iterator itr = rhs.begin();
while (itr != rhs.end())
{
push_back(ETL_STD::move(*itr));
push_back(etlstd::move(*itr));
++itr;
}
@ -1917,7 +1917,7 @@ namespace etl
ETL_ASSERT(p_node_pool != nullptr, ETL_ERROR(list_no_pool));
data_node_t* p_data_node = p_node_pool->allocate<data_node_t>();
::new (&(p_data_node->value)) T(ETL_STD::move(value));
::new (&(p_data_node->value)) T(etlstd::move(value));
ETL_INCREMENT_DEBUG_COUNT
return *p_data_node;
@ -2033,7 +2033,7 @@ namespace etl
typename etl::ilist<T>::iterator itr = other.begin();
while (itr != other.end())
{
this->push_back(ETL_STD::move(*itr));
this->push_back(etlstd::move(*itr));
++itr;
}
@ -2089,7 +2089,7 @@ namespace etl
typename etl::ilist<T>::iterator itr = rhs.begin();
while (itr != rhs.end())
{
this->push_back(ETL_STD::move(*itr));
this->push_back(etlstd::move(*itr));
++itr;
}
@ -2191,7 +2191,7 @@ namespace etl
typename etl::ilist<T>::iterator itr = other.begin();
while (itr != other.end())
{
this->push_back(ETL_STD::move(*itr));
this->push_back(etlstd::move(*itr));
++itr;
}
@ -2214,7 +2214,7 @@ namespace etl
//*************************************************************************
/// Construct from initializer_list.
//*************************************************************************
list(ETL_STD::initializer_list<T> init, etl::ipool& node_pool)
list(std::initializer_list<T> init, etl::ipool& node_pool)
: ilist<T>(node_pool, node_pool.max_size(), true)
{
this->assign(init.begin(), init.end());
@ -2247,7 +2247,7 @@ namespace etl
typename etl::ilist<T>::iterator itr = rhs.begin();
while (itr != rhs.end())
{
this->push_back(ETL_STD::move(*itr));
this->push_back(etlstd::move(*itr));
++itr;
}
@ -2282,7 +2282,7 @@ namespace etl
template <typename T>
bool operator ==(const etl::ilist<T>& lhs, const etl::ilist<T>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
@ -2307,10 +2307,7 @@ namespace etl
template <typename T>
bool operator <(const etl::ilist<T>& lhs, const etl::ilist<T>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

27
include/etl/map.h
View File

@ -37,9 +37,9 @@ SOFTWARE.
#include "platform.h"
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "stl/functional.h"
#include "algorithm.h"
#include "iterator.h"
#include "functional.h"
#include "container.h"
#include "pool.h"
@ -462,7 +462,7 @@ namespace etl
/// A templated base for all etl::map types.
///\ingroup map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TMapped, typename TKeyCompare = etlstd::less<TKey> >
class imap : public etl::map_base
{
public:
@ -575,7 +575,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -696,7 +696,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -804,10 +804,10 @@ namespace etl
friend class const_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Gets the beginning of the map.
@ -2042,7 +2042,7 @@ namespace etl
//*************************************************************************
/// A templated map implementation that uses a fixed size buffer.
//*************************************************************************
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = etlstd::less<TKey> >
class map : public etl::imap<TKey, TValue, TCompare>
{
public:
@ -2129,7 +2129,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator ==(const etl::imap<TKey, TMapped, TKeyCompare>& lhs, const etl::imap<TKey, TMapped, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -2155,10 +2155,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator <(const etl::imap<TKey, TMapped, TKeyCompare>& lhs, const etl::imap<TKey, TMapped, TKeyCompare>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

1192
include/etl/memory.h
View File

File diff suppressed because it is too large Load Diff

38
include/etl/message_bus.h
View File

@ -102,10 +102,10 @@ namespace etl
if (ok)
{
router_list_t::iterator irouter = ETL_STD::upper_bound(router_list.begin(),
router_list.end(),
router.get_message_router_id(),
compare_router_id());
router_list_t::iterator irouter = etlstd::upper_bound(router_list.begin(),
router_list.end(),
router.get_message_router_id(),
compare_router_id());
router_list.insert(irouter, &router);
}
@ -125,10 +125,10 @@ namespace etl
}
else
{
ETL_PAIR<router_list_t::iterator, router_list_t::iterator> range = ETL_STD::equal_range(router_list.begin(),
router_list.end(),
id,
compare_router_id());
ETL_PAIR<router_list_t::iterator, router_list_t::iterator> range = etlstd::equal_range(router_list.begin(),
router_list.end(),
id,
compare_router_id());
router_list.erase(range.first, range.second);
}
@ -137,9 +137,9 @@ namespace etl
//*******************************************
void unsubscribe(etl::imessage_router& router)
{
router_list_t::iterator irouter = ETL_STD::find(router_list.begin(),
router_list.end(),
&router);
router_list_t::iterator irouter = etlstd::find(router_list.begin(),
router_list.end(),
&router);
if (irouter != router_list.end())
{
@ -212,10 +212,10 @@ namespace etl
router_list_t::iterator irouter = router_list.begin();
// Find routers with the id.
ETL_PAIR<router_list_t::iterator, router_list_t::iterator> range = ETL_STD::equal_range(router_list.begin(),
router_list.end(),
destination_router_id,
compare_router_id());
ETL_PAIR<router_list_t::iterator, router_list_t::iterator> range = etlstd::equal_range(router_list.begin(),
router_list.end(),
destination_router_id,
compare_router_id());
// Call all of them.
while (range.first != range.second)
@ -230,10 +230,10 @@ namespace etl
// Do any message buses.
// These are always at the end of the list.
irouter = ETL_STD::lower_bound(router_list.begin(),
router_list.end(),
etl::imessage_bus::MESSAGE_BUS,
compare_router_id());
irouter = etlstd::lower_bound(router_list.begin(),
router_list.end(),
etl::imessage_bus::MESSAGE_BUS,
compare_router_id());
while (irouter != router_list.end())
{

27
include/etl/multimap.h
View File

@ -37,9 +37,9 @@ SOFTWARE.
#include "platform.h"
#include "stl/algorithm.h"
#include "stl/iterator.h"
#include "stl/functional.h"
#include "algorithm.h"
#include "iterator.h"
#include "functional.h"
#include "container.h"
#include "pool.h"
@ -624,7 +624,7 @@ namespace etl
/// A templated base for all etl::multimap types.
///\ingroup map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TMapped, typename TKeyCompare = etlstd::less<TKey> >
class imultimap : public etl::multimap_base
{
public:
@ -733,7 +733,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -853,7 +853,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -960,10 +960,10 @@ namespace etl
};
friend class const_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Gets the beginning of the multimap.
@ -1931,7 +1931,7 @@ namespace etl
//*************************************************************************
/// A templated multimap implementation that uses a fixed size buffer.
//*************************************************************************
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = etlstd::less<TKey> >
class multimap : public etl::imultimap<TKey, TValue, TCompare>
{
public:
@ -2018,7 +2018,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator ==(const etl::imultimap<TKey, TMapped, TKeyCompare>& lhs, const etl::imultimap<TKey, TMapped, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -2044,10 +2044,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator <(const etl::imultimap<TKey, TMapped, TKeyCompare>& lhs, const etl::imultimap<TKey, TMapped, TKeyCompare>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

24
include/etl/multiset.h
View File

@ -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 <typename T, typename TCompare = ETL_STD::less<T> >
template <typename T, typename TCompare = ETL_OR_STD::less<T> >
class imultiset : public etl::multiset_base
{
public:
@ -713,7 +713,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -818,7 +818,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -925,10 +925,10 @@ namespace etl
};
friend class const_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Gets the beginning of the multiset.
@ -1895,7 +1895,7 @@ namespace etl
//*************************************************************************
/// A templated multiset implementation that uses a fixed size buffer.
//*************************************************************************
template <typename T, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<T> >
template <typename T, const size_t MAX_SIZE_, typename TCompare = ETL_OR_STD::less<T> >
class multiset : public etl::imultiset<T, TCompare>
{
public:
@ -1982,7 +1982,7 @@ namespace etl
template <typename T, typename TCompare>
bool operator ==(const etl::imultiset<T, TCompare>& lhs, const etl::imultiset<T, TCompare>& 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 <typename T, typename TCompare>
bool operator <(const etl::imultiset<T, TCompare>& lhs, const etl::imultiset<T, TCompare>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(),
return ETL_OR_STD::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());

6
include/etl/murmur3.h
View File

@ -57,7 +57,7 @@ namespace etl
{
public:
ETL_STATIC_ASSERT((etl::is_same<THash, uint32_t>::value || etl::is_same<THash, uint64_t>::value), "Only 32 & 64 bit types supported");
ETL_STATIC_ASSERT((etlstd::is_same<THash, uint32_t>::value || etlstd::is_same<THash, uint64_t>::value), "Only 32 & 64 bit types supported");
typedef THash value_type;
@ -81,7 +81,7 @@ namespace etl
murmur3(TIterator begin, const TIterator end, value_type seed_ = 0)
: seed(seed_)
{
ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits<TIterator>::value_type) == 1, "Incompatible type");
ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits<TIterator>::value_type) == 1, "Incompatible type");
reset();
while (begin != end)
@ -119,7 +119,7 @@ namespace etl
template<typename TIterator>
void add(TIterator begin, const TIterator end)
{
ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits<TIterator>::value_type) == 1, "Incompatible type");
ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits<TIterator>::value_type) == 1, "Incompatible type");
ETL_ASSERT(!is_finalised, ETL_ERROR(hash_finalised));
while (begin != end)

4
include/etl/negative.h
View File

@ -39,7 +39,7 @@ namespace etl
// For signed types.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_signed<T>::value, bool>::type
typename etlstd::enable_if<etlstd::is_signed<T>::value, bool>::type
is_negative(const T value)
{
return (value < T(0));
@ -49,7 +49,7 @@ namespace etl
// For unsigned types.
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
typename etlstd::enable_if<etlstd::is_unsigned<T>::value, T>::type
is_negative(const T)
{
return false;

12
include/etl/observer.h
View File

@ -115,9 +115,9 @@ namespace etl
void add_observer(TObserver& observer)
{
// See if we already have it in our list.
typename Observer_List::const_iterator i_observer = ETL_STD::find(observer_list.begin(),
observer_list.end(),
&observer);
typename Observer_List::const_iterator i_observer = etlstd::find(observer_list.begin(),
observer_list.end(),
&observer);
// Not there?
if (i_observer == observer_list.end())
@ -138,9 +138,9 @@ namespace etl
bool remove_observer(TObserver& observer)
{
// See if we have it in our list.
typename Observer_List::iterator i_observer = ETL_STD::find(observer_list.begin(),
observer_list.end(),
&observer);
typename Observer_List::iterator i_observer = etlstd::find(observer_list.begin(),
observer_list.end(),
&observer);
// Found it?
if (i_observer != observer_list.end())

4
include/etl/optional.h
View File

@ -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>().~T();
}
::new (storage.template get_address<T>()) T(ETL_STD::forward<Args>(args)...);
::new (storage.template get_address<T>()) T(ETL_OR_STD::forward<Args>(args)...);
valid = true;
}
#else

8
include/etl/packet.h
View File

@ -64,9 +64,9 @@ namespace etl
template <typename T>
explicit packet(const T& value)
{
ETL_STATIC_ASSERT((etl::is_base_of<TBase, T>::value), "Unsupported type");
ETL_STATIC_ASSERT((etlstd::is_base_of<TBase, T>::value), "Unsupported type");
ETL_STATIC_ASSERT(sizeof(T) <= SIZE, "Unsupported size");
ETL_STATIC_ASSERT(etl::alignment_of<T>::value <= ALIGNMENT, "Unsupported alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<T>::value <= ALIGNMENT, "Unsupported alignment");
::new (static_cast<T*>(data)) T(value);
}
@ -86,9 +86,9 @@ namespace etl
template <typename T>
packet& operator =(const T& value)
{
ETL_STATIC_ASSERT((etl::is_base_of<TBase, T>::value), "Unsupported type");
ETL_STATIC_ASSERT((etlstd::is_base_of<TBase, T>::value), "Unsupported type");
ETL_STATIC_ASSERT(sizeof(T) <= SIZE, "Unsupported size");
ETL_STATIC_ASSERT(etl::alignment_of<T>::value <= ALIGNMENT, "Unsupported alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<T>::value <= ALIGNMENT, "Unsupported alignment");
static_cast<TBase*>(data)->~TBase();
::new (static_cast<T*>(data)) T(value);

2
include/etl/parameter_type.h
View File

@ -43,7 +43,7 @@ namespace etl
struct parameter_type
{
/// By default fundamental and pointer types are passed by value.
typedef typename etl::conditional<is_fundamental<T>::value || is_pointer<T>::value,
typedef typename etlstd::conditional<is_fundamental<T>::value || is_pointer<T>::value,
T,
const T&>::type type;
};

4
include/etl/pearson.h
View File

@ -81,7 +81,7 @@ namespace etl
pearson(TIterator begin, const TIterator end)
: first(true)
{
ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
reset();
add(begin, end);
@ -103,7 +103,7 @@ namespace etl
template<typename TIterator>
void add(TIterator begin, const TIterator end)
{
ETL_STATIC_ASSERT(sizeof(typename ETL_STD::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
ETL_STATIC_ASSERT(sizeof(typename etlstd::iterator_traits<TIterator>::value_type) == 1, "Type not supported");
while (begin != end)
{

5
include/etl/platform.h
View File

@ -102,4 +102,9 @@ SOFTWARE.
#define ETL_EXPLICIT_STRING_FROM_CHAR
#endif
// Sort out names for STL/No STL options.
#include "private/choose_namespace.h"
#include "private/choose_tag_types.h"
#include "private/choose_pair_types.h"
#endif

48
include/etl/pool.h
View File

@ -35,8 +35,8 @@ SOFTWARE.
#include <new>
#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>(args)...);
::new (p) T(etlstd::forward<Args>(args)...);
}
return p;
@ -492,7 +492,7 @@ namespace etl
template <typename U>
U* allocate()
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return ipool::allocate<U>();
}
@ -506,7 +506,7 @@ namespace etl
template <typename U>
U* create()
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return ipool::create<U>();
}
@ -519,7 +519,7 @@ namespace etl
template <typename U, typename T1>
U* create(const T1& value1)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return ipool::create<U>(value1);
}
@ -532,7 +532,7 @@ namespace etl
template <typename U, typename T1, typename T2>
U* create(const T1& value1, const T2& value2)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return ipool::create<U>(value1, value2);
}
@ -545,7 +545,7 @@ namespace etl
template <typename U, typename T1, typename T2, typename T3>
U* create(const T1& value1, const T2& value2, const T3& value3)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return ipool::create<U>(value1, value2, value3);
}
@ -558,7 +558,7 @@ namespace etl
template <typename U, typename T1, typename T2, typename T3, typename T4>
U* create(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return ipool::create<U>(value1, value2, value3, value4);
}
@ -569,9 +569,9 @@ namespace etl
template <typename U, typename... Args>
U* create(Args&&... args)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return ipool::create<U>(ETL_STD::forward<Args>(args)...);
return ipool::create<U>(etlstd::forward<Args>(args)...);
}
#endif
@ -583,7 +583,7 @@ namespace etl
template <typename U>
void destroy(const void* const p_object)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT_, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
reinterpret_cast<U*>((const_cast<void*>(p_object)))->~U();
ipool::release(p_object);
@ -600,7 +600,7 @@ namespace etl
};
///< The memory for the pool of objects.
typename etl::aligned_storage<sizeof(Element), etl::alignment_of<Element>::value>::type buffer[SIZE];
typename etl::aligned_storage<sizeof(Element), etlstd::alignment_of<Element>::value>::type buffer[SIZE];
static const uint32_t ELEMENT_SIZE = sizeof(Element);
@ -614,11 +614,11 @@ namespace etl
///\ingroup pool
//*************************************************************************
template <typename T, const size_t SIZE_>
class pool : public etl::generic_pool<sizeof(T), etl::alignment_of<T>::value, SIZE_>
class pool : public etl::generic_pool<sizeof(T), etlstd::alignment_of<T>::value, SIZE_>
{
private:
typedef etl::generic_pool<sizeof(T), etl::alignment_of<T>::value, SIZE_> base_t;
typedef etl::generic_pool<sizeof(T), etlstd::alignment_of<T>::value, SIZE_> base_t;
public:
@ -643,7 +643,7 @@ namespace etl
template <typename U>
U* allocate()
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return base_t::template allocate<U>();
}
@ -657,7 +657,7 @@ namespace etl
template <typename U>
U* create()
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return base_t::template create<U>();
}
@ -670,7 +670,7 @@ namespace etl
template <typename U, typename T1>
U* create(const T1& value1)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return base_t::template create<U>(value1);
}
@ -683,7 +683,7 @@ namespace etl
template <typename U, typename T1, typename T2>
U* create(const T1& value1, const T2& value2)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return base_t::template create<U>(value1, value2);
}
@ -696,7 +696,7 @@ namespace etl
template <typename U, typename T1, typename T2, typename T3>
U* create(const T1& value1, const T2& value2, const T3& value3)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return base_t::template create<U>(value1, value2, value3);
}
@ -709,7 +709,7 @@ namespace etl
template <typename U, typename T1, typename T2, typename T3, typename T4>
U* create(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return base_t::template create<U>(value1, value2, value3, value4);
}
@ -722,9 +722,9 @@ namespace etl
template <typename U, typename... Args>
U* create(Args&&... args)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
return base_t::template create<U>(ETL_STD::forward<Args>(args)...);
return base_t::template create<U>(etlstd::forward<Args>(args)...);
}
#endif
@ -736,7 +736,7 @@ namespace etl
template <typename U>
void destroy(const void* const p_object)
{
ETL_STATIC_ASSERT(etl::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(etlstd::alignment_of<U>::value <= ALIGNMENT, "Type has incompatible alignment");
ETL_STATIC_ASSERT(sizeof(U) <= TYPE_SIZE, "Type too large for pool");
reinterpret_cast<U*>((const_cast<void*>(p_object)))->~U();
base_t::release(p_object);

30
include/etl/priority_queue.h
View File

@ -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 <typename T, typename TContainer, typename TCompare = ETL_STD::less<T> >
template <typename T, typename TContainer, typename TCompare = etlstd::less<T> >
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<typename TContainer::iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<typename TContainer::iterator>::difference_type difference_type;
private:
@ -165,7 +165,7 @@ namespace etl
// Put element at end
container.push_back(value);
// Make elements in container into heap
ETL_STD::push_heap(container.begin(), container.end(), compare);
etlstd::push_heap(container.begin(), container.end(), compare);
}
#if ETL_CPP11_SUPPORTED && !defined(ETL_STLPORT) && !defined(ETL_PRIORITY_QUEUE_FORCE_CPP03)
@ -181,9 +181,9 @@ namespace etl
ETL_ASSERT(!full(), ETL_ERROR(etl::priority_queue_full));
// Put element at end
container.emplace_back(ETL_STD::forward<Args>(args)...);
container.emplace_back(etlstd::forward<Args>(args)...);
// Make elements in container into heap
ETL_STD::push_heap(container.begin(), container.end(), compare);
etlstd::push_heap(container.begin(), container.end(), compare);
}
#else
//*************************************************************************
@ -200,7 +200,7 @@ namespace etl
// Put element at end
container.emplace_back(value1);
// Make elements in container into heap
ETL_STD::push_heap(container.begin(), container.end(), compare);
etlstd::push_heap(container.begin(), container.end(), compare);
}
//*************************************************************************
@ -217,7 +217,7 @@ namespace etl
// Put element at end
container.emplace_back(value1, value2);
// Make elements in container into heap
ETL_STD::push_heap(container.begin(), container.end(), compare);
etlstd::push_heap(container.begin(), container.end(), compare);
}
//*************************************************************************
@ -234,7 +234,7 @@ namespace etl
// Put element at end
container.emplace_back(value1, value2, value3);
// Make elements in container into heap
ETL_STD::push_heap(container.begin(), container.end(), compare);
etlstd::push_heap(container.begin(), container.end(), compare);
}
//*************************************************************************
@ -251,7 +251,7 @@ namespace etl
// Put element at end
container.emplace_back(value1, value2, value3, value4);
// Make elements in container into heap
ETL_STD::push_heap(container.begin(), container.end(), compare);
etlstd::push_heap(container.begin(), container.end(), compare);
}
#endif
@ -268,14 +268,14 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d >= 0, ETL_ERROR(etl::priority_queue_iterator));
ETL_ASSERT(static_cast<size_t>(d) <= max_size(), ETL_ERROR(etl::priority_queue_full));
#endif
clear();
container.assign(first, last);
ETL_STD::make_heap(container.begin(), container.end(), compare);
etlstd::make_heap(container.begin(), container.end(), compare);
}
//*************************************************************************
@ -285,7 +285,7 @@ namespace etl
void pop()
{
// Move largest element to end
ETL_STD::pop_heap(container.begin(), container.end(), compare);
etlstd::pop_heap(container.begin(), container.end(), compare);
// Actually remove largest element at end
container.pop_back();
}
@ -386,7 +386,7 @@ namespace etl
/// \tparam T The type this queue should support.
/// \tparam SIZE The maximum capacity of the queue.
//***************************************************************************
template <typename T, const size_t SIZE, typename TContainer = etl::vector<T, SIZE>, typename TCompare = ETL_STD::less<typename TContainer::value_type> >
template <typename T, const size_t SIZE, typename TContainer = etl::vector<T, SIZE>, typename TCompare = etlstd::less<typename TContainer::value_type> >
class priority_queue : public etl::ipriority_queue<T, TContainer, TCompare>
{
public:

18
include/etl/private/choose_namespace.h
View File

@ -28,19 +28,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_STL_CHOOSE_NAMESPACE_INCLUDED
#define ETL_STL_CHOOSE_NAMESPACE_INCLUDED
#ifndef ETL_CHOOSE_NAMESPACE_INCLUDED
#define ETL_CHOOSE_NAMESPACE_INCLUDED
#include "../platform.h"
#if defined(ETL_NO_STL)
#ifndef ETL_STD
#define ETL_STD etlstd /// Namespace for the alternate STL.
#endif
#undef ETL_OR_STD
#if defined(ETL_NO_STL) && !defined(ETL_IN_UNIT_TEST)
// If we're not using the STL and we are not unit testing, then use the ETL's definitions under the etlstd namespace
#define ETL_OR_STD etlstd
#else
#ifndef ETL_STD
#define ETL_STD std /// Namespace for conventional STL
#endif
// We will use the STL's definitions under the std namespace
#define ETL_OR_STD std
#endif
#endif

46
include/etl/private/choose_pair_types.h
View File

@ -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 <utility>
#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

52
include/etl/private/choose_tag_types.h
View File

@ -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 <iterator>
#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

3
include/etl/private/crc16_poly_0x1021_.h
View File

@ -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

3
include/etl/private/crc16_poly_0x8005.h
View File

@ -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

3
include/etl/private/crc32_poly_0x04c11db7.h
View File

@ -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

3
include/etl/private/crc32_poly_0x1edc6f41.h
View File

@ -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

3
include/etl/private/crc64_poly_0x42f0e1eba9ea3693.h
View File

@ -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

3
include/etl/private/crc8_poly_0x07.h
View File

@ -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

20
include/etl/private/ivectorpointer.h
View File

@ -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<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t size_type;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -441,7 +441,7 @@ namespace etl
//*********************************************************************
void initialise_source_external_buffer_after_move()
{
ETL_SUBTRACT_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end)))
ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end)))
p_end = p_buffer;
}
@ -451,7 +451,7 @@ namespace etl
//*********************************************************************
void initialise_destination_external_buffer_after_move()
{
ETL_ADD_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end)))
ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end)))
}
};
@ -467,10 +467,10 @@ namespace etl
typedef const value_type* const_pointer;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t size_type;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -852,7 +852,7 @@ namespace etl
//*********************************************************************
void initialise_source_external_buffer_after_move()
{
ETL_SUBTRACT_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end)))
ETL_SUBTRACT_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end)))
p_end = p_buffer;
}
@ -862,7 +862,7 @@ namespace etl
//*********************************************************************
void initialise_destination_external_buffer_after_move()
{
ETL_ADD_DEBUG_COUNT(int32_t(ETL_STD::distance(p_buffer, p_end)))
ETL_ADD_DEBUG_COUNT(int32_t(etlstd::distance(p_buffer, p_end)))
}
};

36
include/etl/private/pvoidvector.h
View File

@ -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<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t size_type;
typedef ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef etlstd::iterator_traits<iterator>::difference_type difference_type;
public:
@ -211,7 +211,7 @@ namespace etl
// Size up if necessary.
if (p_end < p_new_end)
{
ETL_STD::fill(p_end, p_new_end, value);
etlstd::fill(p_end, p_new_end, value);
}
p_end = p_new_end;
@ -326,7 +326,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(static_cast<size_t>(d) <= CAPACITY, ETL_ERROR(vector_full));
#endif
@ -402,7 +402,7 @@ namespace etl
if (position != end())
{
++p_end;
ETL_STD::copy_backward(position, end() - 1, end());
etlstd::copy_backward(position, end() - 1, end());
*position = value;
}
else
@ -424,8 +424,8 @@ namespace etl
{
ETL_ASSERT((size() + 1) <= CAPACITY, ETL_ERROR(vector_full));
ETL_STD::copy_backward(position, p_end, p_end + n);
ETL_STD::fill_n(position, n, value);
etlstd::copy_backward(position, p_end, p_end + n);
etlstd::fill_n(position, n, value);
p_end += n;
}
@ -441,12 +441,12 @@ namespace etl
template <typename TIterator>
void insert(iterator position, TIterator first, TIterator last)
{
size_t count = ETL_STD::distance(first, last);
size_t count = etlstd::distance(first, last);
ETL_ASSERT((size() + count) <= CAPACITY, ETL_ERROR(vector_full));
ETL_STD::copy_backward(position, p_end, p_end + count);
ETL_STD::copy(first, last, position);
etlstd::copy_backward(position, p_end, p_end + count);
etlstd::copy(first, last, position);
p_end += count;
}
@ -457,7 +457,7 @@ namespace etl
//*********************************************************************
iterator erase(iterator i_element)
{
ETL_STD::copy(i_element + 1, end(), i_element);
etlstd::copy(i_element + 1, end(), i_element);
--p_end;
return i_element;
@ -473,8 +473,8 @@ namespace etl
//*********************************************************************
iterator erase(iterator first, iterator last)
{
ETL_STD::copy(last, end(), first);
size_t n_delete = ETL_STD::distance(first, last);
etlstd::copy(last, end(), first);
size_t n_delete = etlstd::distance(first, last);
// Just adjust the count.
p_end -= n_delete;
@ -580,7 +580,7 @@ namespace etl
//***************************************************************************
inline bool operator ==(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -604,7 +604,7 @@ namespace etl
//***************************************************************************
inline bool operator <(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//***************************************************************************

81
include/etl/private/to_string_helper.h
View File

@ -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 <typename TIString>
void add_alignment(TIString& str, typename TIString::iterator position, const etl::basic_format_spec<TIString>& format)
{
uint32_t length = static_cast<uint32_t>(ETL_STD::distance(position, str.end()));
uint32_t length = static_cast<uint32_t>(etlstd::distance(position, str.end()));
if (length < format.get_width())
{
@ -166,7 +165,7 @@ namespace etl
}
// Reverse the string we appended.
ETL_STD::reverse(start, str.end());
etlstd::reverse(start, str.end());
}
etl::private_to_string::add_alignment(str, start, format);
@ -242,7 +241,7 @@ namespace etl
else
{
// Make sure we format the two halves correctly.
uint32_t max_precision = ETL_STD::numeric_limits<T>::digits10;
uint32_t max_precision = etlstd::numeric_limits<T>::digits10;
etl::basic_format_spec<TIString> integral_format = format;
integral_format.decimal().width(0).precision(format.get_precision() > max_precision ? max_precision : format.get_precision());
@ -355,10 +354,10 @@ namespace etl
/// For signed integrals less than 64 bits. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, int64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_signed<T>::value &&
!etlstd::is_same<T, bool>::value &&
!etlstd::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const bool append = false)
{
etl::basic_format_spec<TIString> format;
@ -372,10 +371,10 @@ namespace etl
/// For signed integrals less than 64 bits. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, int64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_signed<T>::value &&
!etlstd::is_same<T, bool>::value &&
!etlstd::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_integral(int32_t(value), str, format, append);
@ -387,10 +386,10 @@ namespace etl
/// For unsigned integrals less then 64 bits. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, uint64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_unsigned<T>::value &&
!etlstd::is_same<T, bool>::value &&
!etlstd::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const bool append = false)
{
etl::basic_format_spec<TIString> format;
@ -404,10 +403,10 @@ namespace etl
/// For unsigned integrals less than 64 bits. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, uint64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_unsigned<T>::value &&
!etlstd::is_same<T, bool>::value &&
!etlstd::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_integral(uint32_t(value), str, format, append);
@ -419,10 +418,10 @@ namespace etl
/// For signed 64 bit integrals. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, int64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_signed<T>::value &&
!etlstd::is_same<T, bool>::value &&
etlstd::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const bool append = false)
{
etl::basic_format_spec<TIString> format;
@ -436,10 +435,10 @@ namespace etl
/// For signed 64 bit integrals. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, int64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_signed<T>::value &&
!etlstd::is_same<T, bool>::value &&
etlstd::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_integral(int64_t(value), str, format, append);
@ -451,10 +450,10 @@ namespace etl
/// For unsigned 64 bit integrals. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, uint64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_unsigned<T>::value &&
!etlstd::is_same<T, bool>::value &&
etlstd::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const bool append = false)
{
etl::basic_format_spec<TIString> format;
@ -468,10 +467,10 @@ namespace etl
/// For unsigned 64 bit integrals. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, uint64_t>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_integral<T>::value &&
etlstd::is_unsigned<T>::value &&
!etlstd::is_same<T, bool>::value &&
etlstd::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_integral(uint64_t(value), str, format, append);
@ -483,7 +482,7 @@ namespace etl
/// For floating point. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_floating_point<T>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_floating_point<T>::value, const TIString&>::type
to_string(const T value, TIString& str, const bool append = false)
{
etl::basic_format_spec<TIString> format;
@ -497,7 +496,7 @@ namespace etl
/// For floating point. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_floating_point<T>::value, const TIString&>::type
typename etlstd::enable_if<etlstd::is_floating_point<T>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_floating_point(value, str, format, append);

4
include/etl/queue.h
View File

@ -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>(args)...);
::new (&p_buffer[in]) T(etlstd::forward<Args>(args)...);
add_in();
}
#else
@ -582,7 +582,7 @@ namespace etl
private:
/// The uninitialised buffer of T used in the stack.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[SIZE];
typename etl::aligned_storage<sizeof(T), etlstd::alignment_of<T>::value>::type buffer[SIZE];
};
}

8
include/etl/queue_mpmc_mutex.h
View File

@ -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>(args)...);
bool result = emplace_implementation(etlstd::forward<Args>(args)...);
access.unlock();
@ -392,7 +392,7 @@ namespace etl
{
if (current_size != MAX_SIZE)
{
::new (&p_buffer[write_index]) T(ETL_STD::forward<Args>(args)...);
::new (&p_buffer[write_index]) T(etlstd::forward<Args>(args)...);
write_index = get_next_index(write_index, MAX_SIZE);
@ -585,7 +585,7 @@ namespace etl
queue_mpmc_mutex& operator = (const queue_mpmc_mutex&);
/// The uninitialised buffer of T used in the queue_mpmc_mutex.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[MAX_SIZE];
typename etl::aligned_storage<sizeof(T), etlstd::alignment_of<T>::value>::type buffer[MAX_SIZE];
};
}

4
include/etl/queue_spsc_atomic.h
View File

@ -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>(args)...);
::new (&p_buffer[write_index]) T(etlstd::forward<Args>(args)...);
write.store(next_index, etl::memory_order_release);
@ -469,7 +469,7 @@ namespace etl
private:
/// The uninitialised buffer of T used in the queue_spsc.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[RESERVED_SIZE];
typename etl::aligned_storage<sizeof(T), etlstd::alignment_of<T>::value>::type buffer[RESERVED_SIZE];
};
}

10
include/etl/queue_spsc_isr.h
View File

@ -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 <typename ... Args>
bool emplace_from_isr(Args&&... args)
{
return emplace_implementation(ETL_STD::forward<Args>(args)...);
return emplace_implementation(etlstd::forward<Args>(args)...);
}
#endif
@ -207,7 +207,7 @@ namespace etl
{
if (current_size != MAX_SIZE)
{
::new (&p_buffer[write_index]) T(ETL_STD::forward<Args>(args)...);
::new (&p_buffer[write_index]) T(etlstd::forward<Args>(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>(args)...);
bool result = this->emplace_implementation(etlstd::forward<Args>(args)...);
TAccess::unlock();
@ -676,7 +676,7 @@ namespace etl
queue_spsc_isr& operator = (const queue_spsc_isr&);
/// The uninitialised buffer of T used in the queue_spsc_isr.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[MAX_SIZE];
typename etl::aligned_storage<sizeof(T), etlstd::alignment_of<T>::value>::type buffer[MAX_SIZE];
};
}

10
include/etl/queue_spsc_locked.h
View File

@ -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 <typename ... Args>
bool emplace_from_unlocked(Args&&... args)
{
return emplace_implementation(ETL_STD::forward<Args>(args)...);
return emplace_implementation(etlstd::forward<Args>(args)...);
}
#endif
@ -208,7 +208,7 @@ namespace etl
{
if (current_size != MAX_SIZE)
{
::new (&p_buffer[write_index]) T(ETL_STD::forward<Args>(args)...);
::new (&p_buffer[write_index]) T(etlstd::forward<Args>(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>(args)...);
bool result = this->emplace_implementation(etlstd::forward<Args>(args)...);
unlock();
@ -677,7 +677,7 @@ namespace etl
queue_spsc_locked& operator = (const queue_spsc_locked&);
/// The uninitialised buffer of T used in the queue_spsc_locked.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[MAX_SIZE];
typename etl::aligned_storage<sizeof(T), etlstd::alignment_of<T>::value>::type buffer[MAX_SIZE];
};
}

38
include/etl/reference_flat_map.h
View File

@ -103,7 +103,7 @@ namespace etl
/// Can be used as a reference type for all reference_flat_maps containing a specific type.
///\ingroup reference_flat_map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TMapped, typename TKeyCompare = etlstd::less<TKey> >
class ireference_flat_map
{
public:
@ -126,7 +126,7 @@ namespace etl
typedef size_t size_type;
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -224,7 +224,7 @@ namespace etl
};
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -317,9 +317,9 @@ namespace etl
typename lookup_t::const_iterator ilookup;
};
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -525,10 +525,10 @@ namespace etl
template <typename TIterator>
void assign(TIterator first, TIterator last)
{
ETL_STATIC_ASSERT((etl::is_same<value_type, typename ETL_STD::iterator_traits<TIterator>::value_type>::value), "Incompatible data for assign");
ETL_STATIC_ASSERT((etlstd::is_same<value_type, typename etlstd::iterator_traits<TIterator>::value_type>::value), "Incompatible data for assign");
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_map_full));
#endif
@ -693,7 +693,7 @@ namespace etl
//*********************************************************************
iterator lower_bound(key_parameter_t key)
{
return ETL_STD::lower_bound(begin(), end(), key, compare);
return etlstd::lower_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -703,7 +703,7 @@ namespace etl
//*********************************************************************
const_iterator lower_bound(key_parameter_t key) const
{
return ETL_STD::lower_bound(cbegin(), cend(), key, compare);
return etlstd::lower_bound(cbegin(), cend(), key, compare);
}
//*********************************************************************
@ -713,7 +713,7 @@ namespace etl
//*********************************************************************
iterator upper_bound(key_parameter_t key)
{
return ETL_STD::upper_bound(begin(), end(), key, compare);
return etlstd::upper_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -723,7 +723,7 @@ namespace etl
//*********************************************************************
const_iterator upper_bound(key_parameter_t key) const
{
return ETL_STD::upper_bound(begin(), end(), key, compare);
return etlstd::upper_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -733,9 +733,9 @@ namespace etl
//*********************************************************************
ETL_PAIR<iterator, iterator> equal_range(key_parameter_t key)
{
iterator i_lower = ETL_STD::lower_bound(begin(), end(), key, compare);
iterator i_lower = etlstd::lower_bound(begin(), end(), key, compare);
return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, end(), key, compare));
return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, end(), key, compare));
}
//*********************************************************************
@ -745,9 +745,9 @@ namespace etl
//*********************************************************************
ETL_PAIR<const_iterator, const_iterator> equal_range(key_parameter_t key) const
{
const_iterator i_lower = ETL_STD::lower_bound(cbegin(), cend(), key, compare);
const_iterator i_lower = etlstd::lower_bound(cbegin(), cend(), key, compare);
return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, cend(), key, compare));
return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, cend(), key, compare));
}
//*************************************************************************
@ -886,7 +886,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator ==(const etl::ireference_flat_map<TKey, TMapped, TKeyCompare>& lhs, const etl::ireference_flat_map<TKey, TMapped, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -906,11 +906,11 @@ namespace etl
/// A reference_flat_map implementation that uses a fixed size buffer.
///\tparam TKey The key type.
///\tparam TValue The value type.
///\tparam TCompare The type to compare keys. Default = ETL_STD::less<TKey>
///\tparam TCompare The type to compare keys. Default = etlstd::less<TKey>
///\tparam MAX_SIZE_ The maximum number of elements that can be stored.
///\ingroup reference_flat_map
//***************************************************************************
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = etlstd::less<TKey> >
class reference_flat_map : public ireference_flat_map<TKey, TValue, TCompare>
{
public:

40
include/etl/reference_flat_multimap.h
View File

@ -78,7 +78,7 @@ namespace etl
/// Can be used as a reference type for all reference_flat_multimaps containing a specific type.
///\ingroup reference_flat_multimap
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TMapped, typename TKeyCompare = etlstd::less<TKey> >
class ireference_flat_multimap
{
public:
@ -101,7 +101,7 @@ namespace etl
typedef size_t size_type;
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -199,7 +199,7 @@ namespace etl
};
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -292,9 +292,9 @@ namespace etl
typename lookup_t::const_iterator ilookup;
};
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
protected:
@ -443,7 +443,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multimap_full));
#endif
@ -513,7 +513,7 @@ namespace etl
}
else
{
size_t d = ETL_STD::distance(range.first, range.second);
size_t d = etlstd::distance(range.first, range.second);
erase(range.first, range.second);
return d;
}
@ -605,7 +605,7 @@ namespace etl
{
ETL_PAIR<const_iterator, const_iterator> range = equal_range(key);
return ETL_STD::distance(range.first, range.second);
return etlstd::distance(range.first, range.second);
}
//*********************************************************************
@ -615,7 +615,7 @@ namespace etl
//*********************************************************************
iterator lower_bound(key_parameter_t key)
{
return ETL_STD::lower_bound(begin(), end(), key, compare);
return etlstd::lower_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -625,7 +625,7 @@ namespace etl
//*********************************************************************
const_iterator lower_bound(key_parameter_t key) const
{
return ETL_STD::lower_bound(cbegin(), cend(), key, compare);
return etlstd::lower_bound(cbegin(), cend(), key, compare);
}
//*********************************************************************
@ -635,7 +635,7 @@ namespace etl
//*********************************************************************
iterator upper_bound(key_parameter_t key)
{
return ETL_STD::upper_bound(begin(), end(), key, compare);
return etlstd::upper_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -645,7 +645,7 @@ namespace etl
//*********************************************************************
const_iterator upper_bound(key_parameter_t key) const
{
return ETL_STD::upper_bound(begin(), end(), key, compare);
return etlstd::upper_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -655,9 +655,9 @@ namespace etl
//*********************************************************************
ETL_PAIR<iterator, iterator> equal_range(key_parameter_t key)
{
iterator i_lower = ETL_STD::lower_bound(begin(), end(), key, compare);
iterator i_lower = etlstd::lower_bound(begin(), end(), key, compare);
return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, end(), key, compare));
return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, end(), key, compare));
}
//*********************************************************************
@ -667,9 +667,9 @@ namespace etl
//*********************************************************************
ETL_PAIR<const_iterator, const_iterator> equal_range(key_parameter_t key) const
{
const_iterator i_lower = ETL_STD::lower_bound(cbegin(), cend(), key, compare);
const_iterator i_lower = etlstd::lower_bound(cbegin(), cend(), key, compare);
return ETL_MAKE_PAIR(i_lower, ETL_STD::upper_bound(i_lower, cend(), key, compare));
return ETL_MAKE_PAIR(i_lower, etlstd::upper_bound(i_lower, cend(), key, compare));
}
//*************************************************************************
@ -799,7 +799,7 @@ namespace etl
template <typename TKey, typename TMapped, typename TKeyCompare>
bool operator ==(const etl::ireference_flat_multimap<TKey, TMapped, TKeyCompare>& lhs, const etl::ireference_flat_multimap<TKey, TMapped, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -819,11 +819,11 @@ namespace etl
/// A reference_flat_multimap implementation that uses a fixed size buffer.
///\tparam TKey The key type.
///\tparam TValue The value type.
///\tparam TCompare The type to compare keys. Default = ETL_STD::less<TKey>
///\tparam TCompare The type to compare keys. Default = etlstd::less<TKey>
///\tparam MAX_SIZE_ The maximum number of elements that can be stored.
///\ingroup reference_flat_multimap
//***************************************************************************
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<TKey> >
template <typename TKey, typename TValue, const size_t MAX_SIZE_, typename TCompare = etlstd::less<TKey> >
class reference_flat_multimap : public ireference_flat_multimap<TKey, TValue, TCompare>
{
public:

48
include/etl/reference_flat_multiset.h
View File

@ -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 <typename T, typename TKeyCompare = ETL_STD::less<T> >
template <typename T, typename TKeyCompare = etlstd::less<T> >
class ireference_flat_multiset
{
public:
@ -119,7 +119,7 @@ namespace etl
public:
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -217,7 +217,7 @@ namespace etl
};
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -316,9 +316,9 @@ namespace etl
public:
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
//*********************************************************************
/// Returns an iterator to the beginning of the reference_flat_multiset.
@ -439,7 +439,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_multiset_full));
#endif
@ -462,7 +462,7 @@ namespace etl
ETL_ASSERT(!lookup.full(), ETL_ERROR(flat_multiset_full));
iterator i_element = ETL_STD::lower_bound(begin(), end(), value, compare);
iterator i_element = etlstd::lower_bound(begin(), end(), value, compare);
if (i_element == end())
{
@ -524,7 +524,7 @@ namespace etl
}
else
{
size_t d = ETL_STD::distance(range.first, range.second);
size_t d = etlstd::distance(range.first, range.second);
erase(range.first, range.second);
return d;
}
@ -566,7 +566,7 @@ namespace etl
//*********************************************************************
iterator find(parameter_t key)
{
iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare);
iterator itr = etlstd::lower_bound(begin(), end(), key, compare);
if (itr != end())
{
@ -590,7 +590,7 @@ namespace etl
//*********************************************************************
const_iterator find(parameter_t key) const
{
const_iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare);
const_iterator itr = etlstd::lower_bound(begin(), end(), key, compare);
if (itr != end())
{
@ -616,7 +616,7 @@ namespace etl
{
ETL_PAIR<const_iterator, const_iterator> range = equal_range(key);
return ETL_STD::distance(range.first, range.second);
return etlstd::distance(range.first, range.second);
}
//*********************************************************************
@ -626,7 +626,7 @@ namespace etl
//*********************************************************************
iterator lower_bound(parameter_t key)
{
return ETL_STD::lower_bound(begin(), end(), key, compare);
return etlstd::lower_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -636,7 +636,7 @@ namespace etl
//*********************************************************************
const_iterator lower_bound(parameter_t key) const
{
return ETL_STD::lower_bound(cbegin(), cend(), key, compare);
return etlstd::lower_bound(cbegin(), cend(), key, compare);
}
//*********************************************************************
@ -646,7 +646,7 @@ namespace etl
//*********************************************************************
iterator upper_bound(parameter_t key)
{
return ETL_STD::upper_bound(begin(), end(), key, compare);
return etlstd::upper_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -656,7 +656,7 @@ namespace etl
//*********************************************************************
const_iterator upper_bound(parameter_t key) const
{
return ETL_STD::upper_bound(cbegin(), cend(), key, compare);
return etlstd::upper_bound(cbegin(), cend(), key, compare);
}
//*********************************************************************
@ -666,7 +666,7 @@ namespace etl
//*********************************************************************
ETL_PAIR<iterator, iterator> equal_range(parameter_t key)
{
return ETL_STD::equal_range(begin(), end(), key, compare);
return etlstd::equal_range(begin(), end(), key, compare);
}
//*********************************************************************
@ -676,7 +676,7 @@ namespace etl
//*********************************************************************
ETL_PAIR<const_iterator, const_iterator> equal_range(parameter_t key) const
{
return ETL_STD::equal_range(begin(), end(), key, compare);
return etlstd::equal_range(begin(), end(), key, compare);
}
//*************************************************************************
@ -805,7 +805,7 @@ namespace etl
/// An reference flat set
///\ingroup reference_flat_multiset
//***************************************************************************
template <typename TKey, const size_t MAX_SIZE_, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, const size_t MAX_SIZE_, typename TKeyCompare = etlstd::less<TKey> >
class reference_flat_multiset : public ireference_flat_multiset<TKey, TKeyCompare>
{
public:
@ -868,7 +868,7 @@ namespace etl
template <typename T, typename TKeyCompare>
bool operator ==(const etl::ireference_flat_multiset<T, TKeyCompare>& lhs, const etl::ireference_flat_multiset<T, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************

42
include/etl/reference_flat_set.h
View File

@ -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 <typename T, typename TKeyCompare = ETL_STD::less<T> >
template <typename T, typename TKeyCompare = etlstd::less<T> >
class ireference_flat_set
{
public:
@ -120,7 +120,7 @@ namespace etl
public:
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -218,7 +218,7 @@ namespace etl
};
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -317,9 +317,9 @@ namespace etl
public:
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
//*********************************************************************
/// Returns an iterator to the beginning of the reference_flat_set.
@ -440,7 +440,7 @@ namespace etl
void assign(TIterator first, TIterator last)
{
#if defined(ETL_DEBUG)
difference_type d = ETL_STD::distance(first, last);
difference_type d = etlstd::distance(first, last);
ETL_ASSERT(d <= difference_type(capacity()), ETL_ERROR(flat_set_full));
#endif
@ -547,7 +547,7 @@ namespace etl
//*********************************************************************
iterator find(parameter_t key)
{
iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare);
iterator itr = etlstd::lower_bound(begin(), end(), key, compare);
if (itr != end())
{
@ -571,7 +571,7 @@ namespace etl
//*********************************************************************
const_iterator find(parameter_t key) const
{
const_iterator itr = ETL_STD::lower_bound(begin(), end(), key, compare);
const_iterator itr = etlstd::lower_bound(begin(), end(), key, compare);
if (itr != end())
{
@ -605,7 +605,7 @@ namespace etl
//*********************************************************************
iterator lower_bound(parameter_t key)
{
return ETL_STD::lower_bound(begin(), end(), key, compare);
return etlstd::lower_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -615,7 +615,7 @@ namespace etl
//*********************************************************************
const_iterator lower_bound(parameter_t key) const
{
return ETL_STD::lower_bound(cbegin(), cend(), key, compare);
return etlstd::lower_bound(cbegin(), cend(), key, compare);
}
//*********************************************************************
@ -625,7 +625,7 @@ namespace etl
//*********************************************************************
iterator upper_bound(parameter_t key)
{
return ETL_STD::upper_bound(begin(), end(), key, compare);
return etlstd::upper_bound(begin(), end(), key, compare);
}
//*********************************************************************
@ -635,7 +635,7 @@ namespace etl
//*********************************************************************
const_iterator upper_bound(parameter_t key) const
{
return ETL_STD::upper_bound(cbegin(), cend(), key, compare);
return etlstd::upper_bound(cbegin(), cend(), key, compare);
}
//*********************************************************************
@ -645,7 +645,7 @@ namespace etl
//*********************************************************************
ETL_PAIR<iterator, iterator> equal_range(parameter_t key)
{
return ETL_STD::equal_range(begin(), end(), key, compare);
return etlstd::equal_range(begin(), end(), key, compare);
}
//*********************************************************************
@ -655,7 +655,7 @@ namespace etl
//*********************************************************************
ETL_PAIR<const_iterator, const_iterator> equal_range(parameter_t key) const
{
return ETL_STD::upper_bound(cbegin(), cend(), key, compare);
return etlstd::upper_bound(cbegin(), cend(), key, compare);
}
//*************************************************************************
@ -788,7 +788,7 @@ namespace etl
/// An reference flat set
///\ingroup reference_flat_set
//***************************************************************************
template <typename TKey, const size_t MAX_SIZE_, typename TKeyCompare = ETL_STD::less<TKey> >
template <typename TKey, const size_t MAX_SIZE_, typename TKeyCompare = etlstd::less<TKey> >
class reference_flat_set : public ireference_flat_set<TKey, TKeyCompare>
{
public:
@ -851,7 +851,7 @@ namespace etl
template <typename T, typename TKeyCompare>
bool operator ==(const etl::ireference_flat_set<T, TKeyCompare>& lhs, const etl::ireference_flat_set<T, TKeyCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************

18
include/etl/scaled_rounding.h
View File

@ -41,7 +41,7 @@ namespace etl
template <typename T>
struct scaled_rounding_t
{
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type type;
typedef typename etlstd::conditional<etlstd::is_signed<T>::value, int32_t, uint32_t>::type type;
};
//*****************************************************************************
@ -67,7 +67,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_ceiling_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
typedef typename scaled_rounding_t<T>::type scale_t;
if (value >= 0)
@ -101,7 +101,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_floor_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
typedef typename scaled_rounding_t<T>::type scale_t;
if (value >= 0)
@ -136,7 +136,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_half_up_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT((((SCALING / 2U) * 2U) == SCALING), "Scaling must be divisible by 2");
typedef typename scaled_rounding_t<T>::type scale_t;
@ -173,7 +173,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_half_down_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT((((SCALING / 2U) * 2U) == SCALING), "Scaling must be divisible by 2");
typedef typename scaled_rounding_t<T>::type scale_t;
@ -209,7 +209,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_zero_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
typedef typename scaled_rounding_t<T>::type scale_t;
return T(value / scale_t(SCALING));
@ -236,7 +236,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_infinity_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
typedef typename scaled_rounding_t<T>::type scale_t;
if (value >= 0)
@ -271,7 +271,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_half_even_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
typedef typename scaled_rounding_t<T>::type scale_t;
// Half?
@ -316,7 +316,7 @@ namespace etl
template <const size_t SCALING, typename T>
T round_half_odd_unscaled(T value)
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Type must be an integral");
ETL_STATIC_ASSERT(etlstd::is_integral<T>::value, "Type must be an integral");
typedef typename scaled_rounding_t<T>::type scale_t;
// Half?

8
include/etl/scheduler.h
View File

@ -285,10 +285,10 @@ namespace etl
if (!task_list.full())
{
typename task_list_t::iterator itask = ETL_STD::upper_bound(task_list.begin(),
task_list.end(),
task.get_task_priority(),
compare_priority());
typename task_list_t::iterator itask = etlstd::upper_bound(task_list.begin(),
task_list.end(),
task.get_task_priority(),
compare_priority());
task_list.insert(itask, &task);
}

27
include/etl/set.h
View File

@ -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 <initializer_list>
@ -457,7 +457,7 @@ namespace etl
/// A templated base for all etl::set types.
///\ingroup set
//***************************************************************************
template <typename T, typename TCompare = ETL_STD::less<T> >
template <typename T, typename TCompare = etlstd::less<T> >
class iset : public etl::set_base
{
public:
@ -549,7 +549,7 @@ namespace etl
//*************************************************************************
/// iterator.
//*************************************************************************
class iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, value_type>
class iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, value_type>
{
public:
@ -654,7 +654,7 @@ namespace etl
//*************************************************************************
/// const_iterator
//*************************************************************************
class const_iterator : public etl::iterator<ETL_BIDIRECTIONAL_ITERATOR_TAG, const value_type>
class const_iterator : public etl::iterator<ETL_OR_STD::bidirectional_iterator_tag, const value_type>
{
public:
@ -761,10 +761,10 @@ namespace etl
};
friend class const_iterator;
typedef typename ETL_STD::iterator_traits<iterator>::difference_type difference_type;
typedef typename etlstd::iterator_traits<iterator>::difference_type difference_type;
typedef ETL_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Assignment operator.
@ -1950,7 +1950,7 @@ namespace etl
//*************************************************************************
/// A templated set implementation that uses a fixed size buffer.
//*************************************************************************
template <typename T, const size_t MAX_SIZE_, typename TCompare = ETL_STD::less<T> >
template <typename T, const size_t MAX_SIZE_, typename TCompare = etlstd::less<T> >
class set : public etl::iset<T, TCompare>
{
public:
@ -2037,7 +2037,7 @@ namespace etl
template <typename T, typename TCompare>
bool operator ==(const etl::iset<T, TCompare>& lhs, const etl::iset<T, TCompare>& rhs)
{
return (lhs.size() == rhs.size()) && ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
return (lhs.size() == rhs.size()) && etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
@ -2063,10 +2063,7 @@ namespace etl
template <typename T, typename TCompare>
bool operator <(const etl::iset<T, TCompare>& lhs, const etl::iset<T, TCompare>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(),
lhs.end(),
rhs.begin(),
rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

12
include/etl/smallest.h
View File

@ -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<T1>() < etl::size_of<smallest_other>()), // Boolean
T1, // TrueType
smallest_other> // FalseType
::type; // The smallest type of the two.
using type = typename etlstd::conditional<(etl::size_of<T1>::value < etl::size_of<smallest_other>::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<type>()
size = etl::size_of<type>::value
};
};
@ -106,7 +106,7 @@ namespace etl
enum
{
size = etl::size_of<type>()
size = etl::size_of<type>::value
};
};
#else

12
include/etl/smallest_generator.h
View File

@ -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<T1>() < etl::size_of<smallest_other>()), // Boolean
T1, // TrueType
smallest_other> // FalseType
::type; // The smallest type of the two.
using type = typename etlstd::conditional<(etl::size_of<T1>::value < etl::size_of<smallest_other>::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<type>()
size = etl::size_of<type>::value
};
};
@ -118,7 +118,7 @@ namespace etl
enum
{
size = etl::size_of<type>()
size = etl::size_of<type>::value
};
};
#else

2
include/etl/sqrt.h
View File

@ -45,7 +45,7 @@ namespace etl
template <const size_t VALUE, const size_t I = 1>
struct sqrt
{
typedef typename etl::conditional<((I * I) > VALUE),
typedef typename etlstd::conditional<((I * I) > VALUE),
etl::constant<intmax_t, I - 1>,
etl::sqrt<VALUE, I + 1> >::type type;

8
include/etl/stack.h
View File

@ -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>(args)...);
::new (&p_buffer[top_index]) T(etlstd::forward<Args>(args)...);
}
#else
//*************************************************************************
@ -408,7 +408,7 @@ namespace etl
//*************************************************************************
void reverse()
{
ETL_STD::reverse(p_buffer, p_buffer + current_size);
etlstd::reverse(p_buffer, p_buffer + current_size);
}
//*************************************************************************
@ -527,7 +527,7 @@ namespace etl
private:
/// The unintitialised buffer of T used in the stack.
typename etl::aligned_storage<sizeof(T), etl::alignment_of<T>::value>::type buffer[SIZE];
typename etl::aligned_storage<sizeof(T), etlstd::alignment_of<T>::value>::type buffer[SIZE];
};
}

12
include/etl/state_chart.h
View File

@ -235,9 +235,9 @@ namespace etl
}
else
{
return ETL_STD::find_if(state_table.begin(),
state_table.end(),
is_state(state_id));
return etlstd::find_if(state_table.begin(),
state_table.end(),
is_state(state_id));
}
}
@ -280,9 +280,9 @@ namespace etl
while (t != transition_table.end())
{
// Scan the transition table from the latest position.
t = ETL_STD::find_if(t,
transition_table.end(),
is_transition(event_id, current_state_id));
t = etlstd::find_if(t,
transition_table.end(),
is_transition(event_id, current_state_id));
// Found an entry?
if (t != transition_table.end())

46
include/etl/stl/algorithm.h
View File

@ -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 <algorithm>
#endif
#endif

870
include/etl/stl/alternate/algorithm.h
View File

@ -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 <string.h>
#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 <typename T>
void swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
//***************************************************************************
// iter_swap
template <typename TIterator1, typename TIterator2>
void iter_swap(TIterator1 a, TIterator2 b)
{
typename etlstd::iterator_traits<TIterator1>::value_type c = *a;
*a = *b;
*b = c;
}
//***************************************************************************
// swap_ranges
template <typename T1terator1, typename TIterator2>
TIterator2 swap_ranges(T1terator1 first1,
T1terator1 last1,
TIterator2 first2)
{
while (first1 != last1)
{
iter_swap(first1++, first2++);
}
return first2;
}
//***************************************************************************
// advance
template <typename TIterator, typename TDistance>
typename etl::enable_if<!etl::is_same<typename etlstd::iterator_traits<TIterator>::iterator_tag, etlstd::random_access_iterator_tag>::value, void>::type
advance(TIterator itr, TDistance distance)
{
while (distance-- != 0)
{
++itr;
}
}
template <typename TIterator, typename TDistance>
typename etl::enable_if<etl::is_same<typename etlstd::iterator_traits<TIterator>::iterator_tag, etlstd::random_access_iterator_tag>::value, void>::type
advance(TIterator itr, TDistance distance)
{
return itr += distance;
}
//***************************************************************************
// copy
// Pointer
template <typename TIterator1, typename TIterator2>
typename etl::enable_if<etl::is_pointer<TIterator1>::value &&
etl::is_pointer<TIterator2>::value &&
etl::is_pod<typename etlstd::iterator_traits<TIterator1>::value_type>::value, TIterator2>::type
copy(TIterator1 sb, TIterator1 se, TIterator2 db)
{
typedef typename etlstd::iterator_traits<TIterator1>::value_type value_t;
typedef typename etlstd::iterator_traits<TIterator1>::difference_type difference_t;
difference_t count = (se - sb);
return TIterator2(memmove(db, sb, sizeof(value_t) * count)) + count;
}
// Other iterator
template <typename TIterator1, typename TIterator2>
typename etl::enable_if<!etl::is_pointer<TIterator1>::value ||
!etl::is_pointer<TIterator2>::value ||
!etl::is_pod<typename etlstd::iterator_traits<TIterator1>::value_type>::value, TIterator2>::type
copy(TIterator1 sb, TIterator1 se, TIterator2 db)
{
while (sb != se)
{
*db++ = *sb++;
}
return db;
}
//***************************************************************************
// reverse_copy
template <typename TIterator1, typename TIterator2>
TIterator2 reverse_copy(TIterator1 sb, TIterator1 se, TIterator2 db)
{
while (sb != se)
{
*(db++) = *(--se);
}
return db;
}
//***************************************************************************
// copy_n
// Pointer
template <typename TIterator1, typename TSize, typename TIterator2>
typename etl::enable_if<etl::is_pointer<TIterator1>::value &&
etl::is_pointer<TIterator2>::value &&
etl::is_pod<typename etlstd::iterator_traits<TIterator1>::value_type>::value, TIterator2>::type
copy_n(TIterator1 sb, TSize count, TIterator2 db)
{
typedef typename etlstd::iterator_traits<TIterator1>::value_type value_t;
return TIterator2(memmove(db, sb, sizeof(value_t) * count)) + count;
}
// Other iterator
template <typename TIterator1, typename TSize, typename TIterator2>
typename etl::enable_if<!etl::is_pointer<TIterator1>::value ||
!etl::is_pointer<TIterator2>::value ||
!etl::is_pod<typename etlstd::iterator_traits<TIterator1>::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 TIterator1, typename TIterator2>
typename etl::enable_if<etl::is_pointer<TIterator1>::value &&
etl::is_pointer<TIterator2>::value &&
etl::is_pod<typename etlstd::iterator_traits<TIterator1>::value_type>::value, TIterator2>::type
copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
{
typedef typename etlstd::iterator_traits<TIterator1>::value_type value_t;
const size_t length = (se - sb);
return TIterator2(memmove(de - length, sb, sizeof(value_t) * length));
}
// Other iterator
template <typename TIterator1, typename TIterator2>
typename etl::enable_if<!etl::is_pointer<TIterator1>::value ||
!etl::is_pointer<TIterator2>::value ||
!etl::is_pod<typename etlstd::iterator_traits<TIterator1>::value_type>::value, TIterator2>::type
copy_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
{
while (se != sb)
{
*(--de) = *(--se);
}
return de;
}
//***************************************************************************
// move
template <typename TIterator1, typename TIterator2>
TIterator2 move(TIterator1 sb, TIterator1 se, TIterator2 db)
{
while (sb != se)
{
*db++ = etlstd::move(*sb++);
}
return db;
}
//***************************************************************************
// move_backward
template <typename TIterator1, typename TIterator2>
TIterator2 move_backward(TIterator1 sb, TIterator1 se, TIterator2 de)
{
while (sb != se)
{
*(--de) = etlstd::move(*(--se));
}
return de;
}
//***************************************************************************
// reverse
// Pointers
template <typename TIterator>
typename etl::enable_if<etl::is_pointer<TIterator>::value, void>::type
reverse(TIterator b, TIterator e)
{
if (b != e)
{
while (b < --e)
{
etlstd::iter_swap(b, e);
++b;
}
}
}
// Other
template <typename TIterator>
typename etl::enable_if<!etl::is_pointer<TIterator>::value, void>::type
reverse(TIterator b, TIterator e)
{
while ((b != e) && (b != --e))
{
etlstd::iter_swap(b++, e);
}
}
//***************************************************************************
// lower_bound
template<typename TIterator, typename TValue, typename TCompare>
TIterator lower_bound(TIterator first, TIterator last, const TValue& value, TCompare compare)
{
typedef typename etlstd::iterator_traits<TIterator>::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<typename TIterator, typename TValue>
TIterator lower_bound(TIterator first, TIterator last, const TValue& value)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator>::value_type> compare;
return etlstd::lower_bound(first, last, value, compare());
}
//***************************************************************************
// upper_bound
template<typename TIterator, typename TValue, typename TCompare>
TIterator upper_bound(TIterator first, TIterator last, const TValue& value, TCompare compare)
{
typedef typename etlstd::iterator_traits<TIterator>::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<typename TIterator, typename TValue>
TIterator upper_bound(TIterator first, TIterator last, const TValue& value)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator>::value_type> compare;
return etlstd::upper_bound(first, last, value, compare());
}
//***************************************************************************
// equal_range
template<typename TIterator, typename TValue, typename TCompare>
ETL_PAIR<TIterator, TIterator> 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<typename TIterator, typename TValue>
ETL_PAIR<TIterator, TIterator> equal_range(TIterator first, TIterator last, const TValue& value)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator>::value_type> compare;
return ETL_MAKE_PAIR(etlstd::lower_bound(first, last, value, compare()),
etlstd::upper_bound(first, last, value, compare()));
}
//***************************************************************************
// find_if
template <typename TIterator, typename TUnaryPredicate>
TIterator find_if(TIterator first, TIterator last, TUnaryPredicate predicate)
{
while (first != last)
{
if (predicate(*first))
{
return first;
}
++first;
}
return last;
}
//***************************************************************************
// find
template <typename TIterator, typename T>
TIterator find(TIterator first, TIterator last, const T& value)
{
while (first != last)
{
if (*first == value)
{
return first;
}
++first;
}
return last;
}
//***************************************************************************
// fill
template<typename TIterator, typename TValue>
typename etl::enable_if<!(etl::is_same<char, TValue>::value || etl::is_same<unsigned char, TValue>::value) || !etl::is_pointer<TIterator>::value, void>::type
fill(TIterator first, TIterator last, const TValue& value)
{
while (first != last)
{
*first++ = value;
}
}
template<typename TIterator, typename TValue>
typename etl::enable_if<(etl::is_same<char, TValue>::value || etl::is_same<unsigned char, TValue>::value) && etl::is_pointer<TIterator>::value, void>::type
fill(TIterator first, TIterator last, const TValue& value)
{
memset(first, value, last - first);
}
//***************************************************************************
// fill_n
template<typename TIterator, typename TSize, typename TValue>
typename etl::enable_if<!(etl::is_same<char, TValue>::value || etl::is_same<unsigned char, TValue>::value) || !etl::is_pointer<TIterator>::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 TIterator, typename TSize, typename TValue>
typename etl::enable_if<(etl::is_same<char, TValue>::value || etl::is_same<unsigned char, TValue>::value) && etl::is_pointer<TIterator>::value, void>::type
fill_n(TIterator first, TSize count, const TValue& value)
{
memset(first, value, count);
}
//***************************************************************************
// count
template <typename TIterator, typename T>
typename iterator_traits<TIterator>::difference_type count(TIterator first, TIterator last, const T& value)
{
typename iterator_traits<TIterator>::difference_type n = 0;
while (first != last)
{
if (*first == value)
{
++n;
}
++first;
}
return n;
}
//***************************************************************************
// count
template <typename TIterator, typename TUnaryPredicate>
typename iterator_traits<TIterator>::difference_type count_if(TIterator first, TIterator last, TUnaryPredicate predicate)
{
typename iterator_traits<TIterator>::difference_type n = 0;
while (first != last)
{
if (predicate(*first))
{
++n;
}
++first;
}
return n;
}
//***************************************************************************
// equal
template <typename TIterator1, typename TIterator2>
typename etl::enable_if<!etl::is_pointer<TIterator1>::value || !etl::is_pointer<TIterator2>::value || !etl::is_pod<typename etlstd::iterator_traits<TIterator1>::value_type>::value, bool>::type
equal(TIterator1 first1, TIterator1 last1, TIterator2 first2)
{
while (first1 != last1)
{
if (*first1++ != *first2++)
{
return false;
}
}
return true;
}
template <typename TIterator1, typename TIterator2>
typename etl::enable_if<etl::is_pointer<TIterator1>::value && etl::is_pointer<TIterator2>::value && etl::is_pod<typename etlstd::iterator_traits<TIterator1>::value_type>::value, bool>::type
equal(TIterator1 first1, TIterator1 last1, TIterator2 first2)
{
typedef typename etlstd::iterator_traits<TIterator1>::value_type value_t;
return (memcmp(first1, first2, sizeof(value_t) * (last1 - first1)) == 0);
}
//***************************************************************************
// lexicographical_compare
template <typename TIterator1, typename TIterator2, typename TCompare>
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 <typename TIterator1, typename TIterator2>
bool lexicographical_compare(TIterator1 first1, TIterator1 last1,
TIterator2 first2, TIterator2 last2)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator1>::value_type> compare;
return etlstd::lexicographical_compare(first1, last1, first2, last2, compare());
}
//***************************************************************************
// min
template <typename T, typename TCompare>
const T& min(const T& a, const T& b, TCompare compare)
{
return (compare(a, b)) ? a : b;
}
template <typename T>
const T& min(const T& a, const T& b)
{
typedef etlstd::less<T> compare;
return etlstd::min(a, b, compare());
}
//***************************************************************************
// max
template <typename T, typename TCompare>
const T& max(const T& a, const T& b, TCompare compare)
{
return (compare(a, b)) ? b : a;
}
template <typename T>
const T& max(const T& a, const T& b)
{
typedef etlstd::less<T> compare;
return etlstd::max(a, b, compare());
}
//***************************************************************************
// transform
template <typename TIteratorIn, typename TIteratorOut, typename TUnaryOperation>
TIteratorOut transform(TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation)
{
while (first1 != last1)
{
*d_first++ = unary_operation(*first1++);
}
return d_first;
}
template <typename TIteratorIn1, typename TIteratorIn2, typename TIteratorOut, typename TBinaryOperation>
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 <typename TIterator, typename TDistance, typename TValue, typename TCompare>
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 <typename TIterator, typename TDistance, typename TValue, typename TCompare>
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 <typename TIterator, typename TDistance, typename TCompare>
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 <typename TIterator, typename TCompare>
void pop_heap(TIterator first, TIterator last, TCompare compare)
{
typedef typename etlstd::iterator_traits<TIterator>::value_type value_t;
typedef typename etlstd::iterator_traits<TIterator>::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 <typename TIterator>
void pop_heap(TIterator first, TIterator last)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator>::value_type> compare;
etlstd::pop_heap(first, last, compare());
}
// Push Heap
template <typename TIterator, typename TCompare>
void push_heap(TIterator first, TIterator last, TCompare compare)
{
typedef typename etlstd::iterator_traits<TIterator>::difference_type difference_t;
typedef typename etlstd::iterator_traits<TIterator>::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 <typename TIterator>
void push_heap(TIterator first, TIterator last)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator>::value_type> compare;
etlstd::push_heap(first, last, compare());
}
// Make Heap
template <typename TIterator, typename TCompare>
void make_heap(TIterator first, TIterator last, TCompare compare)
{
typedef typename etlstd::iterator_traits<TIterator>::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 <typename TIterator>
void make_heap(TIterator first, TIterator last)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator>::value_type> compare;
etlstd::make_heap(first, last, compare());
}
// Is Heap
template <typename TIterator>
bool is_heap(TIterator first, TIterator last)
{
typedef etlstd::less<typename etlstd::iterator_traits<TIterator>::value_type> compare;
return private_heap::is_heap(first, last - first, compare());
}
// Is Heap
template <typename TIterator, typename TCompare>
bool is_heap(TIterator first, TIterator last, TCompare compare)
{
return private_heap::is_heap(first, last - first, compare);
}
//***************************************************************************
// Search
template<typename TIterator1, typename TIterator2, typename TCompare>
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<typename TIterator1, class TIterator2>
TIterator1 search(TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last)
{
typedef etlstd::equal_to<typename etlstd::iterator_traits<TIterator1>::value_type> compare;
return etlstd::search(first, last, search_first, search_last, compare());
}
//***************************************************************************
// Rotate
template<typename TIterator>
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 <typename TIterator1, typename TIterator2, typename TPredicate>
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 <typename TIterator1, typename TIterator2>
TIterator1 find_end(TIterator1 b, TIterator1 e,
TIterator2 sb, TIterator2 se)
{
typedef etlstd::equal_to<typename etlstd::iterator_traits<TIterator1>::value_type> predicate;
return find_end(b, e, sb, se, predicate());
}
}
#endif

137
include/etl/stl/alternate/functional.h
View File

@ -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 <typename T = void>
struct less
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs < rhs;
}
};
//***************************************************************************
template <typename T = void>
struct greater
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs > rhs;
}
};
//***************************************************************************
template <typename T = void>
struct equal_to
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs == rhs;
}
};
//***************************************************************************
template <typename T = void>
struct not_equal_to
{
ETL_CONSTEXPR bool operator()(const T &lhs, const T &rhs) const
{
return lhs != rhs;
}
};
//***************************************************************************
template <typename TArgumentType, typename TResultType>
struct unary_function
{
typedef TArgumentType argument_type;
typedef TResultType result_type;
};
//***************************************************************************
template <typename TFirstArgumentType, typename TSecondArgumentType, typename TResultType>
struct binary_function
{
typedef TFirstArgumentType first_argument_type;
typedef TSecondArgumentType second_argument_type;
typedef TResultType result_type;
};
//***************************************************************************
template <typename TFunction>
class binder1st : public etlstd::unary_function<typename TFunction::second_argument_type, typename TFunction::result_type>
{
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 <typename F, typename T>
binder1st<F> bind1st(const F& f, const T& x)
{
return binder1st<F>(f, x);
}
//***************************************************************************
template <typename TFunction >
class binder2nd : public etlstd::unary_function<typename TFunction::first_argument_type, typename TFunction::result_type>
{
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 <typename F, typename T>
binder2nd<F> bind2nd(const F& f, const T& x)
{
return binder2nd<F>(f, x);
}
}
#endif

394
include/etl/stl/alternate/iterator.h
View File

@ -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 <string.h>
#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 <typename TIterator>
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 <typename T>
struct iterator_traits<T*>
{
typedef ETL_RANDOM_ACCESS_ITERATOR_TAG iterator_category;
typedef T value_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef T& reference;
};
template <typename T>
struct iterator_traits<const T*>
{
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 <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_INPUT_ITERATOR_TAG)
{
while (n--)
{
++itr;
}
}
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_OUTPUT_ITERATOR_TAG)
{
while (n--)
{
++itr;
}
}
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_FORWARD_ITERATOR_TAG)
{
while (n--)
{
++itr;
}
}
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_BIDIRECTIONAL_ITERATOR_TAG)
{
if (n > 0)
{
while (n--)
{
++itr;
}
}
else
{
while (n++)
{
--itr;
}
}
}
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance_helper(TIterator& itr, TDistance n, ETL_RANDOM_ACCESS_ITERATOR_TAG)
{
itr += n;
}
template <typename TIterator, typename TDistance>
ETL_CONSTEXPR17 void advance(TIterator& itr, TDistance n)
{
typedef typename etlstd::iterator_traits<TIterator>::iterator_category tag;
advance_helper(itr, n, tag());
}
//***************************************************************************
// distance
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_INPUT_ITERATOR_TAG)
{
typename etlstd::iterator_traits<TIterator>::difference_type d = 0;
while (first != last)
{
++d;
++first;
}
return d;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_FORWARD_ITERATOR_TAG)
{
typename etlstd::iterator_traits<TIterator>::difference_type d = 0;
while (first != last)
{
++d;
++first;
}
return d;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_BIDIRECTIONAL_ITERATOR_TAG)
{
typename etlstd::iterator_traits<TIterator>::difference_type d = 0;
while (first != last)
{
++d;
++first;
}
return d;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance_helper(TIterator first, TIterator last, ETL_RANDOM_ACCESS_ITERATOR_TAG)
{
return last - first;
}
template<typename TIterator>
ETL_CONSTEXPR17 typename etlstd::iterator_traits<TIterator>::difference_type distance(TIterator first, TIterator last)
{
typedef typename etlstd::iterator_traits<TIterator>::iterator_category tag;
return distance_helper(first, last, tag());
}
//***************************************************************************
// reverse_iterator
template <typename TIterator>
class reverse_iterator
{
public:
typedef typename iterator_traits<TIterator>::iterator_category iterator_category;
typedef typename iterator_traits<TIterator>::value_type value_type;
typedef typename iterator_traits<TIterator>::difference_type difference_type;
typedef typename iterator_traits<TIterator>::pointer pointer;
typedef typename iterator_traits<TIterator>::reference reference;
typedef TIterator iterator_type;
ETL_CONSTEXPR17 reverse_iterator()
: current()
{
}
ETL_CONSTEXPR17 explicit reverse_iterator(TIterator itr)
: current(itr)
{
}
template <typename TOther>
ETL_CONSTEXPR17 reverse_iterator(const reverse_iterator<TOther>& other)
: current(other.base())
{
}
template<class TOther>
ETL_CONSTEXPR17 reverse_iterator& operator=(const reverse_iterator<TOther>& 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 <class TIterator>
inline ETL_CONSTEXPR17 bool operator ==(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return lhs.base() == rhs.base();
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator !=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return !(lhs == rhs);
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator <(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return rhs.base() < lhs.base();
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator >(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return rhs < lhs;
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator <=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return !(rhs < lhs);
}
template <class TIterator>
inline ETL_CONSTEXPR17 bool operator >=(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return !(lhs < rhs);
}
template <class TIterator>
inline ETL_CONSTEXPR17 typename reverse_iterator<TIterator>::difference_type operator -(const reverse_iterator<TIterator>& lhs, const reverse_iterator<TIterator>& rhs)
{
return rhs.base() - lhs.base();
}
template <class TIterator, class TDifference>
inline ETL_CONSTEXPR17 reverse_iterator<TIterator> operator +(TDifference n, const reverse_iterator<TIterator>& itr)
{
return itr.operator +(n);
}
//***************************************************************************
// Previous
template<typename TIterator>
ETL_CONSTEXPR17 TIterator prev(TIterator itr, typename etlstd::iterator_traits<TIterator>::difference_type n = 1)
{
etlstd::advance(itr, -n);
return itr;
}
//***************************************************************************
// Next
template<typename TIterator>
ETL_CONSTEXPR17 TIterator next(TIterator itr, typename etlstd::iterator_traits<TIterator>::difference_type n = 1)
{
etlstd::advance(itr, n);
return itr;
}
}
#endif

163
include/etl/stl/alternate/utility.h
View File

@ -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 <typename T1, typename T2>
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 <typename U1, typename U2>
pair(const pair<U1, U2>& other)
: first(other.first),
second(other.second)
{
}
pair(const pair<T1, T2>& other)
: first(other.first),
second(other.second)
{
}
void swap(pair<T1, T2>& other)
{
T1 temp1 = first;
T2 temp2 = second;
first = other.first;
second = other.second;
other.first = temp1;
other.second = temp2;
}
};
//******************************************************************************
template <typename T1, typename T2>
inline pair<T1, T2> make_pair(T1 a, T2 b)
{
return pair<T1, T2>(a, b);
}
//******************************************************************************
template <typename T1, typename T2>
inline void swap(pair<T1, T2>& a, pair<T1, T2>& b)
{
a.swap(b);
}
//******************************************************************************
template <typename T1, typename T2>
inline bool operator ==(const pair<T1, T2>& a, const pair<T1, T2>& b)
{
return (a.first == b.first) && (a.second == b.second);
}
template <typename T1, typename T2>
inline bool operator !=(const pair<T1, T2>& a, const pair<T1, T2>& b)
{
return !(a == b);
}
template <typename T1, typename T2>
inline bool operator <(const pair<T1, T2>& a, const pair<T1, T2>& b)
{
return (a.first < b.first) ||
(!(b.first < a.first) && (a.second < b.second));
}
template <typename T1, typename T2>
inline bool operator >(const pair<T1, T2>& a, const pair<T1, T2>& b)
{
return (b < a);
}
template <typename T1, typename T2>
inline bool operator <=(const pair<T1, T2>& a, const pair<T1, T2>& b)
{
return !(b < a);
}
template <typename T1, typename T2>
inline bool operator >=(const pair<T1, T2>& a, const pair<T1, T2>& b)
{
return !(a < b);
}
#if ETL_CPP11_SUPPORTED
//******************************************************************************
template <typename T>
constexpr typename etl::remove_reference<T>::type&& move(T&& t) noexcept
{
return static_cast<typename etl::remove_reference<T>::type&&>(t);
}
//******************************************************************************
template <typename T>
constexpr T&& forward(typename etl::remove_reference<T>::type& t) noexcept
{
return static_cast<T&&>(t);
}
template <typename T>
constexpr T&& forward(typename etl::remove_reference<T>::type&& t) noexcept
{
return static_cast<T&&>(t);
}
#endif
}
#endif

17
include/etl/stl/functional.h
View File

@ -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 <functional>
#endif
#endif

47
include/etl/stl/iterator.h
View File

@ -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 <iterator>
#endif
#endif

46
include/etl/stl/limits.h
View File

@ -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 <limits>
#endif
#endif

46
include/etl/stl/utility.h
View File

@ -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 <utility>
#endif
#endif

48
include/etl/string_view.h
View File

@ -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_iterator> const_reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
enum
{
@ -155,7 +155,7 @@ namespace etl
//*************************************************************************
/// Construct from iterator/size.
//*************************************************************************
template <typename TSize, typename TDummy = typename etl::enable_if<etl::is_integral<TSize>::value, void>::type>
template <typename TSize, typename TDummy = typename etlstd::enable_if<etlstd::is_integral<TSize>::value, void>::type>
ETL_CONSTEXPR17 basic_string_view(const T* begin_, TSize size_)
: mbegin(begin_),
mend(begin_ + size_)
@ -309,11 +309,11 @@ namespace etl
/// Assign from iterators
//*************************************************************************
template <typename TIterator,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
void assign(TIterator begin_, TIterator end_)
typename TDummy = typename etlstd::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
void assign(TIterator begin_, TIterator end_)
{
mbegin = etl::addressof(*begin_);
mend = etl::addressof(*begin_) + ETL_STD::distance(begin_, end_);
mend = etl::addressof(*begin_) + etlstd::distance(begin_, end_);
}
//*************************************************************************
@ -321,8 +321,8 @@ namespace etl
//*************************************************************************
template <typename TIterator,
typename TSize,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
void assign(TIterator begin_, TSize size_)
typename TDummy = typename etlstd::enable_if<etlstd::is_integral<TSize>::value, void>::type>
void assign(TIterator begin_, TSize size_)
{
mbegin = etl::addressof(*begin_);
mend = etl::addressof(*begin_) + size_;
@ -351,8 +351,14 @@ namespace etl
//*************************************************************************
void swap(basic_string_view& other)
{
ETL_STD::swap(mbegin, other.mbegin);
ETL_STD::swap(mend, other.mend);
#if defined(ETL_NO_STL)
using etlstd::swap;
#else
using std::swap;
#endif
swap(mbegin, other.mbegin);
swap(mend, other.mend);
}
//*************************************************************************
@ -364,9 +370,9 @@ namespace etl
if (position < size())
{
n = ETL_STD::min(count, size() - position);
n = etlstd::min(count, size() - position);
ETL_STD::copy(mbegin + position, mbegin + position + n, destination);
etlstd::copy(mbegin + position, mbegin + position + n, destination);
}
return n;
@ -381,7 +387,7 @@ namespace etl
if (position < size())
{
size_t n = ETL_STD::min(count, size() - position);
size_t n = etlstd::min(count, size() - position);
view = basic_string_view(mbegin + position, mbegin + position + n);
}
@ -495,7 +501,7 @@ namespace etl
return npos;
}
const_iterator iposition = ETL_STD::search(begin() + position, end(), view.begin(), view.end());
const_iterator iposition = etlstd::search(begin() + position, end(), view.begin(), view.end());
if (iposition == end())
{
@ -503,7 +509,7 @@ namespace etl
}
else
{
return ETL_STD::distance(begin(), iposition);
return etlstd::distance(begin(), iposition);
}
}
@ -532,9 +538,9 @@ namespace etl
return npos;
}
position = ETL_STD::min(position, size());
position = etlstd::min(position, size());
const_iterator iposition = ETL_STD::find_end(begin(),
const_iterator iposition = etlstd::find_end(begin(),
begin() + position,
view.begin(),
view.end());
@ -545,7 +551,7 @@ namespace etl
}
else
{
return ETL_STD::distance(begin(), iposition);
return etlstd::distance(begin(), iposition);
}
}
@ -615,7 +621,7 @@ namespace etl
return npos;
}
position = ETL_STD::min(position, size() - 1);
position = etlstd::min(position, size() - 1);
const_reverse_iterator it = rbegin() + size() - position - 1;
@ -711,7 +717,7 @@ namespace etl
return npos;
}
position = ETL_STD::min(position, size() - 1);
position = etlstd::min(position, size() - 1);
const_reverse_iterator it = rbegin() + size() - position - 1;
@ -762,7 +768,7 @@ namespace etl
friend bool operator == (const etl::basic_string_view<T, TTraits>& lhs, const etl::basic_string_view<T, TTraits>& rhs)
{
return (lhs.size() == rhs.size()) &&
ETL_STD::equal(lhs.begin(), lhs.end(), rhs.begin());
etlstd::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
@ -778,7 +784,7 @@ namespace etl
//*************************************************************************
friend bool operator < (const etl::basic_string_view<T, TTraits>& lhs, const etl::basic_string_view<T, TTraits>& rhs)
{
return ETL_STD::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
return etlstd::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//*************************************************************************

104
include/etl/type_lookup.h
View File

@ -101,28 +101,28 @@ namespace etl
struct type_from_id
{
typedef
typename etl::conditional<ID == T1::ID, typename T1::type,
typename etl::conditional<ID == T2::ID, typename T2::type,
typename etl::conditional<ID == T3::ID, typename T3::type,
typename etl::conditional<ID == T4::ID, typename T4::type,
typename etl::conditional<ID == T5::ID, typename T5::type,
typename etl::conditional<ID == T6::ID, typename T6::type,
typename etl::conditional<ID == T7::ID, typename T7::type,
typename etl::conditional<ID == T8::ID, typename T8::type,
typename etl::conditional<ID == T9::ID, typename T9::type,
typename etl::conditional<ID == T10::ID, typename T10::type,
typename etl::conditional<ID == T11::ID, typename T11::type,
typename etl::conditional<ID == T12::ID, typename T12::type,
typename etl::conditional<ID == T13::ID, typename T13::type,
typename etl::conditional<ID == T14::ID, typename T14::type,
typename etl::conditional<ID == T15::ID, typename T15::type,
typename etl::conditional<ID == T16::ID, typename T16::type,
etl::null_type<0>>::type>::type>::type>::type>
typename etlstd::conditional<ID == T1::ID, typename T1::type,
typename etlstd::conditional<ID == T2::ID, typename T2::type,
typename etlstd::conditional<ID == T3::ID, typename T3::type,
typename etlstd::conditional<ID == T4::ID, typename T4::type,
typename etlstd::conditional<ID == T5::ID, typename T5::type,
typename etlstd::conditional<ID == T6::ID, typename T6::type,
typename etlstd::conditional<ID == T7::ID, typename T7::type,
typename etlstd::conditional<ID == T8::ID, typename T8::type,
typename etlstd::conditional<ID == T9::ID, typename T9::type,
typename etlstd::conditional<ID == T10::ID, typename T10::type,
typename etlstd::conditional<ID == T11::ID, typename T11::type,
typename etlstd::conditional<ID == T12::ID, typename T12::type,
typename etlstd::conditional<ID == T13::ID, typename T13::type,
typename etlstd::conditional<ID == T14::ID, typename T14::type,
typename etlstd::conditional<ID == T15::ID, typename T15::type,
typename etlstd::conditional<ID == T16::ID, typename T16::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<etl::null_type<0>, type>::value), "Invalid id");
ETL_STATIC_ASSERT(!(etlstd::is_same<etl::null_type<0>, type>::value), "Invalid id");
};
//************************************
@ -137,22 +137,22 @@ namespace etl
enum
{
value =
(unsigned int) etl::is_same<T, typename T1::type>::value ? T1::ID :
(unsigned int) etl::is_same<T, typename T2::type>::value ? T2::ID :
(unsigned int) etl::is_same<T, typename T3::type>::value ? T3::ID :
(unsigned int) etl::is_same<T, typename T4::type>::value ? T4::ID :
(unsigned int) etl::is_same<T, typename T5::type>::value ? T5::ID :
(unsigned int) etl::is_same<T, typename T6::type>::value ? T6::ID :
(unsigned int) etl::is_same<T, typename T7::type>::value ? T7::ID :
(unsigned int) etl::is_same<T, typename T8::type>::value ? T8::ID :
(unsigned int) etl::is_same<T, typename T9::type>::value ? T9::ID :
(unsigned int) etl::is_same<T, typename T10::type>::value ? T10::ID :
(unsigned int) etl::is_same<T, typename T11::type>::value ? T11::ID :
(unsigned int) etl::is_same<T, typename T12::type>::value ? T12::ID :
(unsigned int) etl::is_same<T, typename T13::type>::value ? T13::ID :
(unsigned int) etl::is_same<T, typename T14::type>::value ? T14::ID :
(unsigned int) etl::is_same<T, typename T15::type>::value ? T15::ID :
(unsigned int) etl::is_same<T, typename T16::type>::value ? T16::ID :
(unsigned int) etlstd::is_same<T, typename T1::type>::value ? T1::ID :
(unsigned int) etlstd::is_same<T, typename T2::type>::value ? T2::ID :
(unsigned int) etlstd::is_same<T, typename T3::type>::value ? T3::ID :
(unsigned int) etlstd::is_same<T, typename T4::type>::value ? T4::ID :
(unsigned int) etlstd::is_same<T, typename T5::type>::value ? T5::ID :
(unsigned int) etlstd::is_same<T, typename T6::type>::value ? T6::ID :
(unsigned int) etlstd::is_same<T, typename T7::type>::value ? T7::ID :
(unsigned int) etlstd::is_same<T, typename T8::type>::value ? T8::ID :
(unsigned int) etlstd::is_same<T, typename T9::type>::value ? T9::ID :
(unsigned int) etlstd::is_same<T, typename T10::type>::value ? T10::ID :
(unsigned int) etlstd::is_same<T, typename T11::type>::value ? T11::ID :
(unsigned int) etlstd::is_same<T, typename T12::type>::value ? T12::ID :
(unsigned int) etlstd::is_same<T, typename T13::type>::value ? T13::ID :
(unsigned int) etlstd::is_same<T, typename T14::type>::value ? T14::ID :
(unsigned int) etlstd::is_same<T, typename T15::type>::value ? T15::ID :
(unsigned int) etlstd::is_same<T, typename T16::type>::value ? T16::ID :
(unsigned int) UNKNOWN
};
@ -202,26 +202,26 @@ namespace etl
struct type_from_type
{
typedef
typename etl::conditional<etl::is_same<T, typename T1::type1>::value, typename T1::type2,
typename etl::conditional<etl::is_same<T, typename T2::type1>::value, typename T2::type2,
typename etl::conditional<etl::is_same<T, typename T3::type1>::value, typename T3::type2,
typename etl::conditional<etl::is_same<T, typename T4::type1>::value, typename T4::type2,
typename etl::conditional<etl::is_same<T, typename T5::type1>::value, typename T5::type2,
typename etl::conditional<etl::is_same<T, typename T6::type1>::value, typename T6::type2,
typename etl::conditional<etl::is_same<T, typename T7::type1>::value, typename T7::type2,
typename etl::conditional<etl::is_same<T, typename T8::type1>::value, typename T8::type2,
typename etl::conditional<etl::is_same<T, typename T9::type1>::value, typename T9::type2,
typename etl::conditional<etl::is_same<T, typename T10::type1>::value, typename T10::type2,
typename etl::conditional<etl::is_same<T, typename T11::type1>::value, typename T11::type2,
typename etl::conditional<etl::is_same<T, typename T12::type1>::value, typename T12::type2,
typename etl::conditional<etl::is_same<T, typename T13::type1>::value, typename T13::type2,
typename etl::conditional<etl::is_same<T, typename T14::type1>::value, typename T14::type2,
typename etl::conditional<etl::is_same<T, typename T15::type1>::value, typename T15::type2,
typename etl::conditional<etl::is_same<T, typename T16::type1>::value, typename T16::type2,
etl::null_type<0>>::type>::type>::type>::type>::type>::type>::type>::type>
typename etlstd::conditional<etlstd::is_same<T, typename T1::type1>::value, typename T1::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T2::type1>::value, typename T2::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T3::type1>::value, typename T3::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T4::type1>::value, typename T4::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T5::type1>::value, typename T5::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T6::type1>::value, typename T6::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T7::type1>::value, typename T7::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T8::type1>::value, typename T8::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T9::type1>::value, typename T9::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T10::type1>::value, typename T10::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T11::type1>::value, typename T11::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T12::type1>::value, typename T12::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T13::type1>::value, typename T13::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T14::type1>::value, typename T14::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T15::type1>::value, typename T15::type2,
typename etlstd::conditional<etlstd::is_same<T, typename T16::type1>::value, typename T16::type2,
etl::null_type<0> >::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type>::type>::type>::type>::type>::type>::type type;
ETL_STATIC_ASSERT(!(etl::is_same<etl::null_type<0>, type>::value), "Invalid type");
ETL_STATIC_ASSERT(!(etlstd::is_same<etl::null_type<0>, type>::value), "Invalid type");
};
};
}

10
include/etl/type_lookup_generator.h
View File

@ -104,7 +104,7 @@ namespace etl
cog.outl(" {")
cog.outl(" typedef ")
for n in range(1, int(NTypes) + 1):
cog.outl(" typename etl::conditional<ID == T%s::ID, typename T%s::type," %(n, n))
cog.outl(" typename etlstd::conditional<ID == T%s::ID, typename T%s::type," %(n, n))
cog.out(" etl::null_type<0> >")
for n in range(1, int(NTypes) + 1):
if n == int(NTypes):
@ -116,7 +116,7 @@ namespace etl
cog.outl("")
cog.out(" ")
cog.outl("")
cog.outl(" ETL_STATIC_ASSERT(!(etl::is_same<etl::null_type<0>, type>::value), \"Invalid id\");")
cog.outl(" ETL_STATIC_ASSERT(!(etlstd::is_same<etl::null_type<0>, type>::value), \"Invalid id\");")
cog.outl(" };")
cog.outl("")
cog.outl(" //************************************")
@ -132,7 +132,7 @@ namespace etl
cog.outl(" {")
cog.outl(" value =")
for n in range(1, int(NTypes) + 1) :
cog.outl(" (unsigned int) etl::is_same<T, typename T%s::type>::value ? T%s::ID :" % (n, n))
cog.outl(" (unsigned int) etlstd::is_same<T, typename T%s::type>::value ? T%s::ID :" % (n, n))
cog.outl(" (unsigned int) UNKNOWN")
cog.outl(" };")
cog.outl("")
@ -171,7 +171,7 @@ namespace etl
cog.outl(" {")
cog.outl(" typedef ")
for n in range(1, int(NTypes) + 1):
cog.outl(" typename etl::conditional<etl::is_same<T, typename T%s::type1>::value, typename T%s::type2," %(n, n))
cog.outl(" typename etlstd::conditional<etlstd::is_same<T, typename T%s::type1>::value, typename T%s::type2," %(n, n))
cog.out(" etl::null_type<0> >")
for n in range(1, int(NTypes) + 1):
if n == int(NTypes):
@ -183,7 +183,7 @@ namespace etl
cog.outl("")
cog.out(" ")
cog.outl("")
cog.outl(" ETL_STATIC_ASSERT(!(etl::is_same<etl::null_type<0>, type>::value), \"Invalid type\");")
cog.outl(" ETL_STATIC_ASSERT(!(etlstd::is_same<etl::null_type<0>, type>::value), \"Invalid type\");")
cog.outl(" };")
cog.outl("};")
]]]*/

272
include/etl/type_select.h
View File

@ -73,22 +73,22 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typename etl::conditional<ID == 9, T9,
typename etl::conditional<ID == 10, T10,
typename etl::conditional<ID == 11, T11,
typename etl::conditional<ID == 12, T12,
typename etl::conditional<ID == 13, T13,
typename etl::conditional<ID == 14, T14,
typename etl::conditional<ID == 15, T15,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
typename etlstd::conditional<ID == 9, T9,
typename etlstd::conditional<ID == 10, T10,
typename etlstd::conditional<ID == 11, T11,
typename etlstd::conditional<ID == 12, T12,
typename etlstd::conditional<ID == 13, T13,
typename etlstd::conditional<ID == 14, T14,
typename etlstd::conditional<ID == 15, T15,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type>::type>::type>::type>::type>::type>::type type;
@ -121,21 +121,21 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typename etl::conditional<ID == 9, T9,
typename etl::conditional<ID == 10, T10,
typename etl::conditional<ID == 11, T11,
typename etl::conditional<ID == 12, T12,
typename etl::conditional<ID == 13, T13,
typename etl::conditional<ID == 14, T14,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
typename etlstd::conditional<ID == 9, T9,
typename etlstd::conditional<ID == 10, T10,
typename etlstd::conditional<ID == 11, T11,
typename etlstd::conditional<ID == 12, T12,
typename etlstd::conditional<ID == 13, T13,
typename etlstd::conditional<ID == 14, T14,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type>::type>::type>::type>::type>::type type;
@ -167,20 +167,20 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typename etl::conditional<ID == 9, T9,
typename etl::conditional<ID == 10, T10,
typename etl::conditional<ID == 11, T11,
typename etl::conditional<ID == 12, T12,
typename etl::conditional<ID == 13, T13,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
typename etlstd::conditional<ID == 9, T9,
typename etlstd::conditional<ID == 10, T10,
typename etlstd::conditional<ID == 11, T11,
typename etlstd::conditional<ID == 12, T12,
typename etlstd::conditional<ID == 13, T13,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type>::type>::type>::type>::type type;
@ -211,19 +211,19 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typename etl::conditional<ID == 9, T9,
typename etl::conditional<ID == 10, T10,
typename etl::conditional<ID == 11, T11,
typename etl::conditional<ID == 12, T12,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
typename etlstd::conditional<ID == 9, T9,
typename etlstd::conditional<ID == 10, T10,
typename etlstd::conditional<ID == 11, T11,
typename etlstd::conditional<ID == 12, T12,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type>::type>::type>::type type;
@ -253,18 +253,18 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typename etl::conditional<ID == 9, T9,
typename etl::conditional<ID == 10, T10,
typename etl::conditional<ID == 11, T11,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
typename etlstd::conditional<ID == 9, T9,
typename etlstd::conditional<ID == 10, T10,
typename etlstd::conditional<ID == 11, T11,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type>::type>::type type;
@ -293,17 +293,17 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typename etl::conditional<ID == 9, T9,
typename etl::conditional<ID == 10, T10,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
typename etlstd::conditional<ID == 9, T9,
typename etlstd::conditional<ID == 10, T10,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type>::type type;
@ -331,16 +331,16 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typename etl::conditional<ID == 9, T9,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
typename etlstd::conditional<ID == 9, T9,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type>::type type;
@ -367,15 +367,15 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typename etl::conditional<ID == 8, T8,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
typename etlstd::conditional<ID == 8, T8,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type>
::type type;
@ -401,14 +401,14 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typename etl::conditional<ID == 7, T7,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
typename etlstd::conditional<ID == 7, T7,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type>::type type;
@ -432,13 +432,13 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typename etl::conditional<ID == 6, T6,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
typename etlstd::conditional<ID == 6, T6,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type>::type type;
@ -461,12 +461,12 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typename etl::conditional<ID == 5, T5,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
typename etlstd::conditional<ID == 5, T5,
etl::null_type<0> >
::type>::type>::type>::type>::type>::type type;
@ -488,11 +488,11 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typename etl::conditional<ID == 4, T4,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
typename etlstd::conditional<ID == 4, T4,
etl::null_type<0> >
::type>::type>::type>::type>::type type;
@ -513,10 +513,10 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typename etl::conditional<ID == 3, T3,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
typename etlstd::conditional<ID == 3, T3,
etl::null_type<0> >
::type>::type>::type>::type type;
@ -536,9 +536,9 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typename etl::conditional<ID == 2, T2,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
typename etlstd::conditional<ID == 2, T2,
etl::null_type<0> >
::type>::type>::type type;
@ -557,8 +557,8 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typename etl::conditional<ID == 1, T1,
typedef typename etlstd::conditional<ID == 0, T0,
typename etlstd::conditional<ID == 1, T1,
etl::null_type<0> >
::type>::type type;
@ -576,7 +576,7 @@ namespace etl
template <const size_t ID>
struct select
{
typedef typename etl::conditional<ID == 0, T0,
typedef typename etlstd::conditional<ID == 0, T0,
etl::null_type<0> >
::type type;

8
include/etl/type_select_generator.h
View File

@ -75,9 +75,9 @@ namespace etl
cog.outl(" template <const size_t ID>")
cog.outl(" struct select")
cog.outl(" {")
cog.outl(" typedef typename etl::conditional<ID == 0, T0,")
cog.outl(" typedef typename etlstd::conditional<ID == 0, T0,")
for n in range(1, int(NTypes)) :
cog.outl(" typename etl::conditional<ID == %s, T%s," % (n, n))
cog.outl(" typename etlstd::conditional<ID == %s, T%s," % (n, n))
cog.outl(" etl::null_type<0> >")
cog.out(" ")
for n in range(1, int(NTypes)) :
@ -110,9 +110,9 @@ namespace etl
cog.outl(" template <const size_t ID>")
cog.outl(" struct select")
cog.outl(" {")
cog.outl(" typedef typename etl::conditional<ID == 0, T0,")
cog.outl(" typedef typename etlstd::conditional<ID == 0, T0,")
for n in range(1, s) :
cog.outl(" typename etl::conditional<ID == %s, T%s," % (n, n))
cog.outl(" typename etlstd::conditional<ID == %s, T%s," % (n, n))
cog.outl(" etl::null_type<0> >")
cog.out(" ")
for n in range(1, s) :

1254
include/etl/type_traits.h
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More