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

Updates to C++03 compatibility

Browse Source
This commit is contained in:
John Wellbelove 2021-03-12 17:31:40 +00:00
parent fb17d48d9b
commit 87bf9ce76d
45 changed files with 259 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
include/etl/array.h
View File

@ -139,7 +139,7 @@ namespace etl
/// Returns a reference to the value at index 'i'.
///\param i The index of the element to access.
//*************************************************************************
ETL_CONSTEXPR reference operator[](size_t i)
reference operator[](size_t i)
{
return _buffer[i];
}
@ -157,7 +157,7 @@ namespace etl
//*************************************************************************
/// Returns a reference to the first element.
//*************************************************************************
ETL_CONSTEXPR reference front()
reference front()
{
return _buffer[0];
}
@ -173,7 +173,7 @@ namespace etl
//*************************************************************************
/// Returns a reference to the last element.
//*************************************************************************
ETL_CONSTEXPR reference back()
reference back()
{
return _buffer[SIZE - 1];
}
@ -189,7 +189,7 @@ namespace etl
//*************************************************************************
/// Returns a pointer to the first element of the internal buffer.
//*************************************************************************
ETL_CONSTEXPR pointer data() ETL_NOEXCEPT
pointer data() ETL_NOEXCEPT
{
return &_buffer[0];
}
@ -209,7 +209,7 @@ namespace etl
//*************************************************************************
/// Returns an iterator to the beginning of the array.
//*************************************************************************
ETL_CONSTEXPR iterator begin() ETL_NOEXCEPT
iterator begin() ETL_NOEXCEPT
{
return &_buffer[0];
}
@ -233,7 +233,7 @@ namespace etl
//*************************************************************************
/// Returns an iterator to the end of the array.
//*************************************************************************
ETL_CONSTEXPR iterator end() ETL_NOEXCEPT
iterator end() ETL_NOEXCEPT
{
return &_buffer[SIZE];
}
@ -257,7 +257,7 @@ namespace etl
//*************************************************************************
// Returns an reverse iterator to the reverse beginning of the array.
//*************************************************************************
ETL_CONSTEXPR reverse_iterator rbegin() ETL_NOEXCEPT
reverse_iterator rbegin() ETL_NOEXCEPT
{
return reverse_iterator(end());
}
@ -281,7 +281,7 @@ namespace etl
//*************************************************************************
/// Returns a reverse iterator to the end of the array.
//*************************************************************************
ETL_CONSTEXPR reverse_iterator rend() ETL_NOEXCEPT
reverse_iterator rend() ETL_NOEXCEPT
{
return reverse_iterator(begin());
}

8
include/etl/basic_string.h
View File

@ -92,7 +92,7 @@ namespace etl
public:
string_empty(string_type file_name_, numeric_type line_number_)
: string_exception(ETL_ERROR_TEXT("string:empty", ETL_STRING_FILE_ID"A"), file_name_, line_number_)
: string_exception(ETL_ERROR_TEXT("string:empty", ETL_BASIC_STRING_FILE_ID"A"), file_name_, line_number_)
{
}
};
@ -106,7 +106,7 @@ namespace etl
public:
string_out_of_bounds(string_type file_name_, numeric_type line_number_)
: string_exception(ETL_ERROR_TEXT("string:bounds", ETL_STRING_FILE_ID"B"), file_name_, line_number_)
: string_exception(ETL_ERROR_TEXT("string:bounds", ETL_BASIC_STRING_FILE_ID"B"), file_name_, line_number_)
{
}
};
@ -120,7 +120,7 @@ namespace etl
public:
string_iterator(string_type file_name_, numeric_type line_number_)
: string_exception(ETL_ERROR_TEXT("string:iterator", ETL_STRING_FILE_ID"C"), file_name_, line_number_)
: string_exception(ETL_ERROR_TEXT("string:iterator", ETL_BASIC_STRING_FILE_ID"C"), file_name_, line_number_)
{
}
};
@ -134,7 +134,7 @@ namespace etl
public:
string_truncation(string_type file_name_, numeric_type line_number_)
: string_exception(ETL_ERROR_TEXT("string:iterator", ETL_STRING_FILE_ID"D"), file_name_, line_number_)
: string_exception(ETL_ERROR_TEXT("string:iterator", ETL_BASIC_STRING_FILE_ID"D"), file_name_, line_number_)
{
}
};

8
include/etl/circular_buffer.h
View File

@ -1064,8 +1064,8 @@ namespace etl
/// Constructor.
/// Constructs a buffer from an iterator range.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
circular_buffer(TIterator first, const TIterator& last)
template <typename TIterator>
circular_buffer(TIterator first, const TIterator& last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: icircular_buffer<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE)
{
while (first != last)
@ -1181,8 +1181,8 @@ namespace etl
/// Constructor.
/// Constructs a buffer from an iterator range.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
circular_buffer_ext(TIterator first, const TIterator& last, void* buffer, size_t max_size)
template <typename TIterator>
circular_buffer_ext(TIterator first, const TIterator& last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: icircular_buffer<T>(reinterpret_cast<T*>(buffer), max_size)
{
while (first != last)

9
include/etl/deque.h
View File

@ -2380,8 +2380,8 @@ namespace etl
//*************************************************************************
/// Assigns data to the deque.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
deque(TIterator begin_, TIterator end_)
template <typename TIterator>
deque(TIterator begin_, TIterator end_, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::ideque<T>(reinterpret_cast<T*>(buffer.raw), MAX_SIZE, BUFFER_SIZE)
{
this->assign(begin_, end_);
@ -2444,7 +2444,10 @@ namespace etl
//*************************************************************************
/// Fix the internal pointers after a low level memory copy.
//*************************************************************************
void repair()
#ifdef ETL_ISTRING_REPAIR_ENABLE
virtual
#endif
void repair()
#ifdef ETL_ISTRING_REPAIR_ENABLE
ETL_OVERRIDE
#endif

1
include/etl/file_error_numbers.h
View File

@ -91,5 +91,6 @@ SOFTWARE.
#define ETL_REFERENCE_COUNTER_MESSAGE_POOL_FILE_ID "58"
#define ETL_QUEUE_SPSC_LOCKABLE_FILE_ID "59"
#define ETL_MESSAGE_ROUTER_REGISTRY_FILE_ID "60"
#define ETL_ARRAY_WRAPPER_FILE_ID "61"
#endif

2
include/etl/flat_map.h
View File

@ -936,7 +936,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
flat_map(TIterator first, TIterator last)
: etl::iflat_map<TKey, TValue, TCompare>(lookup, storage)
{

2
include/etl/flat_multimap.h
View File

@ -839,7 +839,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
flat_multimap(TIterator first, TIterator last)
: etl::iflat_multimap<TKey, TValue, TCompare>(lookup, storage)
{

2
include/etl/flat_multiset.h
View File

@ -791,7 +791,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
flat_multiset(TIterator first, TIterator last)
: iflat_multiset<T, TCompare>(lookup, storage)
{

2
include/etl/flat_set.h
View File

@ -876,7 +876,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
flat_set(TIterator first, TIterator last)
: etl::iflat_set<T, TCompare>(lookup, storage)
{

8
include/etl/forward_list.h
View File

@ -1673,8 +1673,8 @@ namespace etl
//*************************************************************************
/// Construct from range.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
forward_list(TIterator first, TIterator last)
template <typename TIterator>
forward_list(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::iforward_list<T>(node_pool, MAX_SIZE, false)
{
this->assign(first, last);
@ -1834,8 +1834,8 @@ namespace etl
//*************************************************************************
/// Construct from range.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
forward_list_ext(TIterator first, TIterator last, etl::ipool& node_pool)
template <typename TIterator>
forward_list_ext(TIterator first, TIterator last, etl::ipool& node_pool, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::iforward_list<T>(node_pool, node_pool.max_size(), true)
{
this->assign(first, last);

2
include/etl/indirect_vector.h
View File

@ -65,7 +65,7 @@ namespace etl
public:
indirect_vector_buffer_missmatch(string_type file_name_, numeric_type line_number_)
: vector_exception(ETL_ERROR_TEXT("indirect_vector:buffer_missmatch", INDIRECT_VECTOR_FILE_ID"A"), file_name_, line_number_)
: vector_exception(ETL_ERROR_TEXT("indirect_vector:buffer_missmatch", ETL_INDIRECT_VECTOR_FILE_ID"A"), file_name_, line_number_)
{
}
};

4
include/etl/intrusive_forward_list.h
View File

@ -514,8 +514,8 @@ namespace etl
//*************************************************************************
/// Constructor from range
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
intrusive_forward_list(TIterator first, TIterator last)
template <typename TIterator>
intrusive_forward_list(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
{
this->assign(first, last);
}

4
include/etl/intrusive_list.h
View File

@ -599,8 +599,8 @@ namespace etl
//*************************************************************************
/// Constructor from range
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
intrusive_list(TIterator first, TIterator last)
template <typename TIterator>
intrusive_list(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
{
this->assign(first, last);
}

310
include/etl/limits.h
View File

@ -46,6 +46,8 @@ SOFTWARE.
#include <float.h>
#include <math.h>
#include "private/minmax_push.h"
#if defined(ETL_COMPILER_MICROSOFT)
#pragma warning(push)
#pragma warning(disable : 26812)
@ -196,15 +198,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = false;
static ETL_CONSTANT bool min() { return false; }
static ETL_CONSTANT bool max() { return true; }
static ETL_CONSTANT bool lowest() { return false; }
static ETL_CONSTANT bool epsilon() { return false; }
static ETL_CONSTANT bool round_error() { return false; }
static ETL_CONSTANT bool denorm_min() { return false; }
static ETL_CONSTANT bool infinity() { return false; }
static ETL_CONSTANT bool quiet_NaN() { return false; }
static ETL_CONSTANT bool signaling_NaN() { return false; }
static ETL_CONSTEXPR bool min() { return false; }
static ETL_CONSTEXPR bool max() { return true; }
static ETL_CONSTEXPR bool lowest() { return false; }
static ETL_CONSTEXPR bool epsilon() { return false; }
static ETL_CONSTEXPR bool round_error() { return false; }
static ETL_CONSTEXPR bool denorm_min() { return false; }
static ETL_CONSTEXPR bool infinity() { return false; }
static ETL_CONSTEXPR bool quiet_NaN() { return false; }
static ETL_CONSTEXPR bool signaling_NaN() { return false; }
};
//***************************************************************************
@ -219,15 +221,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = etl::is_signed<char>::value;
static ETL_CONSTANT bool is_modulo = false;
static ETL_CONSTANT char min() { return char(CHAR_MIN); }
static ETL_CONSTANT char max() { return char(CHAR_MAX); }
static ETL_CONSTANT char lowest() { return char(CHAR_MIN); }
static ETL_CONSTANT char epsilon() { return 0; }
static ETL_CONSTANT char round_error() { return 0; }
static ETL_CONSTANT char denorm_min() { return 0; }
static ETL_CONSTANT char infinity() { return 0; }
static ETL_CONSTANT char quiet_NaN() { return 0; }
static ETL_CONSTANT char signaling_NaN() { return 0; }
static ETL_CONSTEXPR char min() { return char(CHAR_MIN); }
static ETL_CONSTEXPR char max() { return char(CHAR_MAX); }
static ETL_CONSTEXPR char lowest() { return char(CHAR_MIN); }
static ETL_CONSTEXPR char epsilon() { return 0; }
static ETL_CONSTEXPR char round_error() { return 0; }
static ETL_CONSTEXPR char denorm_min() { return 0; }
static ETL_CONSTEXPR char infinity() { return 0; }
static ETL_CONSTEXPR char quiet_NaN() { return 0; }
static ETL_CONSTEXPR char signaling_NaN() { return 0; }
};
//***************************************************************************
@ -242,15 +244,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = true;
static ETL_CONSTANT unsigned char min() { return 0U; }
static ETL_CONSTANT unsigned char max() { return UCHAR_MAX; }
static ETL_CONSTANT unsigned char lowest() { return 0U; }
static ETL_CONSTANT unsigned char epsilon() { return 0U; }
static ETL_CONSTANT unsigned char round_error() { return 0U; }
static ETL_CONSTANT unsigned char denorm_min() { return 0U; }
static ETL_CONSTANT unsigned char infinity() { return 0U; }
static ETL_CONSTANT unsigned char quiet_NaN() { return 0U; }
static ETL_CONSTANT unsigned char signaling_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned char min() { return 0U; }
static ETL_CONSTEXPR unsigned char max() { return UCHAR_MAX; }
static ETL_CONSTEXPR unsigned char lowest() { return 0U; }
static ETL_CONSTEXPR unsigned char epsilon() { return 0U; }
static ETL_CONSTEXPR unsigned char round_error() { return 0U; }
static ETL_CONSTEXPR unsigned char denorm_min() { return 0U; }
static ETL_CONSTEXPR unsigned char infinity() { return 0U; }
static ETL_CONSTEXPR unsigned char quiet_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned char signaling_NaN() { return 0U; }
};
//***************************************************************************
@ -265,15 +267,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = true;
static ETL_CONSTANT bool is_modulo = false;
static ETL_CONSTANT signed char min() { return SCHAR_MIN; }
static ETL_CONSTANT signed char max() { return SCHAR_MAX; }
static ETL_CONSTANT signed char lowest() { return SCHAR_MIN; }
static ETL_CONSTANT signed char epsilon() { return 0; }
static ETL_CONSTANT signed char round_error() { return 0; }
static ETL_CONSTANT signed char denorm_min() { return 0; }
static ETL_CONSTANT signed char infinity() { return 0; }
static ETL_CONSTANT signed char quiet_NaN() { return 0; }
static ETL_CONSTANT signed char signaling_NaN() { return 0; }
static ETL_CONSTEXPR signed char min() { return SCHAR_MIN; }
static ETL_CONSTEXPR signed char max() { return SCHAR_MAX; }
static ETL_CONSTEXPR signed char lowest() { return SCHAR_MIN; }
static ETL_CONSTEXPR signed char epsilon() { return 0; }
static ETL_CONSTEXPR signed char round_error() { return 0; }
static ETL_CONSTEXPR signed char denorm_min() { return 0; }
static ETL_CONSTEXPR signed char infinity() { return 0; }
static ETL_CONSTEXPR signed char quiet_NaN() { return 0; }
static ETL_CONSTEXPR signed char signaling_NaN() { return 0; }
};
#if (ETL_NO_LARGE_CHAR_SUPPORT == false)
@ -289,15 +291,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = true;
static ETL_CONSTANT char16_t min() { return 0U; }
static ETL_CONSTANT char16_t max() { return UINT_LEAST16_MAX; }
static ETL_CONSTANT char16_t lowest() { return 0U; }
static ETL_CONSTANT char16_t epsilon() { return 0U; }
static ETL_CONSTANT char16_t round_error() { return 0U; }
static ETL_CONSTANT char16_t denorm_min() { return 0U; }
static ETL_CONSTANT char16_t infinity() { return 0U; }
static ETL_CONSTANT char16_t quiet_NaN() { return 0U; }
static ETL_CONSTANT char16_t signaling_NaN() { return 0U; }
static ETL_CONSTEXPR char16_t min() { return 0U; }
static ETL_CONSTEXPR char16_t max() { return UINT_LEAST16_MAX; }
static ETL_CONSTEXPR char16_t lowest() { return 0U; }
static ETL_CONSTEXPR char16_t epsilon() { return 0U; }
static ETL_CONSTEXPR char16_t round_error() { return 0U; }
static ETL_CONSTEXPR char16_t denorm_min() { return 0U; }
static ETL_CONSTEXPR char16_t infinity() { return 0U; }
static ETL_CONSTEXPR char16_t quiet_NaN() { return 0U; }
static ETL_CONSTEXPR char16_t signaling_NaN() { return 0U; }
};
//***************************************************************************
@ -312,15 +314,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = true;
static ETL_CONSTANT char32_t min() { return 0U; }
static ETL_CONSTANT char32_t max() { return UINT_LEAST32_MAX; }
static ETL_CONSTANT char32_t lowest() { return 0U; }
static ETL_CONSTANT char32_t epsilon() { return 0U; }
static ETL_CONSTANT char32_t round_error() { return 0U; }
static ETL_CONSTANT char32_t denorm_min() { return 0U; }
static ETL_CONSTANT char32_t infinity() { return 0U; }
static ETL_CONSTANT char32_t quiet_NaN() { return 0U; }
static ETL_CONSTANT char32_t signaling_NaN() { return 0U; }
static ETL_CONSTEXPR char32_t min() { return 0U; }
static ETL_CONSTEXPR char32_t max() { return UINT_LEAST32_MAX; }
static ETL_CONSTEXPR char32_t lowest() { return 0U; }
static ETL_CONSTEXPR char32_t epsilon() { return 0U; }
static ETL_CONSTEXPR char32_t round_error() { return 0U; }
static ETL_CONSTEXPR char32_t denorm_min() { return 0U; }
static ETL_CONSTEXPR char32_t infinity() { return 0U; }
static ETL_CONSTEXPR char32_t quiet_NaN() { return 0U; }
static ETL_CONSTEXPR char32_t signaling_NaN() { return 0U; }
};
#endif
@ -337,15 +339,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = etl::is_signed<wchar_t>::value;
static ETL_CONSTANT bool is_modulo = etl::is_unsigned<wchar_t>::value;
static ETL_CONSTANT wchar_t min() { return WCHAR_MIN; }
static ETL_CONSTANT wchar_t max() { return WCHAR_MAX; }
static ETL_CONSTANT wchar_t lowest() { return WCHAR_MIN; }
static ETL_CONSTANT wchar_t epsilon() { return wchar_t(0); }
static ETL_CONSTANT wchar_t round_error() { return wchar_t(0); }
static ETL_CONSTANT wchar_t denorm_min() { return wchar_t(0); }
static ETL_CONSTANT wchar_t infinity() { return wchar_t(0); }
static ETL_CONSTANT wchar_t quiet_NaN() { return wchar_t(0); }
static ETL_CONSTANT wchar_t signaling_NaN() { return wchar_t(0); }
static ETL_CONSTEXPR wchar_t min() { return WCHAR_MIN; }
static ETL_CONSTEXPR wchar_t max() { return WCHAR_MAX; }
static ETL_CONSTEXPR wchar_t lowest() { return WCHAR_MIN; }
static ETL_CONSTEXPR wchar_t epsilon() { return wchar_t(0); }
static ETL_CONSTEXPR wchar_t round_error() { return wchar_t(0); }
static ETL_CONSTEXPR wchar_t denorm_min() { return wchar_t(0); }
static ETL_CONSTEXPR wchar_t infinity() { return wchar_t(0); }
static ETL_CONSTEXPR wchar_t quiet_NaN() { return wchar_t(0); }
static ETL_CONSTEXPR wchar_t signaling_NaN() { return wchar_t(0); }
};
//***************************************************************************
@ -360,15 +362,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = true;
static ETL_CONSTANT bool is_modulo = false;
static ETL_CONSTANT short min() { return SHRT_MIN; }
static ETL_CONSTANT short max() { return SHRT_MAX; }
static ETL_CONSTANT short lowest() { return SHRT_MIN; }
static ETL_CONSTANT short epsilon() { return 0; }
static ETL_CONSTANT short round_error() { return 0; }
static ETL_CONSTANT short denorm_min() { return 0; }
static ETL_CONSTANT short infinity() { return 0; }
static ETL_CONSTANT short quiet_NaN() { return 0; }
static ETL_CONSTANT short signaling_NaN() { return 0; }
static ETL_CONSTEXPR short min() { return SHRT_MIN; }
static ETL_CONSTEXPR short max() { return SHRT_MAX; }
static ETL_CONSTEXPR short lowest() { return SHRT_MIN; }
static ETL_CONSTEXPR short epsilon() { return 0; }
static ETL_CONSTEXPR short round_error() { return 0; }
static ETL_CONSTEXPR short denorm_min() { return 0; }
static ETL_CONSTEXPR short infinity() { return 0; }
static ETL_CONSTEXPR short quiet_NaN() { return 0; }
static ETL_CONSTEXPR short signaling_NaN() { return 0; }
};
//***************************************************************************
@ -383,15 +385,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = true;
static ETL_CONSTANT unsigned short min() { return 0U; }
static ETL_CONSTANT unsigned short max() { return USHRT_MAX; }
static ETL_CONSTANT unsigned short lowest() { return 0U; }
static ETL_CONSTANT unsigned short epsilon() { return 0U; }
static ETL_CONSTANT unsigned short round_error() { return 0U; }
static ETL_CONSTANT unsigned short denorm_min() { return 0U; }
static ETL_CONSTANT unsigned short infinity() { return 0U; }
static ETL_CONSTANT unsigned short quiet_NaN() { return 0U; }
static ETL_CONSTANT unsigned short signaling_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned short min() { return 0U; }
static ETL_CONSTEXPR unsigned short max() { return USHRT_MAX; }
static ETL_CONSTEXPR unsigned short lowest() { return 0U; }
static ETL_CONSTEXPR unsigned short epsilon() { return 0U; }
static ETL_CONSTEXPR unsigned short round_error() { return 0U; }
static ETL_CONSTEXPR unsigned short denorm_min() { return 0U; }
static ETL_CONSTEXPR unsigned short infinity() { return 0U; }
static ETL_CONSTEXPR unsigned short quiet_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned short signaling_NaN() { return 0U; }
};
@ -407,15 +409,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = true;
static ETL_CONSTANT bool is_modulo = false;
static ETL_CONSTANT int min() { return INT_MIN; }
static ETL_CONSTANT int max() { return INT_MAX; }
static ETL_CONSTANT int lowest() { return INT_MIN; }
static ETL_CONSTANT int epsilon() { return 0; }
static ETL_CONSTANT int round_error() { return 0; }
static ETL_CONSTANT int denorm_min() { return 0; }
static ETL_CONSTANT int infinity() { return 0; }
static ETL_CONSTANT int quiet_NaN() { return 0; }
static ETL_CONSTANT int signaling_NaN() { return 0; }
static ETL_CONSTEXPR int min() { return INT_MIN; }
static ETL_CONSTEXPR int max() { return INT_MAX; }
static ETL_CONSTEXPR int lowest() { return INT_MIN; }
static ETL_CONSTEXPR int epsilon() { return 0; }
static ETL_CONSTEXPR int round_error() { return 0; }
static ETL_CONSTEXPR int denorm_min() { return 0; }
static ETL_CONSTEXPR int infinity() { return 0; }
static ETL_CONSTEXPR int quiet_NaN() { return 0; }
static ETL_CONSTEXPR int signaling_NaN() { return 0; }
};
//***************************************************************************
@ -430,15 +432,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = true;
static ETL_CONSTANT unsigned int min() { return 0U; }
static ETL_CONSTANT unsigned int max() { return UINT_MAX; }
static ETL_CONSTANT unsigned int lowest() { return 0U; }
static ETL_CONSTANT unsigned int epsilon() { return 0U; }
static ETL_CONSTANT unsigned int round_error() { return 0U; }
static ETL_CONSTANT unsigned int denorm_min() { return 0U; }
static ETL_CONSTANT unsigned int infinity() { return 0U; }
static ETL_CONSTANT unsigned int quiet_NaN() { return 0U; }
static ETL_CONSTANT unsigned int signaling_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned int min() { return 0U; }
static ETL_CONSTEXPR unsigned int max() { return UINT_MAX; }
static ETL_CONSTEXPR unsigned int lowest() { return 0U; }
static ETL_CONSTEXPR unsigned int epsilon() { return 0U; }
static ETL_CONSTEXPR unsigned int round_error() { return 0U; }
static ETL_CONSTEXPR unsigned int denorm_min() { return 0U; }
static ETL_CONSTEXPR unsigned int infinity() { return 0U; }
static ETL_CONSTEXPR unsigned int quiet_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned int signaling_NaN() { return 0U; }
};
//***************************************************************************
@ -453,15 +455,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = true;
static ETL_CONSTANT bool is_modulo = false;
static ETL_CONSTANT long min() { return LONG_MIN; }
static ETL_CONSTANT long max() { return LONG_MAX; }
static ETL_CONSTANT long lowest() { return LONG_MIN; }
static ETL_CONSTANT long epsilon() { return 0; }
static ETL_CONSTANT long round_error() { return 0; }
static ETL_CONSTANT long denorm_min() { return 0; }
static ETL_CONSTANT long infinity() { return 0; }
static ETL_CONSTANT long quiet_NaN() { return 0; }
static ETL_CONSTANT long signaling_NaN() { return 0; }
static ETL_CONSTEXPR long min() { return LONG_MIN; }
static ETL_CONSTEXPR long max() { return LONG_MAX; }
static ETL_CONSTEXPR long lowest() { return LONG_MIN; }
static ETL_CONSTEXPR long epsilon() { return 0; }
static ETL_CONSTEXPR long round_error() { return 0; }
static ETL_CONSTEXPR long denorm_min() { return 0; }
static ETL_CONSTEXPR long infinity() { return 0; }
static ETL_CONSTEXPR long quiet_NaN() { return 0; }
static ETL_CONSTEXPR long signaling_NaN() { return 0; }
};
//***************************************************************************
@ -476,15 +478,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = true;
static ETL_CONSTANT unsigned long min() { return 0U; }
static ETL_CONSTANT unsigned long max() { return ULONG_MAX; }
static ETL_CONSTANT unsigned long lowest() { return 0U; }
static ETL_CONSTANT unsigned long epsilon() { return 0U; }
static ETL_CONSTANT unsigned long round_error() { return 0U; }
static ETL_CONSTANT unsigned long denorm_min() { return 0U; }
static ETL_CONSTANT unsigned long infinity() { return 0U; }
static ETL_CONSTANT unsigned long quiet_NaN() { return 0U; }
static ETL_CONSTANT unsigned long signaling_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned long min() { return 0U; }
static ETL_CONSTEXPR unsigned long max() { return ULONG_MAX; }
static ETL_CONSTEXPR unsigned long lowest() { return 0U; }
static ETL_CONSTEXPR unsigned long epsilon() { return 0U; }
static ETL_CONSTEXPR unsigned long round_error() { return 0U; }
static ETL_CONSTEXPR unsigned long denorm_min() { return 0U; }
static ETL_CONSTEXPR unsigned long infinity() { return 0U; }
static ETL_CONSTEXPR unsigned long quiet_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned long signaling_NaN() { return 0U; }
};
//***************************************************************************
@ -499,15 +501,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = true;
static ETL_CONSTANT bool is_modulo = false;
static ETL_CONSTANT long long min() { return LLONG_MIN; }
static ETL_CONSTANT long long max() { return LLONG_MAX; }
static ETL_CONSTANT long long lowest() { return LLONG_MIN; }
static ETL_CONSTANT long long epsilon() { return 0; }
static ETL_CONSTANT long long round_error() { return 0; }
static ETL_CONSTANT long long denorm_min() { return 0; }
static ETL_CONSTANT long long infinity() { return 0; }
static ETL_CONSTANT long long quiet_NaN() { return 0; }
static ETL_CONSTANT long long signaling_NaN() { return 0; }
static ETL_CONSTEXPR long long min() { return LLONG_MIN; }
static ETL_CONSTEXPR long long max() { return LLONG_MAX; }
static ETL_CONSTEXPR long long lowest() { return LLONG_MIN; }
static ETL_CONSTEXPR long long epsilon() { return 0; }
static ETL_CONSTEXPR long long round_error() { return 0; }
static ETL_CONSTEXPR long long denorm_min() { return 0; }
static ETL_CONSTEXPR long long infinity() { return 0; }
static ETL_CONSTEXPR long long quiet_NaN() { return 0; }
static ETL_CONSTEXPR long long signaling_NaN() { return 0; }
};
//***************************************************************************
@ -522,15 +524,15 @@ namespace etl
static ETL_CONSTANT bool is_signed = false;
static ETL_CONSTANT bool is_modulo = true;
static ETL_CONSTANT unsigned long long min() { return 0U; }
static ETL_CONSTANT unsigned long long max() { return ULLONG_MAX; }
static ETL_CONSTANT unsigned long long lowest() { return 0U; }
static ETL_CONSTANT unsigned long long epsilon() { return 0U; }
static ETL_CONSTANT unsigned long long round_error() { return 0U; }
static ETL_CONSTANT unsigned long long denorm_min() { return 0U; }
static ETL_CONSTANT unsigned long long infinity() { return 0U; }
static ETL_CONSTANT unsigned long long quiet_NaN() { return 0U; }
static ETL_CONSTANT unsigned long long signaling_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned long long min() { return 0U; }
static ETL_CONSTEXPR unsigned long long max() { return ULLONG_MAX; }
static ETL_CONSTEXPR unsigned long long lowest() { return 0U; }
static ETL_CONSTEXPR unsigned long long epsilon() { return 0U; }
static ETL_CONSTEXPR unsigned long long round_error() { return 0U; }
static ETL_CONSTEXPR unsigned long long denorm_min() { return 0U; }
static ETL_CONSTEXPR unsigned long long infinity() { return 0U; }
static ETL_CONSTEXPR unsigned long long quiet_NaN() { return 0U; }
static ETL_CONSTEXPR unsigned long long signaling_NaN() { return 0U; }
};
//***************************************************************************
@ -540,12 +542,12 @@ namespace etl
{
public:
static ETL_CONSTANT float min() { return FLT_MIN; }
static ETL_CONSTANT float max() { return FLT_MAX; }
static ETL_CONSTANT float lowest() { return -FLT_MAX; }
static ETL_CONSTANT float epsilon() { return FLT_EPSILON; }
static ETL_CONSTANT float denorm_min() { return FLT_MIN; }
static ETL_CONSTANT float infinity() { return HUGE_VALF; }
static ETL_CONSTEXPR float min() { return FLT_MIN; }
static ETL_CONSTEXPR float max() { return FLT_MAX; }
static ETL_CONSTEXPR float lowest() { return -FLT_MAX; }
static ETL_CONSTEXPR float epsilon() { return FLT_EPSILON; }
static ETL_CONSTEXPR float denorm_min() { return FLT_MIN; }
static ETL_CONSTEXPR float infinity() { return HUGE_VALF; }
static float quiet_NaN() { return ETL_NANF; }
static float signaling_NaN() { return ETL_NANF; }
@ -566,12 +568,12 @@ namespace etl
{
public:
static ETL_CONSTANT double min() { return DBL_MIN; }
static ETL_CONSTANT double max() { return DBL_MAX; }
static ETL_CONSTANT double lowest() { return -DBL_MAX; }
static ETL_CONSTANT double epsilon() { return DBL_EPSILON; }
static ETL_CONSTANT double denorm_min() { return DBL_MIN; }
static ETL_CONSTANT double infinity() { return HUGE_VAL; }
static ETL_CONSTEXPR double min() { return DBL_MIN; }
static ETL_CONSTEXPR double max() { return DBL_MAX; }
static ETL_CONSTEXPR double lowest() { return -DBL_MAX; }
static ETL_CONSTEXPR double epsilon() { return DBL_EPSILON; }
static ETL_CONSTEXPR double denorm_min() { return DBL_MIN; }
static ETL_CONSTEXPR double infinity() { return HUGE_VAL; }
static double quiet_NaN() { return ETL_NAN; }
static double signaling_NaN() { return ETL_NAN; }
@ -592,12 +594,12 @@ namespace etl
{
public:
static ETL_CONSTANT long double min() { return LDBL_MIN; }
static ETL_CONSTANT long double max() { return LDBL_MAX; }
static ETL_CONSTANT long double lowest() { return -LDBL_MAX; }
static ETL_CONSTANT long double epsilon() { return LDBL_EPSILON; }
static ETL_CONSTANT long double denorm_min() { return LDBL_MIN; }
static ETL_CONSTANT long double infinity() { return HUGE_VALL; }
static ETL_CONSTEXPR long double min() { return LDBL_MIN; }
static ETL_CONSTEXPR long double max() { return LDBL_MAX; }
static ETL_CONSTEXPR long double lowest() { return -LDBL_MAX; }
static ETL_CONSTEXPR long double epsilon() { return LDBL_EPSILON; }
static ETL_CONSTEXPR long double denorm_min() { return LDBL_MIN; }
static ETL_CONSTEXPR long double infinity() { return HUGE_VALL; }
static long double quiet_NaN() { return ETL_NANL; }
static long double signaling_NaN() { return ETL_NANL; }
@ -645,4 +647,6 @@ namespace etl
#pragma warning(pop)
#endif
#include "private/minmax_pop.h"
#endif

8
include/etl/list.h
View File

@ -2115,8 +2115,8 @@ namespace etl
//*************************************************************************
/// Construct from range.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
list(TIterator first, TIterator last)
template <typename TIterator>
list(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: ilist<T>(node_pool, MAX_SIZE, false)
{
this->assign(first, last);
@ -2279,8 +2279,8 @@ namespace etl
//*************************************************************************
/// Construct from range.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
list_ext(TIterator first, TIterator last, etl::ipool& node_pool)
template <typename TIterator>
list_ext(TIterator first, TIterator last, etl::ipool& node_pool, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: ilist<T>(node_pool, node_pool.max_size(), true)
{
this->assign(first, last);

2
include/etl/map.h
View File

@ -2223,7 +2223,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
map(TIterator first, TIterator last)
: etl::imap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
{

3
include/etl/memory.h
View File

@ -1542,9 +1542,8 @@ namespace etl
unique_ptr(const unique_ptr&) ETL_DELETE;
unique_ptr& operator =(const unique_ptr&) ETL_DELETE;
pointer p;
TDeleter deleter;
pointer p;
};
}

2
include/etl/multimap.h
View File

@ -2085,7 +2085,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
multimap(TIterator first, TIterator last)
: etl::imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
{

2
include/etl/multiset.h
View File

@ -2066,7 +2066,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
multiset(TIterator first, TIterator last)
: etl::imultiset<TKey, TCompare>(node_pool, MAX_SIZE)
{

2
include/etl/priority_queue.h
View File

@ -455,7 +455,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
priority_queue(TIterator first, TIterator last)
: etl::ipriority_queue<T, TContainer, TCompare>()
{

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

@ -179,7 +179,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template<typename TIterator>
crc16_poly_0x1021(TIterator begin, const TIterator end)
{
this->reset();

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

@ -179,7 +179,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template<typename TIterator>
crc16_poly_0x8005(TIterator begin, const TIterator end)
{
this->reset();

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

@ -179,7 +179,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template<typename TIterator>
crc32_poly_0x04c11db7(TIterator begin, const TIterator end)
{
this->reset();

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

@ -179,7 +179,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template<typename TIterator>
crc32_poly_0x1edc6f41(TIterator begin, const TIterator end)
{
this->reset();

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

@ -211,7 +211,7 @@ namespace etl
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template<typename TIterator>
crc64_poly_0x42f0e1eba9ea3693(TIterator begin, const TIterator end)
{
this->reset();

10
include/etl/private/minmax_pop.h
View File

@ -32,7 +32,11 @@ SOFTWARE.
* The header include guard has been intentionally omitted.
* This file is intended to evaluated multiple times by design.
*/
#pragma pop_macro("min")
#pragma pop_macro("max")
#if !defined(ETL_COMPILER_ARM5)
#pragma pop_macro("min")
#pragma pop_macro("max")
#else
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)<(b)?(b):(a))
#endif

2
include/etl/private/minmax_push.h
View File

@ -33,7 +33,9 @@ SOFTWARE.
* This file is intended to evaluated multiple times by design.
*/
#if !defined(ETL_COMPILER_ARM5)
#pragma push_macro("min")
#pragma push_macro("max")
#endif
#undef min
#undef max

2
include/etl/reference_flat_map.h
View File

@ -939,7 +939,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
reference_flat_map(TIterator first, TIterator last)
: ireference_flat_map<TKey, TValue, TCompare>(lookup)
{

2
include/etl/reference_flat_multimap.h
View File

@ -851,7 +851,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
reference_flat_multimap(TIterator first, TIterator last)
: ireference_flat_multimap<TKey, TValue, TCompare>(lookup)
{

2
include/etl/reference_flat_set.h
View File

@ -816,7 +816,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
reference_flat_set(TIterator first, TIterator last)
: ireference_flat_set<TKey, TKeyCompare>(lookup)
{

2
include/etl/set.h
View File

@ -2149,7 +2149,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
set(TIterator first, TIterator last)
: etl::iset<TKey, TCompare>(node_pool, MAX_SIZE)
{

8
include/etl/string.h
View File

@ -147,8 +147,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
string(TIterator first, TIterator last)
template <typename TIterator>
string(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: istring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(first, last);
@ -353,8 +353,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size)
template <typename TIterator>
string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: istring(buffer, buffer_size - 1U)
{
this->assign(first, last);

4
include/etl/string_view.h
View File

@ -305,8 +305,8 @@ namespace etl
//*************************************************************************
/// Assign from iterators
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
void assign(TIterator begin_, TIterator end_)
template <typename TIterator>
void assign(TIterator begin_, TIterator end_, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
{
mbegin = etl::addressof(*begin_);
mend = etl::addressof(*begin_) + etl::distance(begin_, end_);

8
include/etl/u16string.h
View File

@ -145,8 +145,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
u16string(TIterator first, TIterator last)
template <typename TIterator>
u16string(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(first, last);
@ -336,8 +336,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
u16string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size)
template <typename TIterator>
u16string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iu16string(buffer, buffer_size - 1U)
{
this->assign(first, last);

8
include/etl/u32string.h
View File

@ -145,8 +145,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
u32string(TIterator first, TIterator last)
template <typename TIterator>
u32string(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iu32string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(first, last);
@ -336,8 +336,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
u32string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size)
template <typename TIterator>
u32string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iu32string(buffer, buffer_size - 1U)
{
this->assign(first, last);

2
include/etl/unordered_map.h
View File

@ -1581,7 +1581,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
unordered_map(TIterator first_, TIterator last_)
: base(node_pool, buckets, MAX_BUCKETS_)
{

2
include/etl/unordered_multimap.h
View File

@ -1492,7 +1492,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
unordered_multimap(TIterator first_, TIterator last_)
: base(node_pool, buckets, MAX_BUCKETS)
{

2
include/etl/unordered_multiset.h
View File

@ -1478,7 +1478,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
unordered_multiset(TIterator first_, TIterator last_)
: base(node_pool, buckets, MAX_BUCKETS)
{

2
include/etl/unordered_set.h
View File

@ -1476,7 +1476,7 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
template <typename TIterator>
unordered_set(TIterator first_, TIterator last_)
: base(node_pool, buckets, MAX_BUCKETS)
{

16
include/etl/vector.h
View File

@ -1193,8 +1193,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
vector(TIterator first, TIterator last)
template <typename TIterator>
vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->assign(first, last);
@ -1366,8 +1366,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size)
template <typename TIterator>
vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
this->assign(first, last);
@ -1528,8 +1528,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
vector(TIterator first, TIterator last)
template <typename TIterator>
vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
{
this->assign(first, last);
@ -1660,8 +1660,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size)
template <typename TIterator>
vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
{
this->assign(first, last);

2
include/etl/version.h
View File

@ -39,7 +39,7 @@ SOFTWARE.
#define ETL_VERSION_MAJOR 20
#define ETL_VERSION_MINOR 6
#define ETL_VERSION_PATCH 0
#define ETL_VERSION_PATCH 1
#define ETL_VERSION ETL_STRINGIFY(ETL_VERSION_MAJOR) "." ETL_STRINGIFY(ETL_VERSION_MINOR) "." ETL_STRINGIFY(ETL_VERSION_PATCH)
#define ETL_VERSION_W ETL_STRINGIFY(ETL_VERSION_MAJOR) L"." ETL_STRINGIFY(ETL_VERSION_MINOR) L"." ETL_STRINGIFY(ETL_VERSION_PATCH)
#define ETL_VERSION_U16 ETL_STRINGIFY(ETL_VERSION_MAJOR) u"." ETL_STRINGIFY(ETL_VERSION_MINOR) u"." ETL_STRINGIFY(ETL_VERSION_PATCH)

8
include/etl/wstring.h
View File

@ -145,8 +145,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
wstring(TIterator first, TIterator last)
template <typename TIterator>
wstring(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iwstring(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(first, last);
@ -336,8 +336,8 @@ namespace etl
///\param first The iterator to the first element.
///\param last The iterator to the last element + 1.
//*************************************************************************
template <typename TIterator, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0>
wstring_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size)
template <typename TIterator>
wstring_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iwstring(buffer, buffer_size - 1U)
{
this->assign(first, last);

2
library.json
View File

@ -1,6 +1,6 @@
{
"name": "ETL Embedded Template Library",
"version": "20.6.0",
"version": "20.6.1",
"author s": {
"name": "John Wellbelove",
"email": "john.wellbelove@etlcpp.com"

2
library.properties
View File

@ -1,5 +1,5 @@
name=Embedded Template Library ETL
version=20.6.0
version=20.6.1
author= John Wellbelove <john.wellbelove@etlcpp.com>
maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
license=MIT

6
support/Release notes.txt
View File

@ -1,3 +1,9 @@
===============================================================================
20.6.1
Added missing etl::atomic<bool> from gcc & clang implementations.
Changed nullptr to ETL_NULLPTR in buffer_descriptors and multi_range.
Fixed header includes in state_chart.h
===============================================================================
20.6.0
Added etl::message_router_registry.