Embedded Template Library 1.0
message_packet.h
1/******************************************************************************
2The MIT License(MIT)
3
4Embedded Template Library.
5https://github.com/ETLCPP/etl
6https://www.etlcpp.com
7
8Copyright(c) 2020 John Wellbelove
9
10Permission is hereby granted, free of charge, to any person obtaining a copy
11of this software and associated documentation files(the "Software"), to deal
12in the Software without restriction, including without limitation the rights
13to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
14copies of the Software, and to permit persons to whom the Software is
15furnished to do so, subject to the following conditions :
16
17The above copyright notice and this permission notice shall be included in all
18copies or substantial portions of the Software.
19
20THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
23AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26SOFTWARE.
27******************************************************************************/
28
29#if 0
30#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
31#endif
32
33//***************************************************************************
34// THIS FILE HAS BEEN AUTO GENERATED. DO NOT EDIT THIS FILE.
35//***************************************************************************
36
37//***************************************************************************
38// To generate to header file, run this at the command line.
39// Note: You will need Python and COG installed.
40//
41// python -m cogapp -d -e -omessage_packet.h -DHandlers=<n> message_packet_generator.h
42// Where <n> is the number of messages to support.
43//
44// e.g.
45// To generate handlers for up to 16 messages...
46// python -m cogapp -d -e -omessage_packet.h -DHandlers=16 message_packet_generator.h
47//
48// See generate.bat
49//***************************************************************************
50
51#ifndef ETL_MESSAGE_PACKET_INCLUDED
52#define ETL_MESSAGE_PACKET_INCLUDED
53
54#include "message.h"
55#include "error_handler.h"
56#include "static_assert.h"
57#include "largest.h"
58#include "alignment.h"
59#include "utility.h"
60
61#include <stdint.h>
62
63namespace etl
64{
65#if ETL_USING_CPP17 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
66 //***************************************************************************
67 // The definition for all message types.
68 //***************************************************************************
69 template <typename... TMessageTypes>
70 class message_packet
71 {
72
73 private:
74
75 template <typename T>
76 static constexpr bool IsMessagePacket = etl::is_same_v< etl::remove_const_t<etl::remove_reference_t<T>>, etl::message_packet<TMessageTypes...>>;
77
78 template <typename T>
79 static constexpr bool IsInMessageList = etl::is_one_of_v<etl::remove_const_t<etl::remove_reference_t<T>>, TMessageTypes...>;
80
81 template <typename T>
82 static constexpr bool IsIMessage = etl::is_same_v<remove_const_t<etl::remove_reference_t<T>>, etl::imessage>;
83
84 public:
85
86 //********************************************
88 message_packet()
89 : valid(false)
90 {
91 }
93
94 //********************************************
96 //********************************************
98 template <typename T>
99 explicit message_packet(T&& msg)
100 : valid(true)
101 {
102 if constexpr (IsIMessage<T>)
103 {
104 if (accepts(msg))
105 {
106 add_new_message(etl::forward<T>(msg));
107 valid = true;
108 }
109 else
110 {
111 valid = false;
112 }
113
114 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
115 }
116 else if constexpr (IsInMessageList<T>)
117 {
118 add_new_message_type<T>(etl::forward<T>(msg));
119 }
120 else if constexpr (IsMessagePacket<T>)
121 {
122 copy(etl::forward<T>(msg));
123 }
124 else
125 {
126 ETL_STATIC_ASSERT(IsInMessageList<T>, "Message not in packet type list");
127 }
128 }
130
131 //**********************************************
132 void copy(const message_packet& other)
133 {
134 valid = other.is_valid();
135
136 if (valid)
137 {
138 add_new_message(other.get());
139 }
140 }
141
142 //**********************************************
143 void copy(message_packet&& other)
144 {
145 valid = other.is_valid();
146
147 if (valid)
148 {
149 add_new_message(etl::move(other.get()));
150 }
151 }
152
153 //**********************************************
154 message_packet& operator =(const message_packet& rhs)
155 {
156 delete_current_message();
157 valid = rhs.is_valid();
158 if (valid)
159 {
160 add_new_message(rhs.get());
161 }
162
163 return *this;
164 }
165
166 //**********************************************
167 message_packet& operator =(message_packet&& rhs)
168 {
169 delete_current_message();
170 valid = rhs.is_valid();
171 if (valid)
172 {
173 add_new_message(etl::move(rhs.get()));
174 }
175
176 return *this;
177 }
178
179 //********************************************
180 ~message_packet()
181 {
182 delete_current_message();
183 }
184
185 //********************************************
186 etl::imessage& get() ETL_NOEXCEPT
187 {
188 return *static_cast<etl::imessage*>(data);
189 }
190
191 //********************************************
192 const etl::imessage& get() const ETL_NOEXCEPT
193 {
194 return *static_cast<const etl::imessage*>(data);
195 }
196
197 //********************************************
198 bool is_valid() const
199 {
200 return valid;
201 }
202
203 //**********************************************
204 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
205 {
206 return (accepts_message<TMessageTypes::ID>(id) || ...);
207 }
208
209 //**********************************************
210 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
211 {
212 return accepts(msg.get_message_id());
213 }
214
215 //**********************************************
216 template <etl::message_id_t Id>
217 static ETL_CONSTEXPR bool accepts()
218 {
219 return (accepts_message<TMessageTypes::ID, Id>() || ...);
220 }
221
222 //**********************************************
223 template <typename TMessage>
224 static ETL_CONSTEXPR
226 accepts()
227 {
228 return accepts<TMessage::ID>();
229 }
230
231 enum
232 {
233 SIZE = etl::largest<TMessageTypes...>::size,
234 ALIGNMENT = etl::largest<TMessageTypes...>::alignment
235 };
236
237 private:
238
239 //**********************************************
240 template <etl::message_id_t Id1, etl::message_id_t Id2>
241 static bool accepts_message()
242 {
243 return Id1 == Id2;
244 }
245
246 //**********************************************
247 template <etl::message_id_t Id1>
248 static bool accepts_message(etl::message_id_t id2)
249 {
250 return Id1 == id2;
251 }
252
253 //********************************************
255 void delete_current_message()
256 {
257 if (valid)
258 {
259 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
260
261 pmsg->~imessage();
262 }
263 }
265
266 //********************************************
267 void add_new_message(const etl::imessage& msg)
268 {
269 (add_new_message_type<TMessageTypes>(msg) || ...);
270 }
271
272 //********************************************
273 void add_new_message(etl::imessage&& msg)
274 {
275 (add_new_message_type<TMessageTypes>(etl::move(msg)) || ...);
276 }
277
278 //********************************************
280 //********************************************
281 template <typename TMessage>
282 etl::enable_if_t<etl::is_one_of_v<etl::remove_const_t<etl::remove_reference_t<TMessage>>, TMessageTypes...>, void>
283 add_new_message_type(TMessage&& msg)
284 {
285 void* p = data;
286 new (p) etl::remove_reference_t<TMessage>((etl::forward<TMessage>(msg)));
287 }
288
289 //********************************************
290 template <typename TType>
291 bool add_new_message_type(const etl::imessage& msg)
292 {
293 if (TType::ID == msg.get_message_id())
294 {
295 void* p = data;
296 new (p) TType(static_cast<const TType&>(msg));
297 return true;
298 }
299 else
300 {
301 return false;
302 }
303 }
304
305 //********************************************
306 template <typename TType>
307 bool add_new_message_type(etl::imessage&& msg)
308 {
309 if (TType::ID == msg.get_message_id())
310 {
311 void* p = data;
312 new (p) TType(static_cast<TType&&>(msg));
313 return true;
314 }
315 else
316 {
317 return false;
318 }
319 }
320
322 bool valid;
323 };
324
325#else
326
327 //***************************************************************************
328 // The definition for all 16 message types.
329 //***************************************************************************
330 template <typename T1, typename T2 = void, typename T3 = void, typename T4 = void,
331 typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void,
332 typename T9 = void, typename T10 = void, typename T11 = void, typename T12 = void,
333 typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void>
335 {
336 public:
337
338 //********************************************
341 : valid(false)
342 {
343 }
345
346 //********************************************
348 explicit message_packet(const etl::imessage& msg)
349 {
350 if (accepts(msg))
351 {
352 add_new_message(msg);
353 valid = true;
354 }
355 else
356 {
357 valid = false;
358 }
359
360 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
361 }
363
364 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
365 //********************************************
367 explicit message_packet(etl::imessage&& msg)
368 {
369 if (accepts(msg))
370 {
371 add_new_message(etl::move(msg));
372 valid = true;
373 }
374 else
375 {
376 valid = false;
377 }
378
379 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
380 }
382 #endif
383
384 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
385 //********************************************
387 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
389 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type>
390 explicit message_packet(TMessage&& /*msg*/)
391 : valid(true)
392 {
393 // Not etl::message_packet, not etl::imessage and in typelist.
396 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value);
397
398 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
399 }
401 #else
402 //********************************************
404 template <typename TMessage>
405 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> >::value &&
406 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
407 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, int>::type = 0)
408 : valid(true)
409 {
410 // Not etl::message_packet, not etl::imessage and in typelist.
413 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value);
414
415 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
416 }
418 #endif
419
420 //**********************************************
422 message_packet(const message_packet& other)
423 : valid(other.is_valid())
424 {
425 if (valid)
426 {
427 add_new_message(other.get());
428 }
429 }
431
432 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
433 //**********************************************
436 : valid(other.is_valid())
437 {
438 if (valid)
439 {
440 add_new_message(etl::move(other.get()));
441 }
442 }
444 #endif
445
446 //**********************************************
447 message_packet& operator =(const message_packet& rhs)
448 {
449 delete_current_message();
450 valid = rhs.is_valid();
451 if (valid)
452 {
453 add_new_message(rhs.get());
454 }
455
456 return *this;
457 }
458
459 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
460 //**********************************************
461 message_packet& operator =(message_packet&& rhs)
462 {
463 delete_current_message();
464 valid = rhs.is_valid();
465 if (valid)
466 {
467 add_new_message(etl::move(rhs.get()));
468 }
469
470 return *this;
471 }
472 #endif
473
474 //********************************************
476 {
477 delete_current_message();
478 }
479
480 //********************************************
481 etl::imessage& get() ETL_NOEXCEPT
482 {
483 return *static_cast<etl::imessage*>(data);
484 }
485
486 //********************************************
487 const etl::imessage& get() const ETL_NOEXCEPT
488 {
489 return *static_cast<const etl::imessage*>(data);
490 }
491
492 //********************************************
493 bool is_valid() const
494 {
495 return valid;
496 }
497
498 //**********************************************
499 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
500 {
501 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
502 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
503 T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
504 T13::ID == id || T14::ID == id || T15::ID == id || T16::ID == id;
505 }
506
507 //**********************************************
508 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
509 {
510 return accepts(msg.get_message_id());
511 }
512
513 //**********************************************
514 template <etl::message_id_t Id>
515 static ETL_CONSTEXPR bool accepts()
516 {
517 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
518 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
519 T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
520 T13::ID == Id || T14::ID == Id || T15::ID == Id || T16::ID == Id;
521 }
522
523 //**********************************************
524 template <typename TMessage>
525 static ETL_CONSTEXPR
527 accepts()
528 {
529 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
530 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
531 T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
532 T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID || T16::ID == TMessage::ID;
533 }
534
535 enum
536 {
539 };
540
541 private:
542
543 //********************************************
545 void delete_current_message()
546 {
547 if (valid)
548 {
549 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
550
551 pmsg->~imessage();
552 }
553 }
555
556 //********************************************
557 void add_new_message(const etl::imessage& msg)
558 {
559 const size_t id = msg.get_message_id();
560 void* p = data;
561
562 switch (id)
563 {
564 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
565 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
566 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
567 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
568 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
569 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
570 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
571 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
572 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
573 case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
574 case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
575 case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
576 case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
577 case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
578 case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
579 case T16::ID: ::new (p) T16(static_cast<const T16&>(msg)); break;
580 default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
581 }
582 }
583
584 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
585 //********************************************
586 void add_new_message(etl::imessage&& msg)
587 {
588 const size_t id = msg.get_message_id();
589 void* p = data;
590
591 switch (id)
592 {
593 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
594 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
595 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
596 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
597 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
598 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
599 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
600 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
601 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
602 case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
603 case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
604 case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
605 case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
606 case T14::ID: ::new (p) T14(static_cast<T14&&>(msg)); break;
607 case T15::ID: ::new (p) T15(static_cast<T15&&>(msg)); break;
608 case T16::ID: ::new (p) T16(static_cast<T16&&>(msg)); break;
609 default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
610 }
611 }
612 #endif
613
615 bool valid;
616 };
617
618 //***************************************************************************
619 // Specialisation for 15 message types.
620 //***************************************************************************
621 template <typename T1, typename T2, typename T3, typename T4,
622 typename T5, typename T6, typename T7, typename T8,
623 typename T9, typename T10, typename T11, typename T12,
624 typename T13, typename T14, typename T15>
625 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void>
626 {
627 public:
628
629 //********************************************
632 : valid(false)
633 {
634 }
636
637 //********************************************
639 explicit message_packet(const etl::imessage& msg)
640 {
641 if (accepts(msg))
642 {
643 add_new_message(msg);
644 valid = true;
645 }
646 else
647 {
648 valid = false;
649 }
650
651 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
652 }
654
655 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
656 //********************************************
658 explicit message_packet(etl::imessage&& msg)
659 {
660 if (accepts(msg))
661 {
662 add_new_message(etl::move(msg));
663 valid = true;
664 }
665 else
666 {
667 valid = false;
668 }
669
670 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
671 }
673 #endif
674
675 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
676 //********************************************
678 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
680 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type>
681 explicit message_packet(TMessage&& /*msg*/)
682 : valid(true)
683 {
684 // Not etl::message_packet, not etl::imessage and in typelist.
687 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value);
688
689 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
690 }
692 #else
693 //********************************************
695 template <typename TMessage>
696 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> >::value &&
697 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
698 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, int>::type = 0)
699 : valid(true)
700 {
701 // Not etl::message_packet, not etl::imessage and in typelist.
704 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value);
705
706 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
707 }
709 #endif
710
711 //**********************************************
713 message_packet(const message_packet& other)
714 : valid(other.is_valid())
715 {
716 if (valid)
717 {
718 add_new_message(other.get());
719 }
720 }
722
723 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
724 //**********************************************
727 : valid(other.is_valid())
728 {
729 if (valid)
730 {
731 add_new_message(etl::move(other.get()));
732 }
733 }
735 #endif
736
737 //**********************************************
738 message_packet& operator =(const message_packet& rhs)
739 {
740 delete_current_message();
741 valid = rhs.is_valid();
742 if (valid)
743 {
744 add_new_message(rhs.get());
745 }
746
747 return *this;
748 }
749
750 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
751 //**********************************************
752 message_packet& operator =(message_packet&& rhs)
753 {
754 delete_current_message();
755 valid = rhs.is_valid();
756 if (valid)
757 {
758 add_new_message(etl::move(rhs.get()));
759 }
760
761 return *this;
762 }
763 #endif
764
765 //********************************************
767 {
768 delete_current_message();
769 }
770
771 //********************************************
772 etl::imessage& get() ETL_NOEXCEPT
773 {
774 return *static_cast<etl::imessage*>(data);
775 }
776
777 //********************************************
778 const etl::imessage& get() const ETL_NOEXCEPT
779 {
780 return *static_cast<const etl::imessage*>(data);
781 }
782
783 //********************************************
784 bool is_valid() const
785 {
786 return valid;
787 }
788
789 //**********************************************
790 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
791 {
792 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
793 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
794 T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
795 T13::ID == id || T14::ID == id || T15::ID == id;
796 }
797
798 //**********************************************
799 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
800 {
801 return accepts(msg.get_message_id());
802 }
803
804 //**********************************************
805 template <etl::message_id_t Id>
806 static ETL_CONSTEXPR bool accepts()
807 {
808 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
809 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
810 T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
811 T13::ID == Id || T14::ID == Id || T15::ID == Id;
812 }
813
814 //**********************************************
815 template <typename TMessage>
816 static ETL_CONSTEXPR
818 accepts()
819 {
820 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
821 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
822 T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
823 T13::ID == TMessage::ID || T14::ID == TMessage::ID || T15::ID == TMessage::ID;
824 }
825
826 enum
827 {
830 };
831
832 private:
833
834 //********************************************
836 void delete_current_message()
837 {
838 if (valid)
839 {
840 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
841
842 pmsg->~imessage();
843 }
844 }
846
847 //********************************************
848 void add_new_message(const etl::imessage& msg)
849 {
850 const size_t id = msg.get_message_id();
851 void* p = data;
852
853 switch (id)
854 {
855 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
856 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
857 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
858 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
859 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
860 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
861 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
862 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
863 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
864 case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
865 case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
866 case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
867 case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
868 case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
869 case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
870 default: break;
871 }
872 }
873
874 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
875 //********************************************
876 void add_new_message(etl::imessage&& msg)
877 {
878 const size_t id = msg.get_message_id();
879 void* p = data;
880
881 switch (id)
882 {
883 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
884 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
885 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
886 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
887 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
888 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
889 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
890 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
891 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
892 case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
893 case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
894 case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
895 case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
896 case T14::ID: ::new (p) T14(static_cast<T14&&>(msg)); break;
897 case T15::ID: ::new (p) T15(static_cast<T15&&>(msg)); break;
898 default: break;
899 }
900 }
901 #endif
902
904 bool valid;
905 };
906
907 //***************************************************************************
908 // Specialisation for 14 message types.
909 //***************************************************************************
910 template <typename T1, typename T2, typename T3, typename T4,
911 typename T5, typename T6, typename T7, typename T8,
912 typename T9, typename T10, typename T11, typename T12,
913 typename T13, typename T14>
914 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void>
915 {
916 public:
917
918 //********************************************
921 : valid(false)
922 {
923 }
925
926 //********************************************
928 explicit message_packet(const etl::imessage& msg)
929 {
930 if (accepts(msg))
931 {
932 add_new_message(msg);
933 valid = true;
934 }
935 else
936 {
937 valid = false;
938 }
939
940 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
941 }
943
944 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
945 //********************************************
947 explicit message_packet(etl::imessage&& msg)
948 {
949 if (accepts(msg))
950 {
951 add_new_message(etl::move(msg));
952 valid = true;
953 }
954 else
955 {
956 valid = false;
957 }
958
959 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
960 }
962 #endif
963
964 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
965 //********************************************
967 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
969 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type>
970 explicit message_packet(TMessage&& /*msg*/)
971 : valid(true)
972 {
973 // Not etl::message_packet, not etl::imessage and in typelist.
976 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value);
977
978 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
979 }
981 #else
982 //********************************************
984 template <typename TMessage>
985 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> >::value &&
986 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
987 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, int>::type = 0)
988 : valid(true)
989 {
990 // Not etl::message_packet, not etl::imessage and in typelist.
993 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value);
994
995 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
996 }
998 #endif
999
1000 //**********************************************
1002 message_packet(const message_packet& other)
1003 : valid(other.is_valid())
1004 {
1005 if (valid)
1006 {
1007 add_new_message(other.get());
1008 }
1009 }
1011
1012 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1013 //**********************************************
1016 : valid(other.is_valid())
1017 {
1018 if (valid)
1019 {
1020 add_new_message(etl::move(other.get()));
1021 }
1022 }
1024 #endif
1025
1026 //**********************************************
1027 message_packet& operator =(const message_packet& rhs)
1028 {
1029 delete_current_message();
1030 valid = rhs.is_valid();
1031 if (valid)
1032 {
1033 add_new_message(rhs.get());
1034 }
1035
1036 return *this;
1037 }
1038
1039 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1040 //**********************************************
1041 message_packet& operator =(message_packet&& rhs)
1042 {
1043 delete_current_message();
1044 valid = rhs.is_valid();
1045 if (valid)
1046 {
1047 add_new_message(etl::move(rhs.get()));
1048 }
1049
1050 return *this;
1051 }
1052 #endif
1053
1054 //********************************************
1056 {
1057 delete_current_message();
1058 }
1059
1060 //********************************************
1061 etl::imessage& get() ETL_NOEXCEPT
1062 {
1063 return *static_cast<etl::imessage*>(data);
1064 }
1065
1066 //********************************************
1067 const etl::imessage& get() const ETL_NOEXCEPT
1068 {
1069 return *static_cast<const etl::imessage*>(data);
1070 }
1071
1072 //********************************************
1073 bool is_valid() const
1074 {
1075 return valid;
1076 }
1077
1078 //**********************************************
1079 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
1080 {
1081 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
1082 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
1083 T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
1084 T13::ID == id || T14::ID == id;
1085 }
1086
1087 //**********************************************
1088 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
1089 {
1090 return accepts(msg.get_message_id());
1091 }
1092
1093 //**********************************************
1094 template <etl::message_id_t Id>
1095 static ETL_CONSTEXPR bool accepts()
1096 {
1097 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
1098 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
1099 T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
1100 T13::ID == Id || T14::ID == Id;
1101 }
1102
1103 //**********************************************
1104 template <typename TMessage>
1105 static ETL_CONSTEXPR
1107 accepts()
1108 {
1109 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
1110 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
1111 T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
1112 T13::ID == TMessage::ID || T14::ID == TMessage::ID;
1113 }
1114
1115 enum
1116 {
1119 };
1120
1121 private:
1122
1123 //********************************************
1125 void delete_current_message()
1126 {
1127 if (valid)
1128 {
1129 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1130
1131 pmsg->~imessage();
1132 }
1133 }
1135
1136 //********************************************
1137 void add_new_message(const etl::imessage& msg)
1138 {
1139 const size_t id = msg.get_message_id();
1140 void* p = data;
1141
1142 switch (id)
1143 {
1144 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1145 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1146 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1147 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1148 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1149 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1150 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1151 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1152 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
1153 case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
1154 case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
1155 case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
1156 case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
1157 case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
1158 default: break;
1159 }
1160 }
1161
1162 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1163 //********************************************
1164 void add_new_message(etl::imessage&& msg)
1165 {
1166 const size_t id = msg.get_message_id();
1167 void* p = data;
1168
1169 switch (id)
1170 {
1171 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1172 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1173 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1174 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1175 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1176 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1177 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1178 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1179 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
1180 case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
1181 case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
1182 case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
1183 case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
1184 case T14::ID: ::new (p) T14(static_cast<T14&&>(msg)); break;
1185 default: break;
1186 }
1187 }
1188 #endif
1189
1191 bool valid;
1192 };
1193
1194 //***************************************************************************
1195 // Specialisation for 13 message types.
1196 //***************************************************************************
1197 template <typename T1, typename T2, typename T3, typename T4,
1198 typename T5, typename T6, typename T7, typename T8,
1199 typename T9, typename T10, typename T11, typename T12,
1200 typename T13>
1201 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void>
1202 {
1203 public:
1204
1205 //********************************************
1208 : valid(false)
1209 {
1210 }
1212
1213 //********************************************
1215 explicit message_packet(const etl::imessage& msg)
1216 {
1217 if (accepts(msg))
1218 {
1219 add_new_message(msg);
1220 valid = true;
1221 }
1222 else
1223 {
1224 valid = false;
1225 }
1226
1227 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
1228 }
1230
1231 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1232 //********************************************
1234 explicit message_packet(etl::imessage&& msg)
1235 {
1236 if (accepts(msg))
1237 {
1238 add_new_message(etl::move(msg));
1239 valid = true;
1240 }
1241 else
1242 {
1243 valid = false;
1244 }
1245
1246 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
1247 }
1249 #endif
1250
1251 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
1252 //********************************************
1254 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
1256 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type>
1257 explicit message_packet(TMessage&& /*msg*/)
1258 : valid(true)
1259 {
1260 // Not etl::message_packet, not etl::imessage and in typelist.
1263 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value);
1264
1265 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
1266 }
1268 #else
1269 //********************************************
1271 template <typename TMessage>
1272 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> >::value &&
1273 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
1274 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, int>::type = 0)
1275 : valid(true)
1276 {
1277 // Not etl::message_packet, not etl::imessage and in typelist.
1280 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value);
1281
1282 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
1283 }
1285 #endif
1286
1287 //**********************************************
1289 message_packet(const message_packet& other)
1290 : valid(other.is_valid())
1291 {
1292 if (valid)
1293 {
1294 add_new_message(other.get());
1295 }
1296 }
1298
1299 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1300 //**********************************************
1303 : valid(other.is_valid())
1304 {
1305 if (valid)
1306 {
1307 add_new_message(etl::move(other.get()));
1308 }
1309 }
1311 #endif
1312
1313 //**********************************************
1314 message_packet& operator =(const message_packet& rhs)
1315 {
1316 delete_current_message();
1317 valid = rhs.is_valid();
1318 if (valid)
1319 {
1320 add_new_message(rhs.get());
1321 }
1322
1323 return *this;
1324 }
1325
1326 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1327 //**********************************************
1328 message_packet& operator =(message_packet&& rhs)
1329 {
1330 delete_current_message();
1331 valid = rhs.is_valid();
1332 if (valid)
1333 {
1334 add_new_message(etl::move(rhs.get()));
1335 }
1336
1337 return *this;
1338 }
1339 #endif
1340
1341 //********************************************
1343 {
1344 delete_current_message();
1345 }
1346
1347 //********************************************
1348 etl::imessage& get() ETL_NOEXCEPT
1349 {
1350 return *static_cast<etl::imessage*>(data);
1351 }
1352
1353 //********************************************
1354 const etl::imessage& get() const ETL_NOEXCEPT
1355 {
1356 return *static_cast<const etl::imessage*>(data);
1357 }
1358
1359 //********************************************
1360 bool is_valid() const
1361 {
1362 return valid;
1363 }
1364
1365 //**********************************************
1366 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
1367 {
1368 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
1369 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
1370 T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id ||
1371 T13::ID == id;
1372 }
1373
1374 //**********************************************
1375 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
1376 {
1377 return accepts(msg.get_message_id());
1378 }
1379
1380 //**********************************************
1381 template <etl::message_id_t Id>
1382 static ETL_CONSTEXPR bool accepts()
1383 {
1384 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
1385 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
1386 T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id ||
1387 T13::ID == Id;
1388 }
1389
1390 //**********************************************
1391 template <typename TMessage>
1392 static ETL_CONSTEXPR
1394 accepts()
1395 {
1396 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
1397 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
1398 T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID ||
1399 T13::ID == TMessage::ID;
1400 }
1401
1402 enum
1403 {
1406 };
1407
1408 private:
1409
1410 //********************************************
1412 void delete_current_message()
1413 {
1414 if (valid)
1415 {
1416 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1417
1418 pmsg->~imessage();
1419 }
1420 }
1422
1423 //********************************************
1424 void add_new_message(const etl::imessage& msg)
1425 {
1426 const size_t id = msg.get_message_id();
1427 void* p = data;
1428
1429 switch (id)
1430 {
1431 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1432 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1433 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1434 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1435 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1436 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1437 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1438 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1439 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
1440 case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
1441 case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
1442 case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
1443 case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
1444 default: break;
1445 }
1446 }
1447
1448 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1449 //********************************************
1450 void add_new_message(etl::imessage&& msg)
1451 {
1452 const size_t id = msg.get_message_id();
1453 void* p = data;
1454
1455 switch (id)
1456 {
1457 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1458 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1459 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1460 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1461 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1462 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1463 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1464 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1465 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
1466 case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
1467 case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
1468 case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
1469 case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
1470 default: break;
1471 }
1472 }
1473 #endif
1474
1476 bool valid;
1477 };
1478
1479 //***************************************************************************
1480 // Specialisation for 12 message types.
1481 //***************************************************************************
1482 template <typename T1, typename T2, typename T3, typename T4,
1483 typename T5, typename T6, typename T7, typename T8,
1484 typename T9, typename T10, typename T11, typename T12>
1485 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void>
1486 {
1487 public:
1488
1489 //********************************************
1492 : valid(false)
1493 {
1494 }
1496
1497 //********************************************
1499 explicit message_packet(const etl::imessage& msg)
1500 {
1501 if (accepts(msg))
1502 {
1503 add_new_message(msg);
1504 valid = true;
1505 }
1506 else
1507 {
1508 valid = false;
1509 }
1510
1511 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
1512 }
1514
1515 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1516 //********************************************
1518 explicit message_packet(etl::imessage&& msg)
1519 {
1520 if (accepts(msg))
1521 {
1522 add_new_message(etl::move(msg));
1523 valid = true;
1524 }
1525 else
1526 {
1527 valid = false;
1528 }
1529
1530 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
1531 }
1533 #endif
1534
1535 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
1536 //********************************************
1538 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
1540 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type>
1541 explicit message_packet(TMessage&& /*msg*/)
1542 : valid(true)
1543 {
1544 // Not etl::message_packet, not etl::imessage and in typelist.
1547 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value);
1548
1549 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
1550 }
1552 #else
1553 //********************************************
1555 template <typename TMessage>
1556 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> >::value &&
1557 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
1558 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, int>::type = 0)
1559 : valid(true)
1560 {
1561 // Not etl::message_packet, not etl::imessage and in typelist.
1564 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value);
1565
1566 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
1567 }
1569 #endif
1570
1571 //**********************************************
1573 message_packet(const message_packet& other)
1574 : valid(other.is_valid())
1575 {
1576 if (valid)
1577 {
1578 add_new_message(other.get());
1579 }
1580 }
1582
1583 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1584 //**********************************************
1587 : valid(other.is_valid())
1588 {
1589 if (valid)
1590 {
1591 add_new_message(etl::move(other.get()));
1592 }
1593 }
1595 #endif
1596
1597 //**********************************************
1598 message_packet& operator =(const message_packet& rhs)
1599 {
1600 delete_current_message();
1601 valid = rhs.is_valid();
1602 if (valid)
1603 {
1604 add_new_message(rhs.get());
1605 }
1606
1607 return *this;
1608 }
1609
1610 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1611 //**********************************************
1612 message_packet& operator =(message_packet&& rhs)
1613 {
1614 delete_current_message();
1615 valid = rhs.is_valid();
1616 if (valid)
1617 {
1618 add_new_message(etl::move(rhs.get()));
1619 }
1620
1621 return *this;
1622 }
1623 #endif
1624
1625 //********************************************
1627 {
1628 delete_current_message();
1629 }
1630
1631 //********************************************
1632 etl::imessage& get() ETL_NOEXCEPT
1633 {
1634 return *static_cast<etl::imessage*>(data);
1635 }
1636
1637 //********************************************
1638 const etl::imessage& get() const ETL_NOEXCEPT
1639 {
1640 return *static_cast<const etl::imessage*>(data);
1641 }
1642
1643 //********************************************
1644 bool is_valid() const
1645 {
1646 return valid;
1647 }
1648
1649 //**********************************************
1650 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
1651 {
1652 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
1653 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
1654 T9::ID == id || T10::ID == id || T11::ID == id || T12::ID == id;
1655 }
1656
1657 //**********************************************
1658 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
1659 {
1660 return accepts(msg.get_message_id());
1661 }
1662
1663 //**********************************************
1664 template <etl::message_id_t Id>
1665 static ETL_CONSTEXPR bool accepts()
1666 {
1667 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
1668 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
1669 T9::ID == Id || T10::ID == Id || T11::ID == Id || T12::ID == Id;
1670 }
1671
1672 //**********************************************
1673 template <typename TMessage>
1674 static ETL_CONSTEXPR
1676 accepts()
1677 {
1678 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
1679 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
1680 T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID || T12::ID == TMessage::ID;
1681 }
1682
1683 enum
1684 {
1687 };
1688
1689 private:
1690
1691 //********************************************
1693 void delete_current_message()
1694 {
1695 if (valid)
1696 {
1697 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1698
1699 pmsg->~imessage();
1700 }
1701 }
1703
1704 //********************************************
1705 void add_new_message(const etl::imessage& msg)
1706 {
1707 const size_t id = msg.get_message_id();
1708 void* p = data;
1709
1710 switch (id)
1711 {
1712 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1713 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1714 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1715 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1716 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1717 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1718 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1719 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1720 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
1721 case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
1722 case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
1723 case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
1724 default: break;
1725 }
1726 }
1727
1728 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1729 //********************************************
1730 void add_new_message(etl::imessage&& msg)
1731 {
1732 const size_t id = msg.get_message_id();
1733 void* p = data;
1734
1735 switch (id)
1736 {
1737 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1738 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1739 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1740 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1741 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1742 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1743 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1744 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1745 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
1746 case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
1747 case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
1748 case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
1749 default: break;
1750 }
1751 }
1752 #endif
1753
1755 bool valid;
1756 };
1757
1758 //***************************************************************************
1759 // Specialisation for 11 message types.
1760 //***************************************************************************
1761 template <typename T1, typename T2, typename T3, typename T4,
1762 typename T5, typename T6, typename T7, typename T8,
1763 typename T9, typename T10, typename T11>
1764 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void>
1765 {
1766 public:
1767
1768 //********************************************
1771 : valid(false)
1772 {
1773 }
1775
1776 //********************************************
1778 explicit message_packet(const etl::imessage& msg)
1779 {
1780 if (accepts(msg))
1781 {
1782 add_new_message(msg);
1783 valid = true;
1784 }
1785 else
1786 {
1787 valid = false;
1788 }
1789
1790 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
1791 }
1793
1794 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1795 //********************************************
1797 explicit message_packet(etl::imessage&& msg)
1798 {
1799 if (accepts(msg))
1800 {
1801 add_new_message(etl::move(msg));
1802 valid = true;
1803 }
1804 else
1805 {
1806 valid = false;
1807 }
1808
1809 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
1810 }
1812 #endif
1813
1814 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
1815 //********************************************
1817 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
1819 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type>
1820 explicit message_packet(TMessage&& /*msg*/)
1821 : valid(true)
1822 {
1823 // Not etl::message_packet, not etl::imessage and in typelist.
1826 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value);
1827
1828 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
1829 }
1831 #else
1832 //********************************************
1834 template <typename TMessage>
1835 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> >::value &&
1836 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
1837 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, int>::type = 0)
1838 : valid(true)
1839 {
1840 // Not etl::message_packet, not etl::imessage and in typelist.
1843 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value);
1844
1845 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
1846 }
1848 #endif
1849
1850 //**********************************************
1852 message_packet(const message_packet& other)
1853 : valid(other.is_valid())
1854 {
1855 if (valid)
1856 {
1857 add_new_message(other.get());
1858 }
1859 }
1861
1862 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1863 //**********************************************
1866 : valid(other.is_valid())
1867 {
1868 if (valid)
1869 {
1870 add_new_message(etl::move(other.get()));
1871 }
1872 }
1874 #endif
1875
1876 //**********************************************
1877 message_packet& operator =(const message_packet& rhs)
1878 {
1879 delete_current_message();
1880 valid = rhs.is_valid();
1881 if (valid)
1882 {
1883 add_new_message(rhs.get());
1884 }
1885
1886 return *this;
1887 }
1888
1889 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
1890 //**********************************************
1891 message_packet& operator =(message_packet&& rhs)
1892 {
1893 delete_current_message();
1894 valid = rhs.is_valid();
1895 if (valid)
1896 {
1897 add_new_message(etl::move(rhs.get()));
1898 }
1899
1900 return *this;
1901 }
1902 #endif
1903
1904 //********************************************
1906 {
1907 delete_current_message();
1908 }
1909
1910 //********************************************
1911 etl::imessage& get() ETL_NOEXCEPT
1912 {
1913 return *static_cast<etl::imessage*>(data);
1914 }
1915
1916 //********************************************
1917 const etl::imessage& get() const ETL_NOEXCEPT
1918 {
1919 return *static_cast<const etl::imessage*>(data);
1920 }
1921
1922 //********************************************
1923 bool is_valid() const
1924 {
1925 return valid;
1926 }
1927
1928 //**********************************************
1929 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
1930 {
1931 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
1932 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
1933 T9::ID == id || T10::ID == id || T11::ID == id;
1934 }
1935
1936 //**********************************************
1937 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
1938 {
1939 return accepts(msg.get_message_id());
1940 }
1941
1942 //**********************************************
1943 template <etl::message_id_t Id>
1944 static ETL_CONSTEXPR bool accepts()
1945 {
1946 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
1947 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
1948 T9::ID == Id || T10::ID == Id || T11::ID == Id;
1949 }
1950
1951 //**********************************************
1952 template <typename TMessage>
1953 static ETL_CONSTEXPR
1955 accepts()
1956 {
1957 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
1958 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
1959 T9::ID == TMessage::ID || T10::ID == TMessage::ID || T11::ID == TMessage::ID;
1960 }
1961
1962 enum
1963 {
1966 };
1967
1968 private:
1969
1970 //********************************************
1972 void delete_current_message()
1973 {
1974 if (valid)
1975 {
1976 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1977
1978 pmsg->~imessage();
1979 }
1980 }
1982
1983 //********************************************
1984 void add_new_message(const etl::imessage& msg)
1985 {
1986 const size_t id = msg.get_message_id();
1987 void* p = data;
1988
1989 switch (id)
1990 {
1991 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1992 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1993 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1994 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1995 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1996 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1997 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1998 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1999 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
2000 case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
2001 case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
2002 default: break;
2003 }
2004 }
2005
2006 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2007 //********************************************
2008 void add_new_message(etl::imessage&& msg)
2009 {
2010 const size_t id = msg.get_message_id();
2011 void* p = data;
2012
2013 switch (id)
2014 {
2015 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2016 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2017 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2018 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2019 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
2020 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
2021 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
2022 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
2023 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
2024 case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
2025 case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
2026 default: break;
2027 }
2028 }
2029 #endif
2030
2032 bool valid;
2033 };
2034
2035 //***************************************************************************
2036 // Specialisation for 10 message types.
2037 //***************************************************************************
2038 template <typename T1, typename T2, typename T3, typename T4,
2039 typename T5, typename T6, typename T7, typename T8,
2040 typename T9, typename T10>
2041 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void>
2042 {
2043 public:
2044
2045 //********************************************
2048 : valid(false)
2049 {
2050 }
2052
2053 //********************************************
2055 explicit message_packet(const etl::imessage& msg)
2056 {
2057 if (accepts(msg))
2058 {
2059 add_new_message(msg);
2060 valid = true;
2061 }
2062 else
2063 {
2064 valid = false;
2065 }
2066
2067 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2068 }
2070
2071 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2072 //********************************************
2074 explicit message_packet(etl::imessage&& msg)
2075 {
2076 if (accepts(msg))
2077 {
2078 add_new_message(etl::move(msg));
2079 valid = true;
2080 }
2081 else
2082 {
2083 valid = false;
2084 }
2085
2086 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2087 }
2089 #endif
2090
2091 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
2092 //********************************************
2094 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
2096 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type>
2097 explicit message_packet(TMessage&& /*msg*/)
2098 : valid(true)
2099 {
2100 // Not etl::message_packet, not etl::imessage and in typelist.
2103 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value);
2104
2105 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2106 }
2108 #else
2109 //********************************************
2111 template <typename TMessage>
2112 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value &&
2113 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
2114 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, int>::type = 0)
2115 : valid(true)
2116 {
2117 // Not etl::message_packet, not etl::imessage and in typelist.
2120 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value);
2121
2122 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2123 }
2125 #endif
2126
2127 //**********************************************
2129 message_packet(const message_packet& other)
2130 : valid(other.is_valid())
2131 {
2132 if (valid)
2133 {
2134 add_new_message(other.get());
2135 }
2136 }
2138
2139 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2140 //**********************************************
2143 : valid(other.is_valid())
2144 {
2145 if (valid)
2146 {
2147 add_new_message(etl::move(other.get()));
2148 }
2149 }
2151 #endif
2152
2153 //**********************************************
2154 message_packet& operator =(const message_packet& rhs)
2155 {
2156 delete_current_message();
2157 valid = rhs.is_valid();
2158 if (valid)
2159 {
2160 add_new_message(rhs.get());
2161 }
2162
2163 return *this;
2164 }
2165
2166 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2167 //**********************************************
2168 message_packet& operator =(message_packet&& rhs)
2169 {
2170 delete_current_message();
2171 valid = rhs.is_valid();
2172 if (valid)
2173 {
2174 add_new_message(etl::move(rhs.get()));
2175 }
2176
2177 return *this;
2178 }
2179 #endif
2180
2181 //********************************************
2183 {
2184 delete_current_message();
2185 }
2186
2187 //********************************************
2188 etl::imessage& get() ETL_NOEXCEPT
2189 {
2190 return *static_cast<etl::imessage*>(data);
2191 }
2192
2193 //********************************************
2194 const etl::imessage& get() const ETL_NOEXCEPT
2195 {
2196 return *static_cast<const etl::imessage*>(data);
2197 }
2198
2199 //********************************************
2200 bool is_valid() const
2201 {
2202 return valid;
2203 }
2204
2205 //**********************************************
2206 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
2207 {
2208 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
2209 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
2210 T9::ID == id || T10::ID == id;
2211 }
2212
2213 //**********************************************
2214 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
2215 {
2216 return accepts(msg.get_message_id());
2217 }
2218
2219 //**********************************************
2220 template <etl::message_id_t Id>
2221 static ETL_CONSTEXPR bool accepts()
2222 {
2223 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
2224 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
2225 T9::ID == Id || T10::ID == Id;
2226 }
2227
2228 //**********************************************
2229 template <typename TMessage>
2230 static ETL_CONSTEXPR
2232 accepts()
2233 {
2234 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
2235 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
2236 T9::ID == TMessage::ID || T10::ID == TMessage::ID;
2237 }
2238
2239 enum
2240 {
2243 };
2244
2245 private:
2246
2247 //********************************************
2249 void delete_current_message()
2250 {
2251 if (valid)
2252 {
2253 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2254
2255 pmsg->~imessage();
2256 }
2257 }
2259
2260 //********************************************
2261 void add_new_message(const etl::imessage& msg)
2262 {
2263 const size_t id = msg.get_message_id();
2264 void* p = data;
2265
2266 switch (id)
2267 {
2268 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2269 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2270 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2271 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
2272 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
2273 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
2274 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
2275 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
2276 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
2277 case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
2278 default: break;
2279 }
2280 }
2281
2282 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2283 //********************************************
2284 void add_new_message(etl::imessage&& msg)
2285 {
2286 const size_t id = msg.get_message_id();
2287 void* p = data;
2288
2289 switch (id)
2290 {
2291 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2292 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2293 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2294 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2295 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
2296 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
2297 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
2298 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
2299 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
2300 case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
2301 default: break;
2302 }
2303 }
2304 #endif
2305
2307 bool valid;
2308 };
2309
2310 //***************************************************************************
2311 // Specialisation for 9 message types.
2312 //***************************************************************************
2313 template <typename T1, typename T2, typename T3, typename T4,
2314 typename T5, typename T6, typename T7, typename T8,
2315 typename T9>
2316 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void>
2317 {
2318 public:
2319
2320 //********************************************
2323 : valid(false)
2324 {
2325 }
2327
2328 //********************************************
2330 explicit message_packet(const etl::imessage& msg)
2331 {
2332 if (accepts(msg))
2333 {
2334 add_new_message(msg);
2335 valid = true;
2336 }
2337 else
2338 {
2339 valid = false;
2340 }
2341
2342 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2343 }
2345
2346 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2347 //********************************************
2349 explicit message_packet(etl::imessage&& msg)
2350 {
2351 if (accepts(msg))
2352 {
2353 add_new_message(etl::move(msg));
2354 valid = true;
2355 }
2356 else
2357 {
2358 valid = false;
2359 }
2360
2361 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2362 }
2364 #endif
2365
2366 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
2367 //********************************************
2369 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
2371 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type>
2372 explicit message_packet(TMessage&& /*msg*/)
2373 : valid(true)
2374 {
2375 // Not etl::message_packet, not etl::imessage and in typelist.
2378 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9>::value);
2379
2380 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2381 }
2383 #else
2384 //********************************************
2386 template <typename TMessage>
2387 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value &&
2388 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
2389 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, int>::type = 0)
2390 : valid(true)
2391 {
2392 // Not etl::message_packet, not etl::imessage and in typelist.
2395 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8, T9>::value);
2396
2397 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2398 }
2400 #endif
2401
2402 //**********************************************
2404 message_packet(const message_packet& other)
2405 : valid(other.is_valid())
2406 {
2407 if (valid)
2408 {
2409 add_new_message(other.get());
2410 }
2411 }
2413
2414 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2415 //**********************************************
2418 : valid(other.is_valid())
2419 {
2420 if (valid)
2421 {
2422 add_new_message(etl::move(other.get()));
2423 }
2424 }
2426 #endif
2427
2428 //**********************************************
2429 message_packet& operator =(const message_packet& rhs)
2430 {
2431 delete_current_message();
2432 valid = rhs.is_valid();
2433 if (valid)
2434 {
2435 add_new_message(rhs.get());
2436 }
2437
2438 return *this;
2439 }
2440
2441 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2442 //**********************************************
2443 message_packet& operator =(message_packet&& rhs)
2444 {
2445 delete_current_message();
2446 valid = rhs.is_valid();
2447 if (valid)
2448 {
2449 add_new_message(etl::move(rhs.get()));
2450 }
2451
2452 return *this;
2453 }
2454 #endif
2455
2456 //********************************************
2458 {
2459 delete_current_message();
2460 }
2461
2462 //********************************************
2463 etl::imessage& get() ETL_NOEXCEPT
2464 {
2465 return *static_cast<etl::imessage*>(data);
2466 }
2467
2468 //********************************************
2469 const etl::imessage& get() const ETL_NOEXCEPT
2470 {
2471 return *static_cast<const etl::imessage*>(data);
2472 }
2473
2474 //********************************************
2475 bool is_valid() const
2476 {
2477 return valid;
2478 }
2479
2480 //**********************************************
2481 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
2482 {
2483 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
2484 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id ||
2485 T9::ID == id;
2486 }
2487
2488 //**********************************************
2489 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
2490 {
2491 return accepts(msg.get_message_id());
2492 }
2493
2494 //**********************************************
2495 template <etl::message_id_t Id>
2496 static ETL_CONSTEXPR bool accepts()
2497 {
2498 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
2499 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id ||
2500 T9::ID == Id;
2501 }
2502
2503 //**********************************************
2504 template <typename TMessage>
2505 static ETL_CONSTEXPR
2507 accepts()
2508 {
2509 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
2510 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID ||
2511 T9::ID == TMessage::ID;
2512 }
2513
2514 enum
2515 {
2518 };
2519
2520 private:
2521
2522 //********************************************
2524 void delete_current_message()
2525 {
2526 if (valid)
2527 {
2528 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2529
2530 pmsg->~imessage();
2531 }
2532 }
2534
2535 //********************************************
2536 void add_new_message(const etl::imessage& msg)
2537 {
2538 const size_t id = msg.get_message_id();
2539 void* p = data;
2540
2541 switch (id)
2542 {
2543 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2544 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2545 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2546 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
2547 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
2548 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
2549 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
2550 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
2551 case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
2552 default: break;
2553 }
2554 }
2555
2556 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2557 //********************************************
2558 void add_new_message(etl::imessage&& msg)
2559 {
2560 const size_t id = msg.get_message_id();
2561 void* p = data;
2562
2563 switch (id)
2564 {
2565 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2566 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2567 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2568 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2569 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
2570 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
2571 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
2572 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
2573 case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
2574 default: break;
2575 }
2576 }
2577 #endif
2578
2580 bool valid;
2581 };
2582
2583 //***************************************************************************
2584 // Specialisation for 8 message types.
2585 //***************************************************************************
2586 template <typename T1, typename T2, typename T3, typename T4,
2587 typename T5, typename T6, typename T7, typename T8>
2588 class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void>
2589 {
2590 public:
2591
2592 //********************************************
2595 : valid(false)
2596 {
2597 }
2599
2600 //********************************************
2602 explicit message_packet(const etl::imessage& msg)
2603 {
2604 if (accepts(msg))
2605 {
2606 add_new_message(msg);
2607 valid = true;
2608 }
2609 else
2610 {
2611 valid = false;
2612 }
2613
2614 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2615 }
2617
2618 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2619 //********************************************
2621 explicit message_packet(etl::imessage&& msg)
2622 {
2623 if (accepts(msg))
2624 {
2625 add_new_message(etl::move(msg));
2626 valid = true;
2627 }
2628 else
2629 {
2630 valid = false;
2631 }
2632
2633 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2634 }
2636 #endif
2637
2638 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
2639 //********************************************
2641 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
2643 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type>
2644 explicit message_packet(TMessage&& /*msg*/)
2645 : valid(true)
2646 {
2647 // Not etl::message_packet, not etl::imessage and in typelist.
2650 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8>::value);
2651
2652 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2653 }
2655 #else
2656 //********************************************
2658 template <typename TMessage>
2659 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> >::value &&
2660 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
2661 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7, T8>::value, int>::type = 0)
2662 : valid(true)
2663 {
2664 // Not etl::message_packet, not etl::imessage and in typelist.
2667 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7, T8>::value);
2668
2669 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2670 }
2672 #endif
2673
2674 //**********************************************
2676 message_packet(const message_packet& other)
2677 : valid(other.is_valid())
2678 {
2679 if (valid)
2680 {
2681 add_new_message(other.get());
2682 }
2683 }
2685
2686 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2687 //**********************************************
2690 : valid(other.is_valid())
2691 {
2692 if (valid)
2693 {
2694 add_new_message(etl::move(other.get()));
2695 }
2696 }
2698 #endif
2699
2700 //**********************************************
2701 message_packet& operator =(const message_packet& rhs)
2702 {
2703 delete_current_message();
2704 valid = rhs.is_valid();
2705 if (valid)
2706 {
2707 add_new_message(rhs.get());
2708 }
2709
2710 return *this;
2711 }
2712
2713 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2714 //**********************************************
2715 message_packet& operator =(message_packet&& rhs)
2716 {
2717 delete_current_message();
2718 valid = rhs.is_valid();
2719 if (valid)
2720 {
2721 add_new_message(etl::move(rhs.get()));
2722 }
2723
2724 return *this;
2725 }
2726 #endif
2727
2728 //********************************************
2730 {
2731 delete_current_message();
2732 }
2733
2734 //********************************************
2735 etl::imessage& get() ETL_NOEXCEPT
2736 {
2737 return *static_cast<etl::imessage*>(data);
2738 }
2739
2740 //********************************************
2741 const etl::imessage& get() const ETL_NOEXCEPT
2742 {
2743 return *static_cast<const etl::imessage*>(data);
2744 }
2745
2746 //********************************************
2747 bool is_valid() const
2748 {
2749 return valid;
2750 }
2751
2752 //**********************************************
2753 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
2754 {
2755 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
2756 T5::ID == id || T6::ID == id || T7::ID == id || T8::ID == id;
2757 }
2758
2759 //**********************************************
2760 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
2761 {
2762 return accepts(msg.get_message_id());
2763 }
2764
2765 //**********************************************
2766 template <etl::message_id_t Id>
2767 static ETL_CONSTEXPR bool accepts()
2768 {
2769 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
2770 T5::ID == Id || T6::ID == Id || T7::ID == Id || T8::ID == Id;
2771 }
2772
2773 //**********************************************
2774 template <typename TMessage>
2775 static ETL_CONSTEXPR
2777 accepts()
2778 {
2779 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
2780 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID || T8::ID == TMessage::ID;
2781 }
2782
2783 enum
2784 {
2787 };
2788
2789 private:
2790
2791 //********************************************
2793 void delete_current_message()
2794 {
2795 if (valid)
2796 {
2797 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2798
2799 pmsg->~imessage();
2800 }
2801 }
2803
2804 //********************************************
2805 void add_new_message(const etl::imessage& msg)
2806 {
2807 const size_t id = msg.get_message_id();
2808 void* p = data;
2809
2810 switch (id)
2811 {
2812 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2813 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2814 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2815 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
2816 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
2817 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
2818 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
2819 case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
2820 default: break;
2821 }
2822 }
2823
2824 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2825 //********************************************
2826 void add_new_message(etl::imessage&& msg)
2827 {
2828 const size_t id = msg.get_message_id();
2829 void* p = data;
2830
2831 switch (id)
2832 {
2833 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2834 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2835 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2836 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2837 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
2838 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
2839 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
2840 case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
2841 default: break;
2842 }
2843 }
2844 #endif
2845
2847 bool valid;
2848 };
2849
2850 //***************************************************************************
2851 // Specialisation for 7 message types.
2852 //***************************************************************************
2853 template <typename T1, typename T2, typename T3, typename T4,
2854 typename T5, typename T6, typename T7>
2855 class message_packet<T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void>
2856 {
2857 public:
2858
2859 //********************************************
2862 : valid(false)
2863 {
2864 }
2866
2867 //********************************************
2869 explicit message_packet(const etl::imessage& msg)
2870 {
2871 if (accepts(msg))
2872 {
2873 add_new_message(msg);
2874 valid = true;
2875 }
2876 else
2877 {
2878 valid = false;
2879 }
2880
2881 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2882 }
2884
2885 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2886 //********************************************
2888 explicit message_packet(etl::imessage&& msg)
2889 {
2890 if (accepts(msg))
2891 {
2892 add_new_message(etl::move(msg));
2893 valid = true;
2894 }
2895 else
2896 {
2897 valid = false;
2898 }
2899
2900 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
2901 }
2903 #endif
2904
2905 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
2906 //********************************************
2908 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
2910 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type>
2911 explicit message_packet(TMessage&& /*msg*/)
2912 : valid(true)
2913 {
2914 // Not etl::message_packet, not etl::imessage and in typelist.
2917 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7>::value);
2918
2919 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2920 }
2922 #else
2923 //********************************************
2925 template <typename TMessage>
2926 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6, T7> >::value &&
2927 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
2928 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6, T7>::value, int>::type = 0)
2929 : valid(true)
2930 {
2931 // Not etl::message_packet, not etl::imessage and in typelist.
2934 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6, T7>::value);
2935
2936 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
2937 }
2939 #endif
2940
2941 //**********************************************
2943 message_packet(const message_packet& other)
2944 : valid(other.is_valid())
2945 {
2946 if (valid)
2947 {
2948 add_new_message(other.get());
2949 }
2950 }
2952
2953 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2954 //**********************************************
2957 : valid(other.is_valid())
2958 {
2959 if (valid)
2960 {
2961 add_new_message(etl::move(other.get()));
2962 }
2963 }
2965 #endif
2966
2967 //**********************************************
2968 message_packet& operator =(const message_packet& rhs)
2969 {
2970 delete_current_message();
2971 valid = rhs.is_valid();
2972 if (valid)
2973 {
2974 add_new_message(rhs.get());
2975 }
2976
2977 return *this;
2978 }
2979
2980 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
2981 //**********************************************
2982 message_packet& operator =(message_packet&& rhs)
2983 {
2984 delete_current_message();
2985 valid = rhs.is_valid();
2986 if (valid)
2987 {
2988 add_new_message(etl::move(rhs.get()));
2989 }
2990
2991 return *this;
2992 }
2993 #endif
2994
2995 //********************************************
2997 {
2998 delete_current_message();
2999 }
3000
3001 //********************************************
3002 etl::imessage& get() ETL_NOEXCEPT
3003 {
3004 return *static_cast<etl::imessage*>(data);
3005 }
3006
3007 //********************************************
3008 const etl::imessage& get() const ETL_NOEXCEPT
3009 {
3010 return *static_cast<const etl::imessage*>(data);
3011 }
3012
3013 //********************************************
3014 bool is_valid() const
3015 {
3016 return valid;
3017 }
3018
3019 //**********************************************
3020 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
3021 {
3022 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
3023 T5::ID == id || T6::ID == id || T7::ID == id;
3024 }
3025
3026 //**********************************************
3027 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
3028 {
3029 return accepts(msg.get_message_id());
3030 }
3031
3032 //**********************************************
3033 template <etl::message_id_t Id>
3034 static ETL_CONSTEXPR bool accepts()
3035 {
3036 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
3037 T5::ID == Id || T6::ID == Id || T7::ID == Id;
3038 }
3039
3040 //**********************************************
3041 template <typename TMessage>
3042 static ETL_CONSTEXPR
3044 accepts()
3045 {
3046 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
3047 T5::ID == TMessage::ID || T6::ID == TMessage::ID || T7::ID == TMessage::ID;
3048 }
3049
3050 enum
3051 {
3054 };
3055
3056 private:
3057
3058 //********************************************
3060 void delete_current_message()
3061 {
3062 if (valid)
3063 {
3064 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
3065
3066 pmsg->~imessage();
3067 }
3068 }
3070
3071 //********************************************
3072 void add_new_message(const etl::imessage& msg)
3073 {
3074 const size_t id = msg.get_message_id();
3075 void* p = data;
3076
3077 switch (id)
3078 {
3079 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
3080 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
3081 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
3082 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
3083 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
3084 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
3085 case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
3086 default: break;
3087 }
3088 }
3089
3090 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3091 //********************************************
3092 void add_new_message(etl::imessage&& msg)
3093 {
3094 const size_t id = msg.get_message_id();
3095 void* p = data;
3096
3097 switch (id)
3098 {
3099 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
3100 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
3101 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
3102 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
3103 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
3104 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
3105 case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
3106 default: break;
3107 }
3108 }
3109 #endif
3110
3112 bool valid;
3113 };
3114
3115 //***************************************************************************
3116 // Specialisation for 6 message types.
3117 //***************************************************************************
3118 template <typename T1, typename T2, typename T3, typename T4,
3119 typename T5, typename T6>
3120 class message_packet<T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void>
3121 {
3122 public:
3123
3124 //********************************************
3127 : valid(false)
3128 {
3129 }
3131
3132 //********************************************
3134 explicit message_packet(const etl::imessage& msg)
3135 {
3136 if (accepts(msg))
3137 {
3138 add_new_message(msg);
3139 valid = true;
3140 }
3141 else
3142 {
3143 valid = false;
3144 }
3145
3146 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3147 }
3149
3150 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3151 //********************************************
3153 explicit message_packet(etl::imessage&& msg)
3154 {
3155 if (accepts(msg))
3156 {
3157 add_new_message(etl::move(msg));
3158 valid = true;
3159 }
3160 else
3161 {
3162 valid = false;
3163 }
3164
3165 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3166 }
3168 #endif
3169
3170 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
3171 //********************************************
3173 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
3175 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value, int>::type>
3176 explicit message_packet(TMessage&& /*msg*/)
3177 : valid(true)
3178 {
3179 // Not etl::message_packet, not etl::imessage and in typelist.
3182 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6>::value);
3183
3184 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3185 }
3187 #else
3188 //********************************************
3190 template <typename TMessage>
3191 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5, T6> >::value &&
3192 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
3193 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5, T6>::value, int>::type = 0)
3194 : valid(true)
3195 {
3196 // Not etl::message_packet, not etl::imessage and in typelist.
3199 etl::is_one_of<typename etl::remove_cvref<TMessage>::type,T1, T2, T3, T4, T5, T6>::value);
3200
3201 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3202 }
3204 #endif
3205
3206 //**********************************************
3208 message_packet(const message_packet& other)
3209 : valid(other.is_valid())
3210 {
3211 if (valid)
3212 {
3213 add_new_message(other.get());
3214 }
3215 }
3217
3218 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3219 //**********************************************
3222 : valid(other.is_valid())
3223 {
3224 if (valid)
3225 {
3226 add_new_message(etl::move(other.get()));
3227 }
3228 }
3230 #endif
3231
3232 //**********************************************
3233 message_packet& operator =(const message_packet& rhs)
3234 {
3235 delete_current_message();
3236 valid = rhs.is_valid();
3237 if (valid)
3238 {
3239 add_new_message(rhs.get());
3240 }
3241
3242 return *this;
3243 }
3244
3245 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3246 //**********************************************
3247 message_packet& operator =(message_packet&& rhs)
3248 {
3249 delete_current_message();
3250 valid = rhs.is_valid();
3251 if (valid)
3252 {
3253 add_new_message(etl::move(rhs.get()));
3254 }
3255
3256 return *this;
3257 }
3258 #endif
3259
3260 //********************************************
3262 {
3263 delete_current_message();
3264 }
3265
3266 //********************************************
3267 etl::imessage& get() ETL_NOEXCEPT
3268 {
3269 return *static_cast<etl::imessage*>(data);
3270 }
3271
3272 //********************************************
3273 const etl::imessage& get() const ETL_NOEXCEPT
3274 {
3275 return *static_cast<const etl::imessage*>(data);
3276 }
3277
3278 //********************************************
3279 bool is_valid() const
3280 {
3281 return valid;
3282 }
3283
3284 //**********************************************
3285 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
3286 {
3287 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
3288 T5::ID == id || T6::ID == id;
3289 }
3290
3291 //**********************************************
3292 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
3293 {
3294 return accepts(msg.get_message_id());
3295 }
3296
3297 //**********************************************
3298 template <etl::message_id_t Id>
3299 static ETL_CONSTEXPR bool accepts()
3300 {
3301 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
3302 T5::ID == Id || T6::ID == Id;
3303 }
3304
3305 //**********************************************
3306 template <typename TMessage>
3307 static ETL_CONSTEXPR
3309 accepts()
3310 {
3311 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
3312 T5::ID == TMessage::ID || T6::ID == TMessage::ID;
3313 }
3314
3315 enum
3316 {
3319 };
3320
3321 private:
3322
3323 //********************************************
3325 void delete_current_message()
3326 {
3327 if (valid)
3328 {
3329 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
3330
3331 pmsg->~imessage();
3332 }
3333 }
3335
3336 //********************************************
3337 void add_new_message(const etl::imessage& msg)
3338 {
3339 const size_t id = msg.get_message_id();
3340 void* p = data;
3341
3342 switch (id)
3343 {
3344 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
3345 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
3346 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
3347 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
3348 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
3349 case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
3350 default: break;
3351 }
3352 }
3353
3354 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3355 //********************************************
3356 void add_new_message(etl::imessage&& msg)
3357 {
3358 const size_t id = msg.get_message_id();
3359 void* p = data;
3360
3361 switch (id)
3362 {
3363 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
3364 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
3365 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
3366 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
3367 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
3368 case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
3369 default: break;
3370 }
3371 }
3372 #endif
3373
3375 bool valid;
3376 };
3377
3378 //***************************************************************************
3379 // Specialisation for 5 message types.
3380 //***************************************************************************
3381 template <typename T1, typename T2, typename T3, typename T4,
3382 typename T5>
3383 class message_packet<T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void>
3384 {
3385 public:
3386
3387 //********************************************
3390 : valid(false)
3391 {
3392 }
3394
3395 //********************************************
3397 explicit message_packet(const etl::imessage& msg)
3398 {
3399 if (accepts(msg))
3400 {
3401 add_new_message(msg);
3402 valid = true;
3403 }
3404 else
3405 {
3406 valid = false;
3407 }
3408
3409 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3410 }
3412
3413 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3414 //********************************************
3416 explicit message_packet(etl::imessage&& msg)
3417 {
3418 if (accepts(msg))
3419 {
3420 add_new_message(etl::move(msg));
3421 valid = true;
3422 }
3423 else
3424 {
3425 valid = false;
3426 }
3427
3428 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3429 }
3431 #endif
3432
3433 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
3434 //********************************************
3436 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
3438 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value, int>::type>
3439 explicit message_packet(TMessage&& /*msg*/)
3440 : valid(true)
3441 {
3442 // Not etl::message_packet, not etl::imessage and in typelist.
3446
3447 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3448 }
3450 #else
3451 //********************************************
3453 template <typename TMessage>
3454 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4, T5> >::value &&
3455 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
3456 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4, T5>::value, int>::type = 0)
3457 : valid(true)
3458 {
3459 // Not etl::message_packet, not etl::imessage and in typelist.
3463
3464 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3465 }
3467 #endif
3468
3469 //**********************************************
3471 message_packet(const message_packet& other)
3472 : valid(other.is_valid())
3473 {
3474 if (valid)
3475 {
3476 add_new_message(other.get());
3477 }
3478 }
3480
3481 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3482 //**********************************************
3485 : valid(other.is_valid())
3486 {
3487 if (valid)
3488 {
3489 add_new_message(etl::move(other.get()));
3490 }
3491 }
3493 #endif
3494
3495 //**********************************************
3496 message_packet& operator =(const message_packet& rhs)
3497 {
3498 delete_current_message();
3499 valid = rhs.is_valid();
3500 if (valid)
3501 {
3502 add_new_message(rhs.get());
3503 }
3504
3505 return *this;
3506 }
3507
3508 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3509 //**********************************************
3510 message_packet& operator =(message_packet&& rhs)
3511 {
3512 delete_current_message();
3513 valid = rhs.is_valid();
3514 if (valid)
3515 {
3516 add_new_message(etl::move(rhs.get()));
3517 }
3518
3519 return *this;
3520 }
3521 #endif
3522
3523 //********************************************
3525 {
3526 delete_current_message();
3527 }
3528
3529 //********************************************
3530 etl::imessage& get() ETL_NOEXCEPT
3531 {
3532 return *static_cast<etl::imessage*>(data);
3533 }
3534
3535 //********************************************
3536 const etl::imessage& get() const ETL_NOEXCEPT
3537 {
3538 return *static_cast<const etl::imessage*>(data);
3539 }
3540
3541 //********************************************
3542 bool is_valid() const
3543 {
3544 return valid;
3545 }
3546
3547 //**********************************************
3548 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
3549 {
3550 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id ||
3551 T5::ID == id;
3552 }
3553
3554 //**********************************************
3555 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
3556 {
3557 return accepts(msg.get_message_id());
3558 }
3559
3560 //**********************************************
3561 template <etl::message_id_t Id>
3562 static ETL_CONSTEXPR bool accepts()
3563 {
3564 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id ||
3565 T5::ID == Id;
3566 }
3567
3568 //**********************************************
3569 template <typename TMessage>
3570 static ETL_CONSTEXPR
3572 accepts()
3573 {
3574 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID ||
3575 T5::ID == TMessage::ID;
3576 }
3577
3578 enum
3579 {
3582 };
3583
3584 private:
3585
3586 //********************************************
3588 void delete_current_message()
3589 {
3590 if (valid)
3591 {
3592 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
3593
3594 pmsg->~imessage();
3595 }
3596 }
3598
3599 //********************************************
3600 void add_new_message(const etl::imessage& msg)
3601 {
3602 const size_t id = msg.get_message_id();
3603 void* p = data;
3604
3605 switch (id)
3606 {
3607 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
3608 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
3609 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
3610 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
3611 case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
3612 default: break;
3613 }
3614 }
3615
3616 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3617 //********************************************
3618 void add_new_message(etl::imessage&& msg)
3619 {
3620 const size_t id = msg.get_message_id();
3621 void* p = data;
3622
3623 switch (id)
3624 {
3625 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
3626 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
3627 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
3628 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
3629 case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
3630 default: break;
3631 }
3632 }
3633 #endif
3634
3636 bool valid;
3637 };
3638
3639 //***************************************************************************
3640 // Specialisation for 4 message types.
3641 //***************************************************************************
3642 template <typename T1, typename T2, typename T3, typename T4>
3643 class message_packet<T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void>
3644 {
3645 public:
3646
3647 //********************************************
3650 : valid(false)
3651 {
3652 }
3654
3655 //********************************************
3657 explicit message_packet(const etl::imessage& msg)
3658 {
3659 if (accepts(msg))
3660 {
3661 add_new_message(msg);
3662 valid = true;
3663 }
3664 else
3665 {
3666 valid = false;
3667 }
3668
3669 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3670 }
3672
3673 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3674 //********************************************
3676 explicit message_packet(etl::imessage&& msg)
3677 {
3678 if (accepts(msg))
3679 {
3680 add_new_message(etl::move(msg));
3681 valid = true;
3682 }
3683 else
3684 {
3685 valid = false;
3686 }
3687
3688 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3689 }
3691 #endif
3692
3693 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
3694 //********************************************
3696 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
3698 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value, int>::type>
3699 explicit message_packet(TMessage&& /*msg*/)
3700 : valid(true)
3701 {
3702 // Not etl::message_packet, not etl::imessage and in typelist.
3706
3707 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3708 }
3710 #else
3711 //********************************************
3713 template <typename TMessage>
3714 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3, T4> >::value &&
3715 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
3716 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3, T4>::value, int>::type = 0)
3717 : valid(true)
3718 {
3719 // Not etl::message_packet, not etl::imessage and in typelist.
3723
3724 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3725 }
3727 #endif
3728
3729 //**********************************************
3731 message_packet(const message_packet& other)
3732 : valid(other.is_valid())
3733 {
3734 if (valid)
3735 {
3736 add_new_message(other.get());
3737 }
3738 }
3740
3741 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3742 //**********************************************
3745 : valid(other.is_valid())
3746 {
3747 if (valid)
3748 {
3749 add_new_message(etl::move(other.get()));
3750 }
3751 }
3753 #endif
3754
3755 //**********************************************
3756 message_packet& operator =(const message_packet& rhs)
3757 {
3758 delete_current_message();
3759 valid = rhs.is_valid();
3760 if (valid)
3761 {
3762 add_new_message(rhs.get());
3763 }
3764
3765 return *this;
3766 }
3767
3768 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3769 //**********************************************
3770 message_packet& operator =(message_packet&& rhs)
3771 {
3772 delete_current_message();
3773 valid = rhs.is_valid();
3774 if (valid)
3775 {
3776 add_new_message(etl::move(rhs.get()));
3777 }
3778
3779 return *this;
3780 }
3781 #endif
3782
3783 //********************************************
3785 {
3786 delete_current_message();
3787 }
3788
3789 //********************************************
3790 etl::imessage& get() ETL_NOEXCEPT
3791 {
3792 return *static_cast<etl::imessage*>(data);
3793 }
3794
3795 //********************************************
3796 const etl::imessage& get() const ETL_NOEXCEPT
3797 {
3798 return *static_cast<const etl::imessage*>(data);
3799 }
3800
3801 //********************************************
3802 bool is_valid() const
3803 {
3804 return valid;
3805 }
3806
3807 //**********************************************
3808 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
3809 {
3810 return T1::ID == id || T2::ID == id || T3::ID == id || T4::ID == id;
3811 }
3812
3813 //**********************************************
3814 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
3815 {
3816 return accepts(msg.get_message_id());
3817 }
3818
3819 //**********************************************
3820 template <etl::message_id_t Id>
3821 static ETL_CONSTEXPR bool accepts()
3822 {
3823 return T1::ID == Id || T2::ID == Id || T3::ID == Id || T4::ID == Id;
3824 }
3825
3826 //**********************************************
3827 template <typename TMessage>
3828 static ETL_CONSTEXPR
3830 accepts()
3831 {
3832 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID || T4::ID == TMessage::ID;
3833 }
3834
3835 enum
3836 {
3839 };
3840
3841 private:
3842
3843 //********************************************
3845 void delete_current_message()
3846 {
3847 if (valid)
3848 {
3849 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
3850
3851 pmsg->~imessage();
3852 }
3853 }
3855
3856 //********************************************
3857 void add_new_message(const etl::imessage& msg)
3858 {
3859 const size_t id = msg.get_message_id();
3860 void* p = data;
3861
3862 switch (id)
3863 {
3864 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
3865 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
3866 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
3867 case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
3868 default: break;
3869 }
3870 }
3871
3872 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3873 //********************************************
3874 void add_new_message(etl::imessage&& msg)
3875 {
3876 const size_t id = msg.get_message_id();
3877 void* p = data;
3878
3879 switch (id)
3880 {
3881 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
3882 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
3883 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
3884 case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
3885 default: break;
3886 }
3887 }
3888 #endif
3889
3891 bool valid;
3892 };
3893
3894 //***************************************************************************
3895 // Specialisation for 3 message types.
3896 //***************************************************************************
3897 template <typename T1, typename T2, typename T3>
3898 class message_packet<T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void>
3899 {
3900 public:
3901
3902 //********************************************
3905 : valid(false)
3906 {
3907 }
3909
3910 //********************************************
3912 explicit message_packet(const etl::imessage& msg)
3913 {
3914 if (accepts(msg))
3915 {
3916 add_new_message(msg);
3917 valid = true;
3918 }
3919 else
3920 {
3921 valid = false;
3922 }
3923
3924 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3925 }
3927
3928 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3929 //********************************************
3931 explicit message_packet(etl::imessage&& msg)
3932 {
3933 if (accepts(msg))
3934 {
3935 add_new_message(etl::move(msg));
3936 valid = true;
3937 }
3938 else
3939 {
3940 valid = false;
3941 }
3942
3943 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
3944 }
3946 #endif
3947
3948 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
3949 //********************************************
3951 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
3953 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value, int>::type>
3954 explicit message_packet(TMessage&& /*msg*/)
3955 : valid(true)
3956 {
3957 // Not etl::message_packet, not etl::imessage and in typelist.
3961
3962 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3963 }
3965 #else
3966 //********************************************
3968 template <typename TMessage>
3969 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2, T3> >::value &&
3970 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
3971 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2, T3>::value, int>::type = 0)
3972 : valid(true)
3973 {
3974 // Not etl::message_packet, not etl::imessage and in typelist.
3978
3979 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
3980 }
3982 #endif
3983
3984 //**********************************************
3986 message_packet(const message_packet& other)
3987 : valid(other.is_valid())
3988 {
3989 if (valid)
3990 {
3991 add_new_message(other.get());
3992 }
3993 }
3995
3996 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
3997 //**********************************************
4000 : valid(other.is_valid())
4001 {
4002 if (valid)
4003 {
4004 add_new_message(etl::move(other.get()));
4005 }
4006 }
4008 #endif
4009
4010 //**********************************************
4011 message_packet& operator =(const message_packet& rhs)
4012 {
4013 delete_current_message();
4014 valid = rhs.is_valid();
4015 if (valid)
4016 {
4017 add_new_message(rhs.get());
4018 }
4019
4020 return *this;
4021 }
4022
4023 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4024 //**********************************************
4025 message_packet& operator =(message_packet&& rhs)
4026 {
4027 delete_current_message();
4028 valid = rhs.is_valid();
4029 if (valid)
4030 {
4031 add_new_message(etl::move(rhs.get()));
4032 }
4033
4034 return *this;
4035 }
4036 #endif
4037
4038 //********************************************
4040 {
4041 delete_current_message();
4042 }
4043
4044 //********************************************
4045 etl::imessage& get() ETL_NOEXCEPT
4046 {
4047 return *static_cast<etl::imessage*>(data);
4048 }
4049
4050 //********************************************
4051 const etl::imessage& get() const ETL_NOEXCEPT
4052 {
4053 return *static_cast<const etl::imessage*>(data);
4054 }
4055
4056 //********************************************
4057 bool is_valid() const
4058 {
4059 return valid;
4060 }
4061
4062 //**********************************************
4063 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
4064 {
4065 return T1::ID == id || T2::ID == id || T3::ID == id;
4066 }
4067
4068 //**********************************************
4069 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
4070 {
4071 return accepts(msg.get_message_id());
4072 }
4073
4074 //**********************************************
4075 template <etl::message_id_t Id>
4076 static ETL_CONSTEXPR bool accepts()
4077 {
4078 return T1::ID == Id || T2::ID == Id || T3::ID == Id;
4079 }
4080
4081 //**********************************************
4082 template <typename TMessage>
4083 static ETL_CONSTEXPR
4085 accepts()
4086 {
4087 return T1::ID == TMessage::ID || T2::ID == TMessage::ID || T3::ID == TMessage::ID;
4088 }
4089
4090 enum
4091 {
4094 };
4095
4096 private:
4097
4098 //********************************************
4100 void delete_current_message()
4101 {
4102 if (valid)
4103 {
4104 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
4105
4106 pmsg->~imessage();
4107 }
4108 }
4110
4111 //********************************************
4112 void add_new_message(const etl::imessage& msg)
4113 {
4114 const size_t id = msg.get_message_id();
4115 void* p = data;
4116
4117 switch (id)
4118 {
4119 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
4120 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
4121 case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
4122 default: break;
4123 }
4124 }
4125
4126 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4127 //********************************************
4128 void add_new_message(etl::imessage&& msg)
4129 {
4130 const size_t id = msg.get_message_id();
4131 void* p = data;
4132
4133 switch (id)
4134 {
4135 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
4136 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
4137 case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
4138 default: break;
4139 }
4140 }
4141 #endif
4142
4144 bool valid;
4145 };
4146
4147 //***************************************************************************
4148 // Specialisation for 2 message types.
4149 //***************************************************************************
4150 template <typename T1, typename T2>
4151 class message_packet<T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
4152 {
4153 public:
4154
4155 //********************************************
4158 : valid(false)
4159 {
4160 }
4162
4163 //********************************************
4165 explicit message_packet(const etl::imessage& msg)
4166 {
4167 if (accepts(msg))
4168 {
4169 add_new_message(msg);
4170 valid = true;
4171 }
4172 else
4173 {
4174 valid = false;
4175 }
4176
4177 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
4178 }
4180
4181 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4182 //********************************************
4184 explicit message_packet(etl::imessage&& msg)
4185 {
4186 if (accepts(msg))
4187 {
4188 add_new_message(etl::move(msg));
4189 valid = true;
4190 }
4191 else
4192 {
4193 valid = false;
4194 }
4195
4196 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
4197 }
4199 #endif
4200
4201 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
4202 //********************************************
4204 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
4207 explicit message_packet(TMessage&& /*msg*/)
4208 : valid(true)
4209 {
4210 // Not etl::message_packet, not etl::imessage and in typelist.
4214
4215 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
4216 }
4218 #else
4219 //********************************************
4221 template <typename TMessage>
4222 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1, T2> >::value &&
4223 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
4224 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1, T2>::value, int>::type = 0)
4225 : valid(true)
4226 {
4227 // Not etl::message_packet, not etl::imessage and in typelist.
4231
4232 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
4233 }
4235 #endif
4236
4237 //**********************************************
4239 message_packet(const message_packet& other)
4240 : valid(other.is_valid())
4241 {
4242 if (valid)
4243 {
4244 add_new_message(other.get());
4245 }
4246 }
4248
4249 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4250 //**********************************************
4253 : valid(other.is_valid())
4254 {
4255 if (valid)
4256 {
4257 add_new_message(etl::move(other.get()));
4258 }
4259 }
4261 #endif
4262
4263 //**********************************************
4264 message_packet& operator =(const message_packet& rhs)
4265 {
4266 delete_current_message();
4267 valid = rhs.is_valid();
4268 if (valid)
4269 {
4270 add_new_message(rhs.get());
4271 }
4272
4273 return *this;
4274 }
4275
4276 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4277 //**********************************************
4278 message_packet& operator =(message_packet&& rhs)
4279 {
4280 delete_current_message();
4281 valid = rhs.is_valid();
4282 if (valid)
4283 {
4284 add_new_message(etl::move(rhs.get()));
4285 }
4286
4287 return *this;
4288 }
4289 #endif
4290
4291 //********************************************
4293 {
4294 delete_current_message();
4295 }
4296
4297 //********************************************
4298 etl::imessage& get() ETL_NOEXCEPT
4299 {
4300 return *static_cast<etl::imessage*>(data);
4301 }
4302
4303 //********************************************
4304 const etl::imessage& get() const ETL_NOEXCEPT
4305 {
4306 return *static_cast<const etl::imessage*>(data);
4307 }
4308
4309 //********************************************
4310 bool is_valid() const
4311 {
4312 return valid;
4313 }
4314
4315 //**********************************************
4316 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
4317 {
4318 return T1::ID == id || T2::ID == id;
4319 }
4320
4321 //**********************************************
4322 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
4323 {
4324 return accepts(msg.get_message_id());
4325 }
4326
4327 //**********************************************
4328 template <etl::message_id_t Id>
4329 static ETL_CONSTEXPR bool accepts()
4330 {
4331 return T1::ID == Id || T2::ID == Id;
4332 }
4333
4334 //**********************************************
4335 template <typename TMessage>
4336 static ETL_CONSTEXPR
4338 accepts()
4339 {
4340 return T1::ID == TMessage::ID || T2::ID == TMessage::ID;
4341 }
4342
4343 enum
4344 {
4347 };
4348
4349 private:
4350
4351 //********************************************
4353 void delete_current_message()
4354 {
4355 if (valid)
4356 {
4357 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
4358
4359 pmsg->~imessage();
4360 }
4361 }
4363
4364 //********************************************
4365 void add_new_message(const etl::imessage& msg)
4366 {
4367 const size_t id = msg.get_message_id();
4368 void* p = data;
4369
4370 switch (id)
4371 {
4372 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
4373 case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
4374 default: break;
4375 }
4376 }
4377
4378 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4379 //********************************************
4380 void add_new_message(etl::imessage&& msg)
4381 {
4382 const size_t id = msg.get_message_id();
4383 void* p = data;
4384
4385 switch (id)
4386 {
4387 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
4388 case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
4389 default: break;
4390 }
4391 }
4392 #endif
4393
4395 bool valid;
4396 };
4397
4398 //***************************************************************************
4399 // Specialisation for 1 message type.
4400 //***************************************************************************
4401 template <typename T1>
4402 class message_packet<T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
4403 {
4404 public:
4405
4406 //********************************************
4409 : valid(false)
4410 {
4411 }
4413
4414 //********************************************
4416 explicit message_packet(const etl::imessage& msg)
4417 {
4418 if (accepts(msg))
4419 {
4420 add_new_message(msg);
4421 valid = true;
4422 }
4423 else
4424 {
4425 valid = false;
4426 }
4427
4428 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
4429 }
4431
4432 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4433 //********************************************
4435 explicit message_packet(etl::imessage&& msg)
4436 {
4437 if (accepts(msg))
4438 {
4439 add_new_message(etl::move(msg));
4440 valid = true;
4441 }
4442 else
4443 {
4444 valid = false;
4445 }
4446
4447 ETL_ASSERT(valid, ETL_ERROR(unhandled_message_exception));
4448 }
4450 #endif
4451
4452 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION) && !defined(ETL_COMPILER_GREEN_HILLS)
4453 //********************************************
4455 template <typename TMessage, typename = typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
4458 explicit message_packet(TMessage&& /*msg*/)
4459 : valid(true)
4460 {
4461 // Not etl::message_packet, not etl::imessage and in typelist.
4462 static constexpr bool Enabled = (!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
4465
4466 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
4467 }
4469 #else
4470 //********************************************
4472 template <typename TMessage>
4473 explicit message_packet(const TMessage& /*msg*/, typename etl::enable_if<!etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::message_packet<T1> >::value &&
4474 !etl::is_same<typename etl::remove_cvref<TMessage>::type, etl::imessage>::value &&
4475 !etl::is_one_of<typename etl::remove_cvref<TMessage>::type, T1>::value, int>::type = 0)
4476 : valid(true)
4477 {
4478 // Not etl::message_packet, not etl::imessage and in typelist.
4482
4483 ETL_STATIC_ASSERT(Enabled, "Message not in packet type list");
4484 }
4486 #endif
4487
4488 //**********************************************
4490 message_packet(const message_packet& other)
4491 : valid(other.is_valid())
4492 {
4493 if (valid)
4494 {
4495 add_new_message(other.get());
4496 }
4497 }
4499
4500 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4501 //**********************************************
4504 : valid(other.is_valid())
4505 {
4506 if (valid)
4507 {
4508 add_new_message(etl::move(other.get()));
4509 }
4510 }
4512 #endif
4513
4514 //**********************************************
4515 message_packet& operator =(const message_packet& rhs)
4516 {
4517 delete_current_message();
4518 valid = rhs.is_valid();
4519 if (valid)
4520 {
4521 add_new_message(rhs.get());
4522 }
4523
4524 return *this;
4525 }
4526
4527 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4528 //**********************************************
4529 message_packet& operator =(message_packet&& rhs)
4530 {
4531 delete_current_message();
4532 valid = rhs.is_valid();
4533 if (valid)
4534 {
4535 add_new_message(etl::move(rhs.get()));
4536 }
4537
4538 return *this;
4539 }
4540 #endif
4541
4542 //********************************************
4544 {
4545 delete_current_message();
4546 }
4547
4548 //********************************************
4549 etl::imessage& get() ETL_NOEXCEPT
4550 {
4551 return *static_cast<etl::imessage*>(data);
4552 }
4553
4554 //********************************************
4555 const etl::imessage& get() const ETL_NOEXCEPT
4556 {
4557 return *static_cast<const etl::imessage*>(data);
4558 }
4559
4560 //********************************************
4561 bool is_valid() const
4562 {
4563 return valid;
4564 }
4565
4566 //**********************************************
4567 static ETL_CONSTEXPR bool accepts(etl::message_id_t id)
4568 {
4569 return T1::ID == id;
4570 }
4571
4572 //**********************************************
4573 static ETL_CONSTEXPR bool accepts(const etl::imessage& msg)
4574 {
4575 return accepts(msg.get_message_id());
4576 }
4577
4578 //**********************************************
4579 template <etl::message_id_t Id>
4580 static ETL_CONSTEXPR bool accepts()
4581 {
4582 return T1::ID == Id;
4583 }
4584
4585 //**********************************************
4586 template <typename TMessage>
4587 static ETL_CONSTEXPR
4589 accepts()
4590 {
4591 return T1::ID == TMessage::ID;
4592 }
4593
4594 enum
4595 {
4597 ALIGNMENT = etl::largest<T1>::alignment
4598 };
4599
4600 private:
4601
4602 //********************************************
4604 void delete_current_message()
4605 {
4606 if (valid)
4607 {
4608 etl::imessage* pmsg = static_cast<etl::imessage*>(data);
4609
4610 pmsg->~imessage();
4611 }
4612 }
4614
4615 //********************************************
4616 void add_new_message(const etl::imessage& msg)
4617 {
4618 const size_t id = msg.get_message_id();
4619 void* p = data;
4620
4621 switch (id)
4622 {
4623 case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
4624 default: break;
4625 }
4626 }
4627
4628 #if ETL_USING_CPP11 && !defined(ETL_MESSAGE_PACKET_FORCE_CPP03_IMPLEMENTATION)
4629 //********************************************
4630 void add_new_message(etl::imessage&& msg)
4631 {
4632 const size_t id = msg.get_message_id();
4633 void* p = data;
4634
4635 switch (id)
4636 {
4637 case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
4638 default: break;
4639 }
4640 }
4641 #endif
4642
4644 bool valid;
4645 };
4646#endif
4647}
4648
4649#endif
Definition: message.h:69
Definition: message_packet.h:335
Definition: message.h:56
#define ETL_ASSERT(b, e)
Definition: error_handler.h:316
Definition: largest.h:367
enable_if
Definition: type_traits_generator.h:1191
is_same
Definition: type_traits_generator.h:1041
bitset_ext
Definition: absolute.h:38
uint_least8_t message_id_t
Allow alternative type for message id.
Definition: message_types.h:40
Definition: alignment.h:223
Definition: type_traits.h:1376