From de5a90a91c1c14434e26c52a3a7ebc7df7abba7a Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Wed, 15 Dec 2021 20:34:30 +0000 Subject: [PATCH] Added Green Hills compiler to minmax push and pop message_packet updates message_packet updates span updates message_packet updates message_packet updates Remove superfluous line Fixe undefined behaviour in test --- .../etl/generators/message_packet_generator.h | 335 +++- include/etl/message_packet.h | 1602 ++++++++++++++--- include/etl/platform.h | 9 + include/etl/private/minmax_pop.h | 2 +- include/etl/private/minmax_push.h | 8 +- include/etl/reference_flat_map.h | 2 - include/etl/span.h | 501 +++++- test/test_message_packet.cpp | 9 + test/test_multi_vector.cpp | 6 +- test/test_span.cpp | 21 +- 10 files changed, 2045 insertions(+), 450 deletions(-) diff --git a/include/etl/generators/message_packet_generator.h b/include/etl/generators/message_packet_generator.h index 1524e8f6..1e43f58b 100644 --- a/include/etl/generators/message_packet_generator.h +++ b/include/etl/generators/message_packet_generator.h @@ -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 , etl::imessage> && - !etl::is_same_v, etl::message_packet>, int> = 0> + template , etl::message_packet> && + !etl::is_same_v, etl::imessage> && + !etl::is_one_of_v, 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::message_packet> && + !etl::is_same_v, etl::imessage> && + etl::is_one_of_v, TMessageTypes...>); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + + //******************************************** + template , TMessageTypes...>, int>> + explicit message_packet(TMessage&& msg) + : data() + , valid(true) { add_new_message(etl::forward(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 static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { return accepts(); @@ -220,14 +259,14 @@ namespace etl //********************************************** template - static ETL_CONSTEXPR bool accepts_message() + static bool accepts_message() { return Id1 == Id2; } //********************************************** template - 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(pmsg->get_message_id()) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (delete_current_message_type(pmsg->get_message_id()) || ...); #endif } } @@ -253,29 +289,20 @@ namespace etl //******************************************** void add_new_message(const etl::imessage& msg) { - if (!(add_new_message_type(msg) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (add_new_message_type(msg) || ...); } //******************************************** void add_new_message(etl::imessage&& msg) { - if (!(add_new_message_type(etl::move(msg)) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (add_new_message_type(etl::move(msg)) || ...); } //******************************************** - template , etl::imessage>, int> = 0> + template , TMessageTypes...>, int>> void add_new_message(TMessage&& msg) { - if (!(add_new_message_type::ID>(etl::forward(msg)) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (add_new_message_type::ID>(etl::forward(msg)) || ...); } typename etl::aligned_storage::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::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::type, etl::imessage>::value &&") + cog.out(" etl::is_one_of::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::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::type, etl::imessage>::value &&") + cog.out(" etl::is_one_of::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 ::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::type, etl::imessage>::value &&") + cog.out(" !etl::is_one_of::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 ") + cog.out(" explicit message_packet(const TMessage& msg, typename etl::enable_if::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::type, etl::imessage>::value &&") + cog.out(" !etl::is_one_of::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 ") 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 ") cog.outl(" static ETL_CONSTEXPR") - cog.outl(" typename etl::enable_if::value, bool>::type") + cog.outl(" typename etl::enable_if::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 ::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::type, etl::imessage>::value &&") + cog.out(" !etl::is_one_of::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 ") + cog.out(" explicit message_packet(const TMessage& msg, typename etl::enable_if::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::type, etl::imessage>::value &&") + cog.out(" !etl::is_one_of::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 ") 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 ") cog.outl(" static ETL_CONSTEXPR") - cog.outl(" typename etl::enable_if::value, bool>::type") + cog.outl(" typename etl::enable_if::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(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(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") diff --git a/include/etl/message_packet.h b/include/etl/message_packet.h index b3e3f527..39c3eb17 100644 --- a/include/etl/message_packet.h +++ b/include/etl/message_packet.h @@ -73,36 +73,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 , etl::imessage> && - !etl::is_same_v, etl::message_packet>, int> = 0> + template , etl::message_packet> && + !etl::is_same_v, etl::imessage> && + !etl::is_one_of_v, 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::message_packet> && + !etl::is_same_v, etl::imessage> && + etl::is_one_of_v, TMessageTypes...>); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + + //******************************************** + template , TMessageTypes...>, int>> + explicit message_packet(TMessage&& msg) + : data() + , valid(true) { add_new_message(etl::forward(msg)); } //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -112,7 +150,8 @@ namespace etl //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -192,7 +231,7 @@ namespace etl //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { return accepts(); @@ -208,14 +247,14 @@ namespace etl //********************************************** template - static ETL_CONSTEXPR bool accepts_message() + static bool accepts_message() { return Id1 == Id2; } //********************************************** template - static ETL_CONSTEXPR bool accepts_message(etl::message_id_t id2) + static bool accepts_message(etl::message_id_t id2) { return Id1 == id2; } @@ -230,10 +269,7 @@ namespace etl #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES) pmsg->~imessage(); #else - if (!(delete_current_message_type(pmsg->get_message_id()) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (delete_current_message_type(pmsg->get_message_id()) || ...); #endif } } @@ -241,29 +277,20 @@ namespace etl //******************************************** void add_new_message(const etl::imessage& msg) { - if (!(add_new_message_type(msg) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (add_new_message_type(msg) || ...); } //******************************************** void add_new_message(etl::imessage&& msg) { - if (!(add_new_message_type(etl::move(msg)) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (add_new_message_type(etl::move(msg)) || ...); } //******************************************** - template , etl::imessage>, int> = 0> + template , TMessageTypes...>, int>> void add_new_message(TMessage&& msg) { - if (!(add_new_message_type::ID>(etl::forward(msg)) || ...)) - { - ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception)); - } + (add_new_message_type::ID>(etl::forward(msg)) || ...); } typename etl::aligned_storage::type data; @@ -366,29 +393,85 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); + } + #endif + + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type> + explicit message_packet(TMessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); } #endif //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -396,10 +479,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -421,7 +505,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -479,16 +563,24 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id || + T13::ID == Id || T14::ID == Id || T15::ID == Id || T16::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || + T13::ID == id || T14::ID == id || T15::ID == id || T16::ID == id; } enum @@ -563,7 +655,7 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -610,29 +702,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -640,10 +789,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -665,7 +815,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -723,16 +873,24 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id || + T13::ID == Id || T14::ID == Id || T15::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || + T13::ID == id || T14::ID == id || T15::ID == id; } enum @@ -801,11 +959,11 @@ namespace etl case T13::ID: ::new (p) T13(static_cast(msg)); break; case T14::ID: ::new (p) T14(static_cast(msg)); break; case T15::ID: ::new (p) T15(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -829,7 +987,7 @@ namespace etl case T13::ID: ::new (p) T13(static_cast(msg)); break; case T14::ID: ::new (p) T14(static_cast(msg)); break; case T15::ID: ::new (p) T15(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -851,29 +1009,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -881,10 +1096,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -906,7 +1122,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -964,16 +1180,24 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id || + T13::ID == Id || T14::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || + T13::ID == id || T14::ID == id; } enum @@ -1040,11 +1264,11 @@ namespace etl case T12::ID: ::new (p) T12(static_cast(msg)); break; case T13::ID: ::new (p) T13(static_cast(msg)); break; case T14::ID: ::new (p) T14(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -1067,7 +1291,7 @@ namespace etl case T12::ID: ::new (p) T12(static_cast(msg)); break; case T13::ID: ::new (p) T13(static_cast(msg)); break; case T14::ID: ::new (p) T14(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -1089,29 +1313,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1119,10 +1400,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1144,7 +1426,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -1202,16 +1484,24 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id || + T13::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id || + T13::ID == id; } enum @@ -1276,11 +1566,11 @@ namespace etl case T11::ID: ::new (p) T11(static_cast(msg)); break; case T12::ID: ::new (p) T12(static_cast(msg)); break; case T13::ID: ::new (p) T13(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -1302,7 +1592,7 @@ namespace etl case T11::ID: ::new (p) T11(static_cast(msg)); break; case T12::ID: ::new (p) T12(static_cast(msg)); break; case T13::ID: ::new (p) T13(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -1323,29 +1613,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1353,10 +1700,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1378,7 +1726,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -1435,16 +1783,22 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id; } enum @@ -1507,11 +1861,11 @@ namespace etl case T10::ID: ::new (p) T10(static_cast(msg)); break; case T11::ID: ::new (p) T11(static_cast(msg)); break; case T12::ID: ::new (p) T12(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -1532,7 +1886,7 @@ namespace etl case T10::ID: ::new (p) T10(static_cast(msg)); break; case T11::ID: ::new (p) T11(static_cast(msg)); break; case T12::ID: ::new (p) T12(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -1553,29 +1907,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1583,10 +1994,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1608,7 +2020,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -1665,16 +2077,22 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id || T10::ID == Id || T11::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id || T10::ID == id || T11::ID == id; } enum @@ -1735,11 +2153,11 @@ namespace etl case T9::ID: ::new (p) T9(static_cast(msg)); break; case T10::ID: ::new (p) T10(static_cast(msg)); break; case T11::ID: ::new (p) T11(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -1759,7 +2177,7 @@ namespace etl case T9::ID: ::new (p) T9(static_cast(msg)); break; case T10::ID: ::new (p) T10(static_cast(msg)); break; case T11::ID: ::new (p) T11(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -1780,29 +2198,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1810,10 +2285,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -1835,7 +2311,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -1892,16 +2368,22 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id || T10::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id || T10::ID == id; } enum @@ -1960,11 +2442,11 @@ namespace etl case T8::ID: ::new (p) T8(static_cast(msg)); break; case T9::ID: ::new (p) T9(static_cast(msg)); break; case T10::ID: ::new (p) T10(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -1983,7 +2465,7 @@ namespace etl case T8::ID: ::new (p) T8(static_cast(msg)); break; case T9::ID: ::new (p) T9(static_cast(msg)); break; case T10::ID: ::new (p) T10(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -2004,29 +2486,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8, T9>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2034,10 +2573,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2059,7 +2599,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -2116,16 +2656,22 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id || + T9::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id || + T9::ID == id; } enum @@ -2182,11 +2728,11 @@ namespace etl case T7::ID: ::new (p) T7(static_cast(msg)); break; case T8::ID: ::new (p) T8(static_cast(msg)); break; case T9::ID: ::new (p) T9(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -2204,7 +2750,7 @@ namespace etl case T7::ID: ::new (p) T7(static_cast(msg)); break; case T8::ID: ::new (p) T8(static_cast(msg)); break; case T9::ID: ::new (p) T9(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -2224,29 +2770,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7, T8>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2254,10 +2857,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2279,7 +2883,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -2335,16 +2939,20 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id; } enum @@ -2399,11 +3007,11 @@ namespace etl case T6::ID: ::new (p) T6(static_cast(msg)); break; case T7::ID: ::new (p) T7(static_cast(msg)); break; case T8::ID: ::new (p) T8(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -2420,7 +3028,7 @@ namespace etl case T6::ID: ::new (p) T6(static_cast(msg)); break; case T7::ID: ::new (p) T7(static_cast(msg)); break; case T8::ID: ::new (p) T8(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -2440,29 +3048,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6, T7>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2470,10 +3135,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2495,7 +3161,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -2551,16 +3217,20 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id || T7::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id || T7::ID == id; } enum @@ -2613,11 +3283,11 @@ namespace etl case T5::ID: ::new (p) T5(static_cast(msg)); break; case T6::ID: ::new (p) T6(static_cast(msg)); break; case T7::ID: ::new (p) T7(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -2633,7 +3303,7 @@ namespace etl case T5::ID: ::new (p) T5(static_cast(msg)); break; case T6::ID: ::new (p) T6(static_cast(msg)); break; case T7::ID: ::new (p) T7(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -2653,29 +3323,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5, T6>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5, T6>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2683,10 +3410,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2708,7 +3436,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -2764,16 +3492,20 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id || T6::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id || T6::ID == id; } enum @@ -2824,11 +3556,11 @@ namespace etl case T4::ID: ::new (p) T4(static_cast(msg)); break; case T5::ID: ::new (p) T5(static_cast(msg)); break; case T6::ID: ::new (p) T6(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -2843,7 +3575,7 @@ namespace etl case T4::ID: ::new (p) T4(static_cast(msg)); break; case T5::ID: ::new (p) T5(static_cast(msg)); break; case T6::ID: ::new (p) T6(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -2863,29 +3595,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4, T5>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4, T5>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2893,10 +3682,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -2918,7 +3708,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -2974,16 +3764,20 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id || + T5::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id || + T5::ID == id; } enum @@ -3032,11 +3826,11 @@ namespace etl case T3::ID: ::new (p) T3(static_cast(msg)); break; case T4::ID: ::new (p) T4(static_cast(msg)); break; case T5::ID: ::new (p) T5(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -3050,7 +3844,7 @@ namespace etl case T3::ID: ::new (p) T3(static_cast(msg)); break; case T4::ID: ::new (p) T4(static_cast(msg)); break; case T5::ID: ::new (p) T5(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -3069,29 +3863,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3, T4>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3, T4>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3099,10 +3950,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3124,7 +3976,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -3179,16 +4031,18 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id; } enum @@ -3235,11 +4089,11 @@ namespace etl case T2::ID: ::new (p) T2(static_cast(msg)); break; case T3::ID: ::new (p) T3(static_cast(msg)); break; case T4::ID: ::new (p) T4(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -3252,7 +4106,7 @@ namespace etl case T2::ID: ::new (p) T2(static_cast(msg)); break; case T3::ID: ::new (p) T3(static_cast(msg)); break; case T4::ID: ::new (p) T4(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -3271,29 +4125,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2, T3>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2, T3>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3301,10 +4212,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3326,7 +4238,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -3381,16 +4293,18 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id || T3::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id || T3::ID == id; } enum @@ -3435,11 +4349,11 @@ namespace etl case T1::ID: ::new (p) T1(static_cast(msg)); break; case T2::ID: ::new (p) T2(static_cast(msg)); break; case T3::ID: ::new (p) T3(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -3451,7 +4365,7 @@ namespace etl case T1::ID: ::new (p) T1(static_cast(msg)); break; case T2::ID: ::new (p) T2(static_cast(msg)); break; case T3::ID: ::new (p) T3(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -3470,29 +4384,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1, T2>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1, T2>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3500,10 +4471,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3525,7 +4497,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -3580,16 +4552,18 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id || T2::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id || T2::ID == id; } enum @@ -3632,11 +4606,11 @@ namespace etl { case T1::ID: ::new (p) T1(static_cast(msg)); break; case T2::ID: ::new (p) T2(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -3647,7 +4621,7 @@ namespace etl { case T1::ID: ::new (p) T1(static_cast(msg)); break; case T2::ID: ::new (p) T2(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif @@ -3666,29 +4640,86 @@ 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)); } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** 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)); } #endif + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) + //******************************************** + template ::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1>::value, int>::type> + explicit message_packet(etl::imessage&& msg) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static constexpr bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #else + //******************************************** + template + explicit message_packet(const TMessage& msg, typename etl::enable_if::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + !etl::is_one_of::type, T1>::value, int>::type = 0) + : data() + , valid(true) + { + // Not etl::message_packet, not etl::imessage and in typelist. + static const bool Enabled = (!etl::is_same::type, etl::message_packet >::value && + !etl::is_same::type, etl::imessage>::value && + etl::is_one_of::type,T1>::value); + + ETL_STATIC_ASSERT(Enabled, "Message not in packet type list"); + } + #endif + + //********************************************** message_packet(const message_packet& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3696,10 +4727,11 @@ namespace etl } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet(message_packet&& other) - : valid(other.is_valid()) + : data() + , valid(other.is_valid()) { if (valid) { @@ -3721,7 +4753,7 @@ namespace etl return *this; } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //********************************************** message_packet& operator =(message_packet&& rhs) { @@ -3776,16 +4808,18 @@ namespace etl template static ETL_CONSTEXPR bool accepts() { - return accepts(Id); + return T1::ID == Id; } //********************************************** template static ETL_CONSTEXPR - typename etl::enable_if::value, bool>::type + typename etl::enable_if::value, bool>::type accepts() { - return accepts(TMessage::ID); + ETL_CONSTANT etl::message_id_t id = TMessage::ID; + + return T1::ID == id; } enum @@ -3826,11 +4860,11 @@ namespace etl switch (id) { case T1::ID: ::new (p) T1(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } - #if ETL_CPP11_SUPPORTED + #if ETL_CPP11_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) //******************************************** void add_new_message(etl::imessage&& msg) { @@ -3840,7 +4874,7 @@ namespace etl switch (id) { case T1::ID: ::new (p) T1(static_cast(msg)); break; - default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break; + default: break; } } #endif diff --git a/include/etl/platform.h b/include/etl/platform.h index 4f62377a..a10225db 100644 --- a/include/etl/platform.h +++ b/include/etl/platform.h @@ -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) || \ diff --git a/include/etl/private/minmax_pop.h b/include/etl/private/minmax_pop.h index b989d79c..e25d0a93 100644 --- a/include/etl/private/minmax_pop.h +++ b/include/etl/private/minmax_pop.h @@ -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 diff --git a/include/etl/private/minmax_push.h b/include/etl/private/minmax_push.h index ee648aca..ef71439c 100644 --- a/include/etl/private/minmax_push.h +++ b/include/etl/private/minmax_push.h @@ -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 diff --git a/include/etl/reference_flat_map.h b/include/etl/reference_flat_map.h index fff66450..ab3105d5 100644 --- a/include/etl/reference_flat_map.h +++ b/include/etl/reference_flat_map.h @@ -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; diff --git a/include/etl/span.h b/include/etl/span.h index e8855c31..c6d43fc9 100644 --- a/include/etl/span.h +++ b/include/etl/span.h @@ -48,9 +48,9 @@ namespace etl static ETL_CONSTANT size_t dynamic_extent = etl::integral_limits::max; //*************************************************************************** - /// Array view. + /// Span //*************************************************************************** - template + template class span { public: @@ -108,10 +108,11 @@ namespace etl { } +#if ETL_CPP11_SUPPORTED //************************************************************************* /// Construct from etl::array. //************************************************************************* - template + template ::type> ETL_CONSTEXPR span(etl::array& a) ETL_NOEXCEPT : mbegin(a.data()) , mend(a.data() + a.size()) @@ -121,18 +122,39 @@ namespace etl //************************************************************************* /// Construct from etl::array. //************************************************************************* - template + template ::type> ETL_CONSTEXPR span(const etl::array& a) ETL_NOEXCEPT : mbegin(a.data()) , mend(a.data() + a.size()) { } +#else + //************************************************************************* + /// Construct from etl::array. + //************************************************************************* + template + ETL_CONSTEXPR span(etl::array& a, typename etl::enable_if::type) ETL_NOEXCEPT + : mbegin(a.data()) + , mend(a.data() + a.size()) + { + } + + //************************************************************************* + /// Construct from etl::array. + //************************************************************************* + template + ETL_CONSTEXPR span(const etl::array& a, typename etl::enable_if::type) ETL_NOEXCEPT + : mbegin(a.data()) + , mend(a.data() + a.size()) + { + } +#endif #if ETL_CPP11_SUPPORTED && ETL_USING_STL //************************************************************************* /// Construct from std::array. //************************************************************************* - template + template ::type> ETL_CONSTEXPR span(std::array& a) ETL_NOEXCEPT : mbegin(a.data()) , mend(a.data() + a.size()) @@ -142,7 +164,7 @@ namespace etl //************************************************************************* /// Construct from std::array. //************************************************************************* - template + template ::type> ETL_CONSTEXPR span(const std::array& 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 ::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 ::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 - ETL_CONSTEXPR span(TContainer& a, typename etl::enable_if::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 - ETL_CONSTEXPR span(const TContainer& a, typename etl::enable_if::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 + template ETL_CONSTEXPR etl::span first() const { return etl::span(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 + template ETL_CONSTEXPR etl::span last() const { return etl::span(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 - ETL_CONSTEXPR - typename etl::enable_if >::type - subspan() const + template + ETL_CONSTEXPR + etl::span subspan() const { - return etl::span(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 - ETL_CONSTEXPR - typename etl::enable_if >::type - subspan() const - { - return etl::span(mbegin + OFFSET, mbegin + OFFSET + COUNT); + if (COUNT == etl::dynamic_extent) + { + return etl::span(mbegin + OFFSET, mend); + } + else + { + return etl::span(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 - ETL_CONSTEXPR - typename etl::enable_if >::type - subspan() const + template + ETL_CONSTEXPR + etl::span subspan() const + { + if (COUNT == etl::dynamic_extent) + { + return etl::span(mbegin + OFFSET, mend); + } + else + { + return etl::span(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 subspan(size_t offset, size_t count = etl::dynamic_extent) const + { + if (count == etl::dynamic_extent) + { + return etl::span(mbegin + offset, mend); + } + else + { + return etl::span(mbegin + offset, mbegin + offset + count); + } + } + + private: + + element_type* mbegin; + element_type* mend; + }; + + //*************************************************************************** + /// Span specialisation + //*************************************************************************** + template + class span + { + public: + + typedef T element_type; + typedef typename etl::remove_cv::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 reverse_iterator; + typedef ETL_OR_STD::reverse_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(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 - ETL_CONSTEXPR - typename etl::enable_if >::type - subspan() const + template + ETL_CONSTEXPR span(const TIterator begin_, const TSize size_) ETL_NOEXCEPT + : mbegin(etl::addressof(*begin_)) + , mend(etl::addressof(*begin_) + size_) { - return etl::span(mbegin + OFFSET, mbegin + OFFSET + COUNT); + } + + //************************************************************************* + /// Construct from iterators + //************************************************************************* + template + 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 + ETL_CONSTEXPR span(element_type(&begin_)[ARRAY_SIZE]) ETL_NOEXCEPT + : mbegin(begin_) + , mend(begin_ + ARRAY_SIZE) + { + } + + //************************************************************************* + /// Construct from etl::array. + //************************************************************************* + template + ETL_CONSTEXPR span(etl::array& a) ETL_NOEXCEPT + : mbegin(a.data()) + , mend(a.data() + a.size()) + { + } + + //************************************************************************* + /// Construct from etl::array. + //************************************************************************* + template + ETL_CONSTEXPR span(const etl::array& a) ETL_NOEXCEPT + : mbegin(a.data()) + , mend(a.data() + a.size()) + { + } + +#if ETL_CPP11_SUPPORTED && ETL_USING_STL + //************************************************************************* + /// Construct from std::array. + //************************************************************************* + template + ETL_CONSTEXPR span(std::array& a) ETL_NOEXCEPT + : mbegin(a.data()) + , mend(a.data() + a.size()) + { + } + + //************************************************************************* + /// Construct from std::array. + //************************************************************************* + template + ETL_CONSTEXPR span(const std::array& 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 >::value && + !etl::is_array>::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 + ETL_CONSTEXPR span(TContainer& a, typename etl::enable_if::type>::value && + !etl::is_array::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 + ETL_CONSTEXPR span(const TContainer& a, typename etl::enable_if::type>::value && + !etl::is_array::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 true 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 + ETL_CONSTEXPR etl::span first() const + { + return etl::span(mbegin, mbegin + COUNT); + } + + //************************************************************************* + /// Obtains a span that is a view over the first count elements of this span. + //************************************************************************* + ETL_CONSTEXPR etl::span first(size_t count) const + { + return etl::span(mbegin, mbegin + count); + } + + //************************************************************************* + /// Obtains a span that is a view over the last COUNT elements of this span. + //************************************************************************* + template + ETL_CONSTEXPR etl::span last() const + { + return etl::span(mend - COUNT, mend); + } + + //************************************************************************* + /// Obtains a span that is a view over the last count elements of this span. + //************************************************************************* + ETL_CONSTEXPR etl::span last(size_t count) const + { + return etl::span(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 + ETL_CONSTEXPR + etl::span subspan() const + { + if (COUNT == etl::dynamic_extent) + { + return etl::span(mbegin + OFFSET, mend); + } + else + { + return etl::span(mbegin + OFFSET, mbegin + OFFSET + COUNT); + } + } +#else + //************************************************************************* + /// Obtains a span that is a view from OFFSET over the next COUNT elements of this span. + //************************************************************************* + template + ETL_CONSTEXPR + etl::span subspan() const + { + if (COUNT == etl::dynamic_extent) + { + return etl::span(mbegin + OFFSET, mend); + } + else + { + return etl::span(mbegin + OFFSET, mbegin + OFFSET + COUNT); + } } #endif @@ -419,16 +728,27 @@ namespace etl #if ETL_CPP17_SUPPORTED template span(TArray& a) - ->span; + ->span; template span(const TIterator begin_, const TIterator end_) - ->span>; + ->span, etl::dynamic_extent>; - template + template span(const TIterator begin_, const TSize size_) - ->span>; + ->span, etl::dynamic_extent>; + + //template + //span(TArray& a) + // ->span; + + //template + //span(const TIterator begin_, const TIterator end_) + // ->span, EXTENT>; + + //template + // span(const TIterator begin_, const TSize size_) + // ->span, EXTENT>; #endif //************************************************************************* @@ -448,4 +768,3 @@ namespace etl } #endif - diff --git a/test/test_message_packet.cpp b/test/test_message_packet.cpp index 75ac200e..029b4bce 100644 --- a/test/test_message_packet.cpp +++ b/test/test_message_packet.cpp @@ -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(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(packet1.get()).x); CHECK_EQUAL(2.2, static_cast(packet2.get()).x); } +#endif //************************************************************************* TEST(message_constant_packet_construction) @@ -302,6 +307,7 @@ namespace CHECK_EQUAL(1, static_cast(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(packet1.get()).x); CHECK_EQUAL(1, static_cast(packet2.get()).x); } +#endif //************************************************************************* TEST(message_packet_assignment) @@ -348,6 +355,7 @@ namespace CHECK_EQUAL(1, static_cast(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(packet1.get()).x); CHECK_EQUAL(1, static_cast(packet2.get()).x); } +#endif //************************************************************************* TEST(message_packet_accepts) diff --git a/test/test_multi_vector.cpp b/test/test_multi_vector.cpp index 0a0f8ca4..8ec89871 100644 --- a/test/test_multi_vector.cpp +++ b/test/test_multi_vector.cpp @@ -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()); diff --git a/test/test_span.cpp b/test/test_span.cpp index eff46316..51745251 100644 --- a/test/test_span.cpp +++ b/test/test_span.cpp @@ -631,14 +631,31 @@ namespace } //************************************************************************* - void f(etl::span value) + void f_issue_481(etl::span value) { } TEST(test_issue_481) { + // Should compile. char c[10]; - f(c); + f_issue_481(c); + } + + //************************************************************************* + void f_issue_486(etl::span value) + { + } + + TEST(test_issue_486) + { + //std::array c; + + // Should not compile. + //etl::span value(c); + + // Should not compile. + //f_issue_486(c); } }; }