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

Fixes after merge

Browse Source
This commit is contained in:
John Wellbelove 2021-08-10 12:37:33 +01:00
parent 27f5204032
commit 774384e316
5 changed files with 418 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/etl/generators/largest_generator.h
View File

@ -396,11 +396,8 @@ namespace etl
#endif
#if ETL_CPP17_SUPPORTED
template <typename... T>
inline constexpr size_t largest_size_v = largest<T...>::size;
template <typename... T>
inline constexpr size_t largest_alignment_v = largest<T...>::alignment;
template <typename... T>
inline constexpr size_t largest_size = largest<T...>::size;
#endif
#else

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

@ -74,6 +74,297 @@ cog.outl("//********************************************************************
namespace etl
{
#if ETL_CPP17_SUPPORTED && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03)
//***************************************************************************
// The definition for all message types.
//***************************************************************************
template <typename... TMessageTypes>
class message_packet
{
public:
//********************************************
message_packet()
: valid(false)
{
}
//********************************************
explicit message_packet(const etl::imessage& msg)
: valid(true)
{
add_new_message(msg);
}
//********************************************
explicit message_packet(etl::imessage&& msg)
: valid(true)
{
add_new_message(etl::move(msg));
}
//********************************************
template <typename TMessage, etl::enable_if_t<!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::imessage> &&
!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::message_packet<TMessageTypes...>>, int> = 0>
explicit message_packet(TMessage&& msg)
: valid(true)
{
add_new_message<TMessage>(etl::forward<TMessage>(msg));
}
//**********************************************
message_packet(const message_packet& other)
: valid(other.is_valid())
{
if (valid)
{
add_new_message(other.get());
}
}
//**********************************************
message_packet(message_packet&& other)
: valid(other.is_valid())
{
if (valid)
{
add_new_message(etl::move(other.get()));
}
}
//**********************************************
message_packet& operator =(const message_packet& rhs)
{
delete_current_message();
valid = rhs.is_valid();
if (valid)
{
add_new_message(rhs.get());
}
return *this;
}
//**********************************************
message_packet& operator =(message_packet&& rhs)
{
delete_current_message();
valid = rhs.is_valid();
if (valid)
{
add_new_message(etl::move(rhs.get()));
}
return *this;
}
//********************************************
~message_packet()
{
delete_current_message();
}
//********************************************
etl::imessage& get() ETL_NOEXCEPT
{
return *static_cast<etl::imessage*>(data);
}
//********************************************
const etl::imessage& get() const ETL_NOEXCEPT
{
return *static_cast<const etl::imessage*>(data);
}
//********************************************
bool is_valid() const
{
return valid;
}
//**********************************************
static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
{
return (accepts_message<TMessageTypes::ID>(id) || ...);
}
//**********************************************
static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
{
return accepts(msg.get_message_id());
}
//**********************************************
template <etl::message_id_t Id>
static ETL_CONSTEXPR bool accepts()
{
return (accepts_message<TMessageTypes::ID, Id>() || ...);
}
//**********************************************
template <typename TMessage>
static ETL_CONSTEXPR
typename etl::enable_if<!etl::is_integral<TMessage>::value, bool>::type
accepts()
{
return accepts<TMessage::ID>();
}
enum
{
SIZE = etl::largest<TMessageTypes...>::size,
ALIGNMENT = etl::largest<TMessageTypes...>::alignment
};
private:
//**********************************************
template <etl::message_id_t Id1, etl::message_id_t Id2>
static ETL_CONSTEXPR bool accepts_message()
{
return Id1 == Id2;
}
//**********************************************
template <etl::message_id_t Id1>
static ETL_CONSTEXPR bool accepts_message(etl::message_id_t id2)
{
return Id1 == id2;
}
//********************************************
void delete_current_message()
{
if (valid)
{
etl::imessage* pmsg = static_cast<etl::imessage*>(data);
#if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
pmsg->~imessage();
#else
if (!(delete_current_message_type<TMessageTypes>(pmsg->get_message_id()) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
#endif
}
}
//********************************************
void add_new_message(const etl::imessage& msg)
{
if (!(add_new_message_type<TMessageTypes>(msg) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
}
//********************************************
void add_new_message(etl::imessage&& msg)
{
if (!(add_new_message_type<TMessageTypes>(etl::move(msg)) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
}
//********************************************
template <typename TMessage, etl::enable_if_t<!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::imessage>, int> = 0>
void add_new_message(TMessage&& msg)
{
if (!(add_new_message_type<TMessageTypes, etl::remove_reference_t<TMessage>::ID>(etl::forward<TMessage>(msg)) || ...))
{
ETL_ALWAYS_ASSERT(ETL_ERROR(unhandled_message_exception));
}
}
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
private:
//********************************************
template <typename TType>
bool delete_current_message_type(etl::message_id_t Id)
{
if (TType::ID == Id)
{
static_cast<TType*>(data)->~TType();
return true;
}
else
{
return false;
}
}
//********************************************
template <typename TType>
bool add_new_message_type(const etl::imessage& msg)
{
if (TType::ID == msg.get_message_id())
{
void* p = data;
new (p) TType(static_cast<const TType&>(msg));
return true;
}
else
{
return false;
}
}
//********************************************
template <typename TType, etl::message_id_t Id>
bool add_new_message_type(const etl::imessage& msg)
{
if (TType::ID == Id)
{
void* p = data;
new (p) TType(static_cast<const TType&>(msg));
return true;
}
else
{
return false;
}
}
//********************************************
template <typename TType>
bool add_new_message_type(etl::imessage&& msg)
{
if (TType::ID == msg.get_message_id())
{
void* p = data;
new (p) TType(static_cast<TType&&>(msg));
return true;
}
else
{
return false;
}
}
//********************************************
template <typename TType, etl::message_id_t Id>
bool add_new_message_type(etl::imessage&& msg)
{
if (TType::ID == Id)
{
void* p = data;
new (p) TType(static_cast<TType&&>(msg));
return true;
}
else
{
return false;
}
}
};
#else
/*[[[cog
import cog
################################################
@ -539,6 +830,7 @@ namespace etl
cog.outl("};")
]]]*/
/*[[[end]]]*/
#endif
}
#endif

104
include/etl/generators/message_router_generator.h
View File

@ -307,6 +307,109 @@ namespace etl
destination.receive(message);
}
#if ETL_CPP17_SUPPORTED && !defined(ETL_MESSAGE_ROUTER_FORCE_CPP03)
//***************************************************************************
// The definition for all message types.
//***************************************************************************
template <typename TDerived, typename... TMessageTypes>
class message_router : public imessage_router
{
public:
typedef etl::message_packet<TMessageTypes...> message_packet;
//**********************************************
message_router(etl::message_router_id_t id_)
: imessage_router(id_)
{
ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
}
//**********************************************
message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
: imessage_router(id_, successor_)
{
ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
}
//**********************************************
using etl::imessage_router::receive;
void receive(const etl::imessage& msg) ETL_OVERRIDE
{
const bool was_handled = (receive_message_type<TMessageTypes>(msg) || ...);
if (!was_handled)
{
if (has_successor())
{
get_successor().receive(msg);
}
else
{
static_cast<TDerived*>(this)->on_receive_unknown(msg);
}
}
}
//**********************************************
using imessage_router::accepts;
bool accepts(etl::message_id_t id) const ETL_OVERRIDE
{
return (accepts_type<TMessageTypes>(id) || ...);
}
//********************************************
ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
{
return false;
}
//********************************************
bool is_producer() const ETL_OVERRIDE
{
return true;
}
//********************************************
bool is_consumer() const ETL_OVERRIDE
{
return true;
}
private:
//********************************************
template <typename TMessage>
bool receive_message_type(const etl::imessage& msg)
{
if (TMessage::ID == msg.get_message_id())
{
static_cast<TDerived*>(this)->on_receive(static_cast<const TMessage&>(msg));
return true;
}
else
{
return false;
}
}
//********************************************
template <typename TMessage>
bool accepts_type(etl::message_id_t id) const
{
if (TMessage::ID == id)
{
return true;
}
else
{
return false;
}
}
};
#else
/*[[[cog
import cog
################################################
@ -536,6 +639,7 @@ namespace etl
cog.outl("};")
]]]*/
/*[[[end]]]*/
#endif
}
#endif

5
include/etl/largest.h
View File

@ -347,6 +347,11 @@ namespace etl
using largest_t = typename largest<T...>::type;
#endif
#if ETL_CPP17_SUPPORTED
template <typename... T>
inline constexpr size_t largest_size = largest<T...>::size;
#endif
#else
//***************************************************************************
/// Template to determine the largest type, size and alignment.

31
include/etl/message_packet.h
View File

@ -54,7 +54,6 @@ SOFTWARE.
#include "message.h"
#include "error_handler.h"
#include "static_assert.h"
#include "exception.h"
#include "largest.h"
#include "alignment.h"
#include "utility.h"
@ -94,8 +93,8 @@ namespace etl
//********************************************
template <typename TMessage, etl::enable_if_t<!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::imessage> &&
!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::message_packet<TMessageTypes...>>, int> = 0>
explicit message_packet(TMessage&& msg)
!etl::is_same_v<etl::remove_reference_t<TMessage>, etl::message_packet<TMessageTypes...>>, int> = 0>
explicit message_packet(TMessage&& msg)
: valid(true)
{
add_new_message<TMessage>(etl::forward<TMessage>(msg));
@ -201,7 +200,7 @@ namespace etl
enum
{
SIZE = etl::largest<TMessageTypes...>::size,
SIZE = etl::largest<TMessageTypes...>::size,
ALIGNMENT = etl::largest<TMessageTypes...>::alignment
};
@ -285,8 +284,8 @@ namespace etl
{
return false;
}
}
}
//********************************************
template <typename TType>
bool add_new_message_type(const etl::imessage& msg)
@ -498,7 +497,7 @@ namespace etl
enum
{
Size = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::size,
SIZE = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::size,
ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::alignment
};
@ -598,7 +597,7 @@ namespace etl
}
#endif
typename etl::aligned_storage<Size, ALIGNMENT>::type data;
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
};
@ -746,7 +745,7 @@ namespace etl
enum
{
Size = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::size,
SIZE = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::size,
ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::alignment
};
@ -843,7 +842,7 @@ namespace etl
}
#endif
typename etl::aligned_storage<Size, ALIGNMENT>::type data;
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
};
@ -991,7 +990,7 @@ namespace etl
enum
{
Size = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::size,
SIZE = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::size,
ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::alignment
};
@ -1085,7 +1084,7 @@ namespace etl
}
#endif
typename etl::aligned_storage<Size, ALIGNMENT>::type data;
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
};
@ -1233,7 +1232,7 @@ namespace etl
enum
{
Size = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::size,
SIZE = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::size,
ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::alignment
};
@ -1324,7 +1323,7 @@ namespace etl
}
#endif
typename etl::aligned_storage<Size, ALIGNMENT>::type data;
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
};
@ -1471,7 +1470,7 @@ namespace etl
enum
{
Size = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::size,
SIZE = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::size,
ALIGNMENT = etl::largest<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::alignment
};
@ -1559,7 +1558,7 @@ namespace etl
}
#endif
typename etl::aligned_storage<Size, ALIGNMENT>::type data;
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
};