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

Added Green Hills compiler to minmax push and pop

Browse Source 
message_packet updates

message_packet updates

span updates

message_packet updates

message_packet updates

Remove superfluous line

Fixe undefined behaviour in test
This commit is contained in:
John Wellbelove 2021-12-15 20:34:30 +00:00
parent a2d6cb4fc1
commit de5a90a91c
10 changed files with 2045 additions and 450 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

335
include/etl/generators/message_packet_generator.h
View File

@ -85,36 +85,74 @@ namespace etl
//********************************************
message_packet()
: valid(false)
: data()
, valid(false)
{
}
//********************************************
explicit message_packet(const etl::imessage& msg)
: valid(true)
: data()
{
add_new_message(msg);
if (accepts(msg))
{
add_new_message(msg);
valid = true;
}
else
{
valid = false;
}
ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
}
//********************************************
explicit message_packet(etl::imessage&& msg)
: valid(true)
: data()
{
add_new_message(etl::move(msg));
if (accepts(msg))
{
add_new_message(etl::move(msg));
valid = true;
}
else
{
valid = false;
}
ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
}
//********************************************
template <typename TMessage, etl::enable_if_t<!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::imessage> &&
!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::message_packet<TMessageTypes...>>, int> = 0>
template <typename TMessage, typename = etl::enable_if_t<!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::message_packet<TMessageTypes...>> &&
!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::imessage> &&
!etl::is_one_of_v<etl::remove_reference_t<TMessage>, TMessageTypes...>, int>>
explicit message_packet(TMessage&& msg)
: valid(true)
: data()
, valid(true)
{
// Not etl::message_packet, not etl::imessage and in typelist.
constexpr bool Enabled = (!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::message_packet<TMessageTypes...>> &&
!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::imessage> &&
etl::is_one_of_v<etl::remove_reference_t<TMessage>, TMessageTypes...>);
ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
}
//********************************************
template <typename TMessage, etl::enable_if_t<etl::is_one_of_v<etl::remove_reference_t<TMessage>, TMessageTypes...>, int>>
explicit message_packet(TMessage&& msg)
: data()
, valid(true)
{
add_new_message<TMessage>(etl::forward<TMessage>(msg));
}
//**********************************************
message_packet(const message_packet& other)
: valid(other.is_valid())
: data()
, valid(other.is_valid())
{
if (valid)
{
@ -124,7 +162,8 @@ namespace etl
//**********************************************
message_packet(message_packet&& other)
: valid(other.is_valid())
: data()
, valid(other.is_valid())
{
if (valid)
{
@ -204,7 +243,7 @@ namespace etl
//**********************************************
template <typename TMessage>
static ETL_CONSTEXPR
typename etl::enable_if<!etl::is_integral<TMessage>::value, bool>::type
typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type
accepts()
{
return accepts<TMessage::ID>();
@ -220,14 +259,14 @@ namespace etl
//**********************************************
template <etl::message_id_t Id1, etl::message_id_t Id2>
static ETL_CONSTEXPR bool accepts_message()
static bool accepts_message()
{
return Id1 == Id2;
}
//**********************************************
template <etl::message_id_t Id1>
static ETL_CONSTEXPR bool accepts_message(etl::message_id_t id2)
static bool accepts_message(etl::message_id_t id2)
{
return Id1 == id2;
}
@ -242,10 +281,7 @@ namespace etl
#if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
pmsg->~imessage();
#else
if (!(delete_current_message_type<TMessageTypes>(pmsg->get_message_id()) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
(delete_current_message_type<TMessageTypes>(pmsg->get_message_id()) || ...);
#endif
}
}
@ -253,29 +289,20 @@ namespace etl
//********************************************
void add_new_message(const etl::imessage& msg)
{
if (!(add_new_message_type<TMessageTypes>(msg) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
(add_new_message_type<TMessageTypes>(msg) || ...);
}
//********************************************
void add_new_message(etl::imessage&& msg)
{
if (!(add_new_message_type<TMessageTypes>(etl::move(msg)) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
(add_new_message_type<TMessageTypes>(etl::move(msg)) || ...);
}
//********************************************
template <typename TMessage, etl::enable_if_t<!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::imessage>, int> = 0>
template <typename TMessage, etl::enable_if_t<etl::is_one_of_v<etl::remove_reference_t<TMessage>, TMessageTypes...>, int>>
void add_new_message(TMessage&& msg)
{
if (!(add_new_message_type<TMessageTypes, etl::remove_reference_t<TMessage>::ID>(etl::forward<TMessage>(msg)) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
(add_new_message_type<TMessageTypes, etl::remove_reference_t<TMessage>::ID>(etl::forward<TMessage>(msg)) || ...);
}
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
@ -367,16 +394,75 @@ namespace etl
/*[[[cog
import cog
def accepts_return(num_id):
################################################
def generate_accepts_return(n):
cog.out(" return")
for i in range(1, num_id + 1):
for i in range(1, n + 1):
cog.out(" T%d::ID == id" % i)
if i < num_id:
if i < n:
cog.out(" ||")
if i % 4 == 0:
cog.outl("")
cog.out(" ")
cog.outl(";")
################################################
def generate_accepts_return_compile_time(n):
cog.out(" return")
for i in range(1, n + 1):
cog.out(" T%d::ID == Id" % i)
if i < n:
cog.out(" ||")
if i % 4 == 0:
cog.outl("")
cog.out(" ")
cog.outl(";")
################################################
def generate_accepts_return_compile_time_TMessage(n):
cog.outl(" ETL_CONSTANT etl::message_id_t id = TMessage::ID;")
cog.outl("")
cog.out(" return")
for i in range(1, n + 1):
cog.out(" T%d::ID == id" % i)
if i < n:
cog.out(" ||")
if i % 4 == 0:
cog.outl("")
cog.out(" ")
cog.outl(";")
################################################
def generate_static_assert_cpp03(n):
cog.outl(" // Not etl::message_packet, not etl::imessage and in typelist.")
cog.out(" static const bool Enabled = (!etl::is_same<typename etl::remove_reference<TMessage>::type, etl::message_packet<")
for i in range(1, n):
cog.out("T%d, " % i)
cog.outl("T%s> >::value &&" % n)
cog.outl(" !etl::is_same<typename etl::remove_reference<TMessage>::type, etl::imessage>::value &&")
cog.out(" etl::is_one_of<typename etl::remove_reference<TMessage>::type,")
for i in range(1, n):
cog.out("T%d, " % i)
cog.outl("T%s>::value);" % n)
cog.outl("")
cog.outl(" ETL_STATIC_ASSERT(Enabled, \"Message not in packet type list\");")
################################################
def generate_static_assert_cpp11(n):
cog.outl(" // Not etl::message_packet, not etl::imessage and in typelist.")
cog.out(" static constexpr bool Enabled = (!etl::is_same<typename etl::remove_reference<TMessage>::type, etl::message_packet<")
for i in range(1, n):
cog.out("T%d, " % i)
cog.outl("T%s> >::value &&" % n)
cog.outl(" !etl::is_same<typename etl::remove_reference<TMessage>::type, etl::imessage>::value &&")
cog.out(" etl::is_one_of<typename etl::remove_reference<TMessage>::type,")
for i in range(1, n):
cog.out("T%d, " % i)
cog.outl("T%s>::value);" % n)
cog.outl("")
cog.outl(" ETL_STATIC_ASSERT(Enabled, \"Message not in packet type list\");")
################################################
# The first definition for all of the messages.
################################################
@ -397,29 +483,87 @@ namespace etl
cog.outl("")
cog.outl(" //********************************************")
cog.outl(" message_packet()")
cog.outl(" : valid(false)")
cog.outl(" : data()")
cog.outl(" , valid(false)")
cog.outl(" {")
cog.outl(" }")
cog.outl("")
cog.outl(" //********************************************")
cog.outl(" explicit message_packet(const etl::imessage& msg)")
cog.outl(" : valid(true)")
cog.outl(" : data()")
cog.outl(" {")
cog.outl(" add_new_message(msg);")
cog.outl(" if (accepts(msg))")
cog.outl(" {")
cog.outl(" add_new_message(msg);")
cog.outl(" valid = true;")
cog.outl(" }")
cog.outl(" else")
cog.outl(" {")
cog.outl(" valid = false;")
cog.outl(" }")
cog.outl("")
cog.outl(" ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //********************************************")
cog.outl(" explicit message_packet(etl::imessage&& msg)")
cog.outl(" : valid(true)")
cog.outl(" : data()")
cog.outl(" {")
cog.outl(" add_new_message(etl::move(msg));")
cog.outl(" if (accepts(msg))")
cog.outl(" {")
cog.outl(" add_new_message(etl::move(msg));")
cog.outl(" valid = true;")
cog.outl(" }")
cog.outl(" else")
cog.outl(" {")
cog.outl(" valid = false;")
cog.outl(" }")
cog.outl("")
cog.outl(" ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
cog.outl(" }")
cog.outl("#endif")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //********************************************")
cog.out(" template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_reference<TMessage>::type, etl::message_packet<")
for n in range(1, int(Handlers)):
cog.out("T%s, " % n)
cog.outl("T%s> >::value &&" % int(Handlers))
cog.outl(" !etl::is_same<typename etl::remove_reference<TMessage>::type, etl::imessage>::value &&")
cog.out(" !etl::is_one_of<typename etl::remove_reference<TMessage>::type, ")
for n in range(1, int(Handlers)):
cog.out("T%s, " % n)
cog.outl("T%s>::value, int>::type>" % int(Handlers))
cog.outl(" explicit message_packet(TMessage&& msg)")
cog.outl(" : data()")
cog.outl(" , valid(true)")
cog.outl(" {")
generate_static_assert_cpp11(int(Handlers))
cog.outl(" }")
cog.outl("#else")
cog.outl(" //********************************************")
cog.outl(" template <typename TMessage>")
cog.out(" explicit message_packet(const TMessage& msg, typename etl::enable_if<!etl::is_same<typename etl::remove_reference<TMessage>::type, etl::message_packet<")
for n in range(1, int(Handlers)):
cog.out("T%s, " % n)
cog.outl("T%s> >::value &&" % int(Handlers))
cog.outl(" !etl::is_same<typename etl::remove_reference<TMessage>::type, etl::imessage>::value &&")
cog.out(" !etl::is_one_of<typename etl::remove_reference<TMessage>::type, ")
for n in range(1, int(Handlers)):
cog.out("T%s, " % n)
cog.outl("T%s>::value, int>::type = 0)" % int(Handlers))
cog.outl(" : data()")
cog.outl(" , valid(true)")
cog.outl(" {")
generate_static_assert_cpp03(int(Handlers))
cog.outl(" }")
cog.outl("#endif")
cog.outl("")
cog.outl(" //**********************************************")
cog.outl(" message_packet(const message_packet& other)")
cog.outl(" : valid(other.is_valid())")
cog.outl(" : data()")
cog.outl(" , valid(other.is_valid())")
cog.outl(" {")
cog.outl(" if (valid)")
cog.outl(" {")
@ -427,10 +571,11 @@ namespace etl
cog.outl(" }")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //**********************************************")
cog.outl(" message_packet(message_packet&& other)")
cog.outl(" : valid(other.is_valid())")
cog.outl(" : data()")
cog.outl(" , valid(other.is_valid())")
cog.outl(" {")
cog.outl(" if (valid)")
cog.outl(" {")
@ -452,7 +597,7 @@ namespace etl
cog.outl(" return *this;")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //**********************************************")
cog.outl(" message_packet& operator =(message_packet&& rhs)")
cog.outl(" {")
@ -494,7 +639,7 @@ namespace etl
cog.outl(" //**********************************************")
cog.outl(" static ETL_CONSTEXPR bool accepts(etl::message_id_t id)")
cog.outl(" {")
accepts_return(int(Handlers))
generate_accepts_return(int(Handlers))
cog.outl(" }")
cog.outl("")
cog.outl(" //**********************************************")
@ -507,16 +652,16 @@ namespace etl
cog.outl(" template <etl::message_id_t Id>")
cog.outl(" static ETL_CONSTEXPR bool accepts()")
cog.outl(" {")
cog.outl(" return accepts(Id);")
generate_accepts_return_compile_time(int(Handlers))
cog.outl(" }")
cog.outl("")
cog.outl(" //**********************************************")
cog.outl(" template <typename TMessage>")
cog.outl(" static ETL_CONSTEXPR")
cog.outl(" typename etl::enable_if<!etl::is_integral<TMessage>::value, bool>::type")
cog.outl(" typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type")
cog.outl(" accepts()")
cog.outl(" {")
cog.outl(" return accepts(TMessage::ID);")
generate_accepts_return_compile_time_TMessage(int(Handlers))
cog.outl(" }")
cog.outl("")
cog.outl(" enum")
@ -569,7 +714,7 @@ namespace etl
cog.outl(" }")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //********************************************")
cog.outl(" void add_new_message(etl::imessage&& msg)")
cog.outl(" {")
@ -624,29 +769,88 @@ namespace etl
cog.outl("")
cog.outl(" //********************************************")
cog.outl(" message_packet()")
cog.outl(" : valid(false)")
cog.outl(" : data()")
cog.outl(" , valid(false)")
cog.outl(" {")
cog.outl(" }")
cog.outl("")
cog.outl(" //********************************************")
cog.outl(" explicit message_packet(const etl::imessage& msg)")
cog.outl(" : valid(true)")
cog.outl(" : data()")
cog.outl(" {")
cog.outl(" add_new_message(msg);")
cog.outl(" if (accepts(msg))")
cog.outl(" {")
cog.outl(" add_new_message(msg);")
cog.outl(" valid = true;")
cog.outl(" }")
cog.outl(" else")
cog.outl(" {")
cog.outl(" valid = false;")
cog.outl(" }")
cog.outl("")
cog.outl(" ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //********************************************")
cog.outl(" explicit message_packet(etl::imessage&& msg)")
cog.outl(" : valid(true)")
cog.outl(" : data()")
cog.outl(" {")
cog.outl(" add_new_message(etl::move(msg));")
cog.outl(" if (accepts(msg))")
cog.outl(" {")
cog.outl(" add_new_message(etl::move(msg));")
cog.outl(" valid = true;")
cog.outl(" }")
cog.outl(" else")
cog.outl(" {")
cog.outl(" valid = false;")
cog.outl(" }")
cog.outl("")
cog.outl(" ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));")
cog.outl(" }")
cog.outl("#endif")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //********************************************")
cog.out(" template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_reference<TMessage>::type, etl::message_packet<")
for t in range(1, n):
cog.out("T%s, " % t)
cog.outl("T%s> >::value &&" % n)
cog.outl(" !etl::is_same<typename etl::remove_reference<TMessage>::type, etl::imessage>::value &&")
cog.out(" !etl::is_one_of<typename etl::remove_reference<TMessage>::type, ")
for t in range(1, n):
cog.out("T%s, " % t)
cog.outl("T%s>::value, int>::type>" % n)
cog.outl(" explicit message_packet(etl::imessage&& msg)")
cog.outl(" : data()")
cog.outl(" , valid(true)")
cog.outl(" {")
generate_static_assert_cpp11(n)
cog.outl(" }")
cog.outl("#else")
cog.outl(" //********************************************")
cog.outl(" template <typename TMessage>")
cog.out(" explicit message_packet(const TMessage& msg, typename etl::enable_if<!etl::is_same<typename etl::remove_reference<TMessage>::type, etl::message_packet<")
for t in range(1, n):
cog.out("T%s, " % t)
cog.outl("T%s> >::value &&" % n)
cog.outl(" !etl::is_same<typename etl::remove_reference<TMessage>::type, etl::imessage>::value &&")
cog.out(" !etl::is_one_of<typename etl::remove_reference<TMessage>::type, ")
for t in range(1, n):
cog.out("T%s, " % t)
cog.outl("T%s>::value, int>::type = 0)" % n)
cog.outl(" : data()")
cog.outl(" , valid(true)")
cog.outl(" {")
generate_static_assert_cpp03(n)
cog.outl(" }")
cog.outl("#endif")
cog.outl("")
cog.outl("")
cog.outl(" //**********************************************")
cog.outl(" message_packet(const message_packet& other)")
cog.outl(" : valid(other.is_valid())")
cog.outl(" : data()")
cog.outl(" , valid(other.is_valid())")
cog.outl(" {")
cog.outl(" if (valid)")
cog.outl(" {")
@ -654,10 +858,11 @@ namespace etl
cog.outl(" }")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //**********************************************")
cog.outl(" message_packet(message_packet&& other)")
cog.outl(" : valid(other.is_valid())")
cog.outl(" : data()")
cog.outl(" , valid(other.is_valid())")
cog.outl(" {")
cog.outl(" if (valid)")
cog.outl(" {")
@ -679,7 +884,7 @@ namespace etl
cog.outl(" return *this;")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //**********************************************")
cog.outl(" message_packet& operator =(message_packet&& rhs)")
cog.outl(" {")
@ -721,7 +926,7 @@ namespace etl
cog.outl(" //**********************************************")
cog.outl(" static ETL_CONSTEXPR bool accepts(etl::message_id_t id)")
cog.outl(" {")
accepts_return(n)
generate_accepts_return(n)
cog.outl(" }")
cog.outl("")
cog.outl(" //**********************************************")
@ -734,16 +939,16 @@ namespace etl
cog.outl(" template <etl::message_id_t Id>")
cog.outl(" static ETL_CONSTEXPR bool accepts()")
cog.outl(" {")
cog.outl(" return accepts(Id);")
generate_accepts_return_compile_time(n)
cog.outl(" }")
cog.outl("")
cog.outl(" //**********************************************")
cog.outl(" template <typename TMessage>")
cog.outl(" static ETL_CONSTEXPR")
cog.outl(" typename etl::enable_if<!etl::is_integral<TMessage>::value, bool>::type")
cog.outl(" typename etl::enable_if<etl::is_base_of<etl::imessage, TMessage>::value, bool>::type")
cog.outl(" accepts()")
cog.outl(" {")
cog.outl(" return accepts(TMessage::ID);")
generate_accepts_return_compile_time_TMessage(n)
cog.outl(" }")
cog.outl("")
cog.outl(" enum")
@ -792,11 +997,11 @@ namespace etl
cog.outl(" {")
for t in range(1, n + 1):
cog.outl(" case T%d::ID: ::new (p) T%d(static_cast<const T%d&>(msg)); break;" %(t, t, t))
cog.outl(" default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;")
cog.outl(" default: break;")
cog.outl(" }")
cog.outl(" }")
cog.outl("")
cog.outl("#if ETL_CPP11_SUPPORTED")
cog.outl("#if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)")
cog.outl(" //********************************************")
cog.outl(" void add_new_message(etl::imessage&& msg)")
cog.outl(" {")
@ -807,7 +1012,7 @@ namespace etl
cog.outl(" {")
for t in range(1, n + 1):
cog.outl(" case T%d::ID: ::new (p) T%d(static_cast<T%d&&>(msg)); break;" %(t, t, t))
cog.outl(" default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;")
cog.outl(" default: break;")
cog.outl(" }")
cog.outl(" }")
cog.outl("#endif")

1602
include/etl/message_packet.h
View File

File diff suppressed because it is too large Load Diff

9
include/etl/platform.h
View File

@ -221,6 +221,15 @@ SOFTWARE.
#endif
#endif
// Determine if the ETL can use std::array
#if !defined(ETL_HAS_STD_ARRAY)
#if ETL_CPP11_SUPPORTED && ETL_USING_STL
#define ETL_HAS_STD_ARRAY 1
#else
#define ETL_HAS_STD_ARRAY 0
#endif
#endif
// Determine if the ETL should support atomics.
#if defined(ETL_NO_ATOMICS) || \
defined(ETL_TARGET_DEVICE_ARM_CORTEX_M0) || \

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

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

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

@ -32,10 +32,10 @@ SOFTWARE.
* The header include guard has been intentionally omitted.
* This file is intended to evaluated multiple times by design.
*/
#if !defined(ETL_COMPILER_ARM5)
#pragma push_macro("min")
#pragma push_macro("max")
#if !defined(ETL_COMPILER_ARM5) && !defined(ETL_COMPILER_GREEN_HILLS)
#pragma push_macro("min")
#pragma push_macro("max")
#endif
#undef min
#undef max

2
include/etl/reference_flat_map.h
View File

@ -538,8 +538,6 @@ namespace etl
{
const_iterator i_element = lower_bound(key);
bool b = keys_are_equal(1, 1);
ETL_ASSERT((i_element != end()) && keys_are_equal(i_element->first, key), ETL_ERROR(flat_map_out_of_bounds));
return i_element->second;

501
include/etl/span.h
View File

@ -48,9 +48,9 @@ namespace etl
static ETL_CONSTANT size_t dynamic_extent = etl::integral_limits<size_t>::max;
//***************************************************************************
/// Array view.
/// Span
//***************************************************************************
template <typename T, const size_t EXTENT = etl::dynamic_extent>
template <typename T, size_t EXTENT = etl::dynamic_extent>
class span
{
public:
@ -108,10 +108,11 @@ namespace etl
{
}
#if ETL_CPP11_SUPPORTED
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
template <typename U, size_t N>
template <typename U, size_t N, typename = typename etl::enable_if<N == EXTENT, void>::type>
ETL_CONSTEXPR span(etl::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
@ -121,18 +122,39 @@ namespace etl
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
template <typename U, size_t N>
template <typename U, size_t N, typename = typename etl::enable_if<N == EXTENT, void>::type>
ETL_CONSTEXPR span(const etl::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#else
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
template <typename U, size_t N>
ETL_CONSTEXPR span(etl::array<U, N>& a, typename etl::enable_if<N == EXTENT, void>::type) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
template <typename U, size_t N>
ETL_CONSTEXPR span(const etl::array<U, N>& a, typename etl::enable_if<N == EXTENT, void>::type) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#endif
#if ETL_CPP11_SUPPORTED && ETL_USING_STL
//*************************************************************************
/// Construct from std::array.
//*************************************************************************
template <typename U, size_t N>
template <typename U, size_t N, typename = typename etl::enable_if<N == EXTENT, void>::type>
ETL_CONSTEXPR span(std::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
@ -142,7 +164,7 @@ namespace etl
//*************************************************************************
/// Construct from std::array.
//*************************************************************************
template <typename U, size_t N>
template <typename U, size_t N, typename = typename etl::enable_if<N == EXTENT, void>::type>
ETL_CONSTEXPR span(const std::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
@ -150,52 +172,6 @@ namespace etl
}
#endif
#if ETL_CPP11_SUPPORTED
//*************************************************************************
/// Construct from a container or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TContainer, typename = typename etl::enable_if<!etl::is_array<TContainer>::value, int>::type>
ETL_CONSTEXPR span(TContainer& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
//*************************************************************************
/// Construct from a container or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TContainer, typename = typename etl::enable_if<!etl::is_array<TContainer>::value, int>::type>
ETL_CONSTEXPR span(const TContainer& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#else
//*************************************************************************
/// Construct from a container or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TContainer>
ETL_CONSTEXPR span(TContainer& a, typename etl::enable_if<!etl::is_array<TContainer>::value, int>::type = 0) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
//*************************************************************************
/// Construct from a container or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TContainer>
ETL_CONSTEXPR span(const TContainer& a, typename etl::enable_if<!etl::is_array<TContainer>::value, int>::type = 0) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#endif
//*************************************************************************
/// Copy constructor
//*************************************************************************
@ -314,7 +290,7 @@ namespace etl
//*************************************************************************
/// Obtains a span that is a view over the first COUNT elements of this span.
//*************************************************************************
template <const size_t COUNT>
template <size_t COUNT>
ETL_CONSTEXPR etl::span<element_type, COUNT> first() const
{
return etl::span<element_type, COUNT>(mbegin, mbegin + COUNT);
@ -331,7 +307,7 @@ namespace etl
//*************************************************************************
/// Obtains a span that is a view over the last COUNT elements of this span.
//*************************************************************************
template <const size_t COUNT>
template <size_t COUNT>
ETL_CONSTEXPR etl::span<element_type, COUNT> last() const
{
return etl::span<element_type, COUNT>(mend - COUNT, mend);
@ -348,50 +324,383 @@ namespace etl
#if ETL_CPP11_SUPPORTED
//*************************************************************************
/// Obtains a span that is a view from OFFSET over the next COUNT elements of this span.
/// Enabled for COUNT == etl::dynamic_extent
//*************************************************************************
template <const size_t OFFSET, const size_t COUNT = etl::dynamic_extent>
ETL_CONSTEXPR
typename etl::enable_if<COUNT == etl::dynamic_extent, etl::span<element_type, ((EXTENT != etl::dynamic_extent) ? EXTENT - OFFSET : etl::dynamic_extent)> >::type
subspan() const
template <const size_t OFFSET, size_t COUNT = etl::dynamic_extent>
ETL_CONSTEXPR
etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : (EXTENT != etl::dynamic_extent ? EXTENT - OFFSET : etl::dynamic_extent))> subspan() const
{
return etl::span<element_type, ((EXTENT != etl::dynamic_extent) ? EXTENT - OFFSET : etl::dynamic_extent)>(mbegin + OFFSET, mend);
}
//*************************************************************************
/// Obtains a span that is a view from OFFSET over the next COUNT elements of this span.
/// Enabled for COUNT != etl::dynamic_extent
//*************************************************************************
template <const size_t OFFSET, const size_t COUNT = etl::dynamic_extent>
ETL_CONSTEXPR
typename etl::enable_if<COUNT != etl::dynamic_extent, etl::span<element_type, COUNT> >::type
subspan() const
{
return etl::span<element_type, COUNT>(mbegin + OFFSET, mbegin + OFFSET + COUNT);
if (COUNT == etl::dynamic_extent)
{
return etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : (EXTENT != etl::dynamic_extent ? EXTENT - OFFSET : etl::dynamic_extent))>(mbegin + OFFSET, mend);
}
else
{
return etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : (EXTENT != etl::dynamic_extent ? EXTENT - OFFSET : etl::dynamic_extent))>(mbegin + OFFSET, mbegin + OFFSET + COUNT);
}
}
#else
//*************************************************************************
/// Obtains a span that is a view from OFFSET over the next COUNT elements of this span.
/// Enabled for COUNT == etl::dynamic_extent
//*************************************************************************
template <const size_t OFFSET, const size_t COUNT>
ETL_CONSTEXPR
typename etl::enable_if<COUNT == etl::dynamic_extent, etl::span<element_type, ((EXTENT != etl::dynamic_extent) ? EXTENT - OFFSET : etl::dynamic_extent)> >::type
subspan() const
template <const size_t OFFSET, size_t COUNT>
ETL_CONSTEXPR
etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : (EXTENT != etl::dynamic_extent ? EXTENT - OFFSET : etl::dynamic_extent))> subspan() const
{
if (COUNT == etl::dynamic_extent)
{
return etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : (EXTENT != etl::dynamic_extent ? EXTENT - OFFSET : etl::dynamic_extent))>(mbegin + OFFSET, mend);
}
else
{
return etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : (EXTENT != etl::dynamic_extent ? EXTENT - OFFSET : etl::dynamic_extent))>(mbegin + OFFSET, mbegin + OFFSET + COUNT);
}
}
#endif
//*************************************************************************
/// Obtains a span that is a view from 'offset' over the next 'count' elements of this span.
//*************************************************************************
ETL_CONSTEXPR14 etl::span<element_type, etl::dynamic_extent> subspan(size_t offset, size_t count = etl::dynamic_extent) const
{
if (count == etl::dynamic_extent)
{
return etl::span<element_type, etl::dynamic_extent>(mbegin + offset, mend);
}
else
{
return etl::span<element_type, etl::dynamic_extent>(mbegin + offset, mbegin + offset + count);
}
}
private:
element_type* mbegin;
element_type* mend;
};
//***************************************************************************
/// Span specialisation
//***************************************************************************
template <typename T>
class span<T, etl::dynamic_extent>
{
public:
typedef T element_type;
typedef typename etl::remove_cv<T>::type value_type;
typedef size_t size_type;
typedef T& reference;
typedef const T& const_reference;
typedef T* pointer;
typedef const T* const_pointer;
typedef T* iterator;
typedef const T* const_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
static ETL_CONSTANT size_t extent = etl::dynamic_extent;
//*************************************************************************
/// Default constructor.
//*************************************************************************
ETL_CONSTEXPR span() ETL_NOEXCEPT
: mbegin(ETL_NULLPTR)
, mend(ETL_NULLPTR)
{
return etl::span<element_type, ((EXTENT != etl::dynamic_extent) ? EXTENT - OFFSET : etl::dynamic_extent)>(mbegin + OFFSET, mend);
}
//*************************************************************************
/// Obtains a span that is a view from OFFSET over the next COUNT elements of this span.
/// Enabled for COUNT != etl::dynamic_extent
/// Construct from pointer + size
//*************************************************************************
template <const size_t OFFSET, const size_t COUNT>
ETL_CONSTEXPR
typename etl::enable_if<COUNT != etl::dynamic_extent, etl::span<element_type, COUNT> >::type
subspan() const
template <typename TIterator, typename TSize>
ETL_CONSTEXPR span(const TIterator begin_, const TSize size_) ETL_NOEXCEPT
: mbegin(etl::addressof(*begin_))
, mend(etl::addressof(*begin_) + size_)
{
return etl::span<element_type, COUNT>(mbegin + OFFSET, mbegin + OFFSET + COUNT);
}
//*************************************************************************
/// Construct from iterators
//*************************************************************************
template <typename TIterator>
ETL_CONSTEXPR span(const TIterator begin_, const TIterator end_)
: mbegin(etl::addressof(*begin_))
, mend(etl::addressof(*begin_) + etl::distance(begin_, end_))
{
}
//*************************************************************************
/// Construct from C array
//*************************************************************************
template<size_t ARRAY_SIZE>
ETL_CONSTEXPR span(element_type(&begin_)[ARRAY_SIZE]) ETL_NOEXCEPT
: mbegin(begin_)
, mend(begin_ + ARRAY_SIZE)
{
}
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
template <typename U, size_t N>
ETL_CONSTEXPR span(etl::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
//*************************************************************************
/// Construct from etl::array.
//*************************************************************************
template <typename U, size_t N>
ETL_CONSTEXPR span(const etl::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#if ETL_CPP11_SUPPORTED && ETL_USING_STL
//*************************************************************************
/// Construct from std::array.
//*************************************************************************
template <typename U, size_t N>
ETL_CONSTEXPR span(std::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
//*************************************************************************
/// Construct from std::array.
//*************************************************************************
template <typename U, size_t N>
ETL_CONSTEXPR span(const std::array<U, N>& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#endif
#if ETL_CPP11_SUPPORTED
//*************************************************************************
/// Construct from a container or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TContainer, typename = typename etl::enable_if<!etl::is_pointer<etl::remove_reference_t<TContainer>>::value &&
!etl::is_array<etl::remove_reference_t<TContainer>>::value, int>::type>
ETL_CONSTEXPR span(TContainer&& a) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#else
//*************************************************************************
/// Construct from a container or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TContainer>
ETL_CONSTEXPR span(TContainer& a, typename etl::enable_if<!etl::is_pointer<typename etl::remove_reference<TContainer>::type>::value &&
!etl::is_array<TContainer>::value, int>::type = 0) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
//*************************************************************************
/// Construct from a container or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TContainer>
ETL_CONSTEXPR span(const TContainer& a, typename etl::enable_if<!etl::is_pointer<typename etl::remove_reference<TContainer>::type>::value &&
!etl::is_array<TContainer>::value, int>::type = 0) ETL_NOEXCEPT
: mbegin(a.data())
, mend(a.data() + a.size())
{
}
#endif
//*************************************************************************
/// Copy constructor
//*************************************************************************
ETL_CONSTEXPR span(const span& other) ETL_NOEXCEPT
: mbegin(other.mbegin)
, mend(other.mend)
{
}
//*************************************************************************
/// Returns a reference to the first element.
//*************************************************************************
ETL_CONSTEXPR reference front() const ETL_NOEXCEPT
{
return *mbegin;
}
//*************************************************************************
/// Returns a reference to the last element.
//*************************************************************************
ETL_CONSTEXPR reference back() const ETL_NOEXCEPT
{
return *(mend - 1);
}
//*************************************************************************
/// Returns a pointer to the first element of the internal storage.
//*************************************************************************
ETL_CONSTEXPR pointer data() const ETL_NOEXCEPT
{
return mbegin;
}
//*************************************************************************
/// Returns an iterator to the beginning of the span.
//*************************************************************************
ETL_CONSTEXPR iterator begin() const ETL_NOEXCEPT
{
return mbegin;
}
//*************************************************************************
/// Returns an iterator to the end of the span.
//*************************************************************************
ETL_CONSTEXPR iterator end() const ETL_NOEXCEPT
{
return mend;
}
//*************************************************************************
// Returns an reverse iterator to the reverse beginning of the span.
//*************************************************************************
ETL_CONSTEXPR reverse_iterator rbegin() const ETL_NOEXCEPT
{
return reverse_iterator(mend);
}
//*************************************************************************
/// Returns a reverse iterator to the end of the span.
//*************************************************************************
ETL_CONSTEXPR reverse_iterator rend() const ETL_NOEXCEPT
{
return reverse_iterator(mbegin);
}
//*************************************************************************
/// Returns <b>true</b> if the span size is zero.
//*************************************************************************
ETL_CONSTEXPR bool empty() const ETL_NOEXCEPT
{
return (mbegin == mend);
}
//*************************************************************************
/// Returns the size of the span.
//*************************************************************************
ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
{
return (mend - mbegin);
}
//*************************************************************************
/// Returns the size of the span in bytes.
//*************************************************************************
ETL_CONSTEXPR size_t size_bytes() const ETL_NOEXCEPT
{
return sizeof(element_type) * (mend - mbegin);
}
//*************************************************************************
/// Returns the maximum possible size of the span.
//*************************************************************************
ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
{
return size();
}
//*************************************************************************
/// Assign from a span.
//*************************************************************************
ETL_CONSTEXPR14 span& operator =(const span& other) ETL_NOEXCEPT
{
mbegin = other.mbegin;
mend = other.mend;
return *this;
}
//*************************************************************************
/// Returns a reference to the indexed value.
//*************************************************************************
ETL_CONSTEXPR reference operator[](const size_t i) const
{
return mbegin[i];
}
//*************************************************************************
/// Obtains a span that is a view over the first COUNT elements of this span.
//*************************************************************************
template <size_t COUNT>
ETL_CONSTEXPR etl::span<element_type, COUNT> first() const
{
return etl::span<element_type, COUNT>(mbegin, mbegin + COUNT);
}
//*************************************************************************
/// Obtains a span that is a view over the first count elements of this span.
//*************************************************************************
ETL_CONSTEXPR etl::span<element_type, etl::dynamic_extent> first(size_t count) const
{
return etl::span<element_type, etl::dynamic_extent>(mbegin, mbegin + count);
}
//*************************************************************************
/// Obtains a span that is a view over the last COUNT elements of this span.
//*************************************************************************
template <size_t COUNT>
ETL_CONSTEXPR etl::span<element_type, COUNT> last() const
{
return etl::span<element_type, COUNT>(mend - COUNT, mend);
}
//*************************************************************************
/// Obtains a span that is a view over the last count elements of this span.
//*************************************************************************
ETL_CONSTEXPR etl::span<element_type, etl::dynamic_extent> last(size_t count) const
{
return etl::span<element_type, etl::dynamic_extent>(mend - count, mend);
}
#if ETL_CPP11_SUPPORTED
//*************************************************************************
/// Obtains a span that is a view from OFFSET over the next COUNT elements of this span.
//*************************************************************************
template <const size_t OFFSET, size_t COUNT = etl::dynamic_extent>
ETL_CONSTEXPR
etl::span<element_type, COUNT> subspan() const
{
if (COUNT == etl::dynamic_extent)
{
return etl::span<element_type, COUNT>(mbegin + OFFSET, mend);
}
else
{
return etl::span<element_type, COUNT>(mbegin + OFFSET, mbegin + OFFSET + COUNT);
}
}
#else
//*************************************************************************
/// Obtains a span that is a view from OFFSET over the next COUNT elements of this span.
//*************************************************************************
template <const size_t OFFSET, size_t COUNT>
ETL_CONSTEXPR
etl::span<element_type, (COUNT != etl::dynamic_extent ? COUNT : etl::dynamic_extent)> subspan() const
{
if (COUNT == etl::dynamic_extent)
{
return etl::span<element_type, COUNT>(mbegin + OFFSET, mend);
}
else
{
return etl::span<element_type, COUNT>(mbegin + OFFSET, mbegin + OFFSET + COUNT);
}
}
#endif
@ -419,16 +728,27 @@ namespace etl
#if ETL_CPP17_SUPPORTED
template <typename TArray>
span(TArray& a)
->span<typename TArray::value_type>;
->span<typename TArray::value_type, etl::dynamic_extent>;
template <typename TIterator>
span(const TIterator begin_, const TIterator end_)
->span<etl::remove_pointer_t<TIterator>>;
->span<etl::remove_pointer_t<TIterator>, etl::dynamic_extent>;
template <typename TIterator,
typename TSize>
template <typename TIterator, typename TSize>
span(const TIterator begin_, const TSize size_)
->span<etl::remove_pointer_t<TIterator>>;
->span<etl::remove_pointer_t<TIterator>, etl::dynamic_extent>;
//template <typename TArray, size_t EXTENT>
//span(TArray& a)
// ->span<typename TArray::value_type, EXTENT>;
//template <typename TIterator, size_t EXTENT>
//span(const TIterator begin_, const TIterator end_)
// ->span<etl::remove_pointer_t<TIterator>, EXTENT>;
//template <typename TIterator, typename TSize, size_t EXTENT>
// span(const TIterator begin_, const TSize size_)
// ->span<etl::remove_pointer_t<TIterator>, EXTENT>;
#endif
//*************************************************************************
@ -448,4 +768,3 @@ namespace etl
}
#endif

9
test/test_message_packet.cpp
View File

@ -197,6 +197,9 @@ namespace
Packet packet2(message2);
Packet packet3(message3);
// Should causes a static assert.
//Packet packet4(message4);
CHECK_EQUAL(MESSAGE1, packet1.get().get_message_id());
CHECK_EQUAL(MESSAGE2, packet2.get().get_message_id());
CHECK_EQUAL(MESSAGE3, packet3.get().get_message_id());
@ -214,6 +217,7 @@ namespace
CHECK_EQUAL("3", static_cast<Message3&>(packet3.get()).x);
}
#if !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
TEST(message_packet_move_construction)
{
@ -235,6 +239,7 @@ namespace
CHECK_EQUAL(1, static_cast<Message1&>(packet1.get()).x);
CHECK_EQUAL(2.2, static_cast<Message2&>(packet2.get()).x);
}
#endif
//*************************************************************************
TEST(message_constant_packet_construction)
@ -302,6 +307,7 @@ namespace
CHECK_EQUAL(1, static_cast<Message1&>(packet2.get()).x);
}
#if !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
TEST(message_packet_move_consructor)
{
@ -323,6 +329,7 @@ namespace
CHECK_EQUAL(1, static_cast<Message1&>(packet1.get()).x);
CHECK_EQUAL(1, static_cast<Message1&>(packet2.get()).x);
}
#endif
//*************************************************************************
TEST(message_packet_assignment)
@ -348,6 +355,7 @@ namespace
CHECK_EQUAL(1, static_cast<Message1&>(packet2.get()).x);
}
#if !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
TEST(message_packet_move_assignment)
{
@ -371,6 +379,7 @@ namespace
CHECK_EQUAL(1, static_cast<Message1&>(packet1.get()).x);
CHECK_EQUAL(1, static_cast<Message1&>(packet2.get()).x);
}
#endif
//*************************************************************************
TEST(message_packet_accepts)

6
test/test_multi_vector.cpp
View File

@ -358,6 +358,8 @@ namespace
Data data;
CHECK(data.empty());
data.resize(1);
CHECK(data[0].empty());
}
@ -367,6 +369,9 @@ namespace
Data data;
CHECK_EQUAL(0, data.size());
data.resize(1);
CHECK_EQUAL(1, data.size());
CHECK_EQUAL(0, data[0].size());
}
@ -374,7 +379,6 @@ namespace
TEST(test_max_size)
{
Data data;
data.resize(1);
CHECK_EQUAL(SIZE1, data.max_size());

21
test/test_span.cpp
View File

@ -631,14 +631,31 @@ namespace
}
//*************************************************************************
void f(etl::span<const char, 10> value)
void f_issue_481(etl::span<const char, 10> value)
{
}
TEST(test_issue_481)
{
// Should compile.
char c[10];
f(c);
f_issue_481(c);
}
//*************************************************************************
void f_issue_486(etl::span<const char, 11> value)
{
}
TEST(test_issue_486)
{
//std::array<char, 10> c;
// Should not compile.
//etl::span<char, 11> value(c);
// Should not compile.
//f_issue_486(c);
}
};
}