Embedded Template Library  1.0
message_packet.h
1 /******************************************************************************
2 The MIT License(MIT)
3 
4 Embedded Template Library.
5 https://github.com/ETLCPP/etl
6 https://www.etlcpp.com
7 
8 Copyright(c) 2020 jwellbelove
9 
10 Permission is hereby granted, free of charge, to any person obtaining a copy
11 of this software and associated documentation files(the "Software"), to deal
12 in the Software without restriction, including without limitation the rights
13 to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
14 copies of the Software, and to permit persons to whom the Software is
15 furnished to do so, subject to the following conditions :
16 
17 The above copyright notice and this permission notice shall be included in all
18 copies or substantial portions of the Software.
19 
20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
23 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 SOFTWARE.
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 
63 #undef ETL_FILE
64 #define ETL_FILE "55"
65 
66 namespace etl
67 {
68  //***************************************************************************
69  // The definition for all 16 message types.
70  //***************************************************************************
71  template <typename T1, typename T2 = void, typename T3 = void, typename T4 = void,
72  typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void,
73  typename T9 = void, typename T10 = void, typename T11 = void, typename T12 = void,
74  typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void>
76  {
77  public:
78 
79  //********************************************
81  : valid(false)
82  {
83  }
84 
85  //********************************************
86  explicit message_packet(const etl::imessage& msg)
87  : valid(true)
88  {
89  add_new_message(msg);
90  }
91 
92  #if ETL_CPP11_SUPPORTED
93  //********************************************
94  explicit message_packet(etl::imessage&& msg)
95  : valid(true)
96  {
97  add_new_message(etl::move(msg));
98  }
99  #endif
100 
101  //**********************************************
102  message_packet(const message_packet& other)
103  : valid(other.is_valid())
104  {
105  if (valid)
106  {
107  add_new_message(other.get());
108  }
109  }
110 
111  #if ETL_CPP11_SUPPORTED
112  //**********************************************
114  : valid(other.is_valid())
115  {
116  if (valid)
117  {
118  add_new_message(etl::move(other.get()));
119  }
120  }
121  #endif
122 
123  //**********************************************
124  message_packet& operator =(const message_packet& rhs)
125  {
126  delete_current_message();
127  valid = rhs.is_valid();
128  if (valid)
129  {
130  add_new_message(rhs.get());
131  }
132 
133  return *this;
134  }
135 
136  #if ETL_CPP11_SUPPORTED
137  //**********************************************
138  message_packet& operator =(message_packet&& rhs)
139  {
140  delete_current_message();
141  valid = rhs.is_valid();
142  if (valid)
143  {
144  add_new_message(etl::move(rhs.get()));
145  }
146 
147  return *this;
148  }
149  #endif
150 
151  //********************************************
152  ~message_packet()
153  {
154  delete_current_message();
155  }
156 
157  //********************************************
158  etl::imessage& get() ETL_NOEXCEPT
159  {
160  return *static_cast<etl::imessage*>(data);
161  }
162 
163  //********************************************
164  const etl::imessage& get() const ETL_NOEXCEPT
165  {
166  return *static_cast<const etl::imessage*>(data);
167  }
168 
169  //********************************************
170  bool is_valid() const
171  {
172  return valid;
173  }
174 
175  enum
176  {
179  };
180 
181  private:
182 
183  //********************************************
184  void delete_current_message()
185  {
186  if (valid)
187  {
188  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
189 
190  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
191  pmsg->~imessage();
192  #else
193  size_t id = pmsg->message_id;
194 
195  switch (id)
196  {
197  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
198  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
199  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
200  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
201  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
202  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
203  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
204  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
205  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
206  case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
207  case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
208  case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
209  case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
210  case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
211  case T15::ID: static_cast<T15*>(pmsg)->~T15(); break;
212  case T16::ID: static_cast<T16*>(pmsg)->~T16(); break;
213  default: assert(false); break;
214  }
215  #endif
216  }
217  }
218 
219  //********************************************
220  void add_new_message(const etl::imessage& msg)
221  {
222  const size_t id = msg.message_id;
223  void* p = data;
224 
225  switch (id)
226  {
227  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
228  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
229  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
230  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
231  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
232  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
233  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
234  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
235  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
236  case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
237  case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
238  case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
239  case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
240  case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
241  case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
242  case T16::ID: ::new (p) T16(static_cast<const T16&>(msg)); break;
243  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
244  }
245  }
246 
247  #if ETL_CPP11_SUPPORTED
248  //********************************************
249  void add_new_message(etl::imessage&& msg)
250  {
251  const size_t id = msg.message_id;
252  void* p = data;
253 
254  switch (id)
255  {
256  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
257  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
258  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
259  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
260  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
261  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
262  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
263  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
264  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
265  case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
266  case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
267  case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
268  case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
269  case T14::ID: ::new (p) T14(static_cast<T14&&>(msg)); break;
270  case T15::ID: ::new (p) T15(static_cast<T15&&>(msg)); break;
271  case T16::ID: ::new (p) T16(static_cast<T16&&>(msg)); break;
272  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
273  }
274  }
275  #endif
276 
278  bool valid;
279  };
280 
281  //***************************************************************************
282  // Specialisation for 15 message types.
283  //***************************************************************************
284  template <typename T1, typename T2, typename T3, typename T4,
285  typename T5, typename T6, typename T7, typename T8,
286  typename T9, typename T10, typename T11, typename T12,
287  typename T13, typename T14, typename T15>
288  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void>
289  {
290  public:
291 
292  //********************************************
294  : valid(false)
295  {
296  }
297 
298  //********************************************
299  explicit message_packet(const etl::imessage& msg)
300  : valid(true)
301  {
302  add_new_message(msg);
303  }
304 
305  #if ETL_CPP11_SUPPORTED
306  //********************************************
307  explicit message_packet(etl::imessage&& msg)
308  : valid(true)
309  {
310  add_new_message(etl::move(msg));
311  }
312  #endif
313 
314  //**********************************************
315  message_packet(const message_packet& other)
316  : valid(other.is_valid())
317  {
318  if (valid)
319  {
320  add_new_message(other.get());
321  }
322  }
323 
324  #if ETL_CPP11_SUPPORTED
325  //**********************************************
327  : valid(other.is_valid())
328  {
329  if (valid)
330  {
331  add_new_message(etl::move(other.get()));
332  }
333  }
334  #endif
335 
336  //**********************************************
337  message_packet& operator =(const message_packet& rhs)
338  {
339  delete_current_message();
340  valid = rhs.is_valid();
341  if (valid)
342  {
343  add_new_message(rhs.get());
344  }
345 
346  return *this;
347  }
348 
349  #if ETL_CPP11_SUPPORTED
350  //**********************************************
351  message_packet& operator =(message_packet&& rhs)
352  {
353  delete_current_message();
354  valid = rhs.is_valid();
355  if (valid)
356  {
357  add_new_message(etl::move(rhs.get()));
358  }
359 
360  return *this;
361  }
362  #endif
363 
364  //********************************************
365  ~message_packet()
366  {
367  delete_current_message();
368  }
369 
370  //********************************************
371  etl::imessage& get() ETL_NOEXCEPT
372  {
373  return *static_cast<etl::imessage*>(data);
374  }
375 
376  //********************************************
377  const etl::imessage& get() const ETL_NOEXCEPT
378  {
379  return *static_cast<const etl::imessage*>(data);
380  }
381 
382  //********************************************
383  bool is_valid() const
384  {
385  return valid;
386  }
387 
388  enum
389  {
392  };
393 
394  private:
395 
396  //********************************************
397  void delete_current_message()
398  {
399  if (valid)
400  {
401  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
402 
403  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
404  pmsg->~imessage();
405  #else
406  size_t id = pmsg->message_id;
407 
408  switch (id)
409  {
410  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
411  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
412  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
413  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
414  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
415  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
416  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
417  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
418  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
419  case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
420  case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
421  case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
422  case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
423  case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
424  case T15::ID: static_cast<T15*>(pmsg)->~T15(); break;
425  default: assert(false); break;
426  }
427  #endif
428  }
429  }
430 
431  //********************************************
432  void add_new_message(const etl::imessage& msg)
433  {
434  const size_t id = msg.message_id;
435  void* p = data;
436 
437  switch (id)
438  {
439  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
440  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
441  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
442  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
443  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
444  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
445  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
446  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
447  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
448  case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
449  case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
450  case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
451  case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
452  case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
453  case T15::ID: ::new (p) T15(static_cast<const T15&>(msg)); break;
454  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
455  }
456  }
457 
458  #if ETL_CPP11_SUPPORTED
459  //********************************************
460  void add_new_message(etl::imessage&& msg)
461  {
462  const size_t id = msg.message_id;
463  void* p = data;
464 
465  switch (id)
466  {
467  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
468  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
469  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
470  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
471  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
472  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
473  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
474  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
475  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
476  case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
477  case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
478  case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
479  case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
480  case T14::ID: ::new (p) T14(static_cast<T14&&>(msg)); break;
481  case T15::ID: ::new (p) T15(static_cast<T15&&>(msg)); break;
482  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
483  }
484  }
485  #endif
486 
488  bool valid;
489  };
490 
491  //***************************************************************************
492  // Specialisation for 14 message types.
493  //***************************************************************************
494  template <typename T1, typename T2, typename T3, typename T4,
495  typename T5, typename T6, typename T7, typename T8,
496  typename T9, typename T10, typename T11, typename T12,
497  typename T13, typename T14>
498  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void>
499  {
500  public:
501 
502  //********************************************
504  : valid(false)
505  {
506  }
507 
508  //********************************************
509  explicit message_packet(const etl::imessage& msg)
510  : valid(true)
511  {
512  add_new_message(msg);
513  }
514 
515  #if ETL_CPP11_SUPPORTED
516  //********************************************
517  explicit message_packet(etl::imessage&& msg)
518  : valid(true)
519  {
520  add_new_message(etl::move(msg));
521  }
522  #endif
523 
524  //**********************************************
525  message_packet(const message_packet& other)
526  : valid(other.is_valid())
527  {
528  if (valid)
529  {
530  add_new_message(other.get());
531  }
532  }
533 
534  #if ETL_CPP11_SUPPORTED
535  //**********************************************
537  : valid(other.is_valid())
538  {
539  if (valid)
540  {
541  add_new_message(etl::move(other.get()));
542  }
543  }
544  #endif
545 
546  //**********************************************
547  message_packet& operator =(const message_packet& rhs)
548  {
549  delete_current_message();
550  valid = rhs.is_valid();
551  if (valid)
552  {
553  add_new_message(rhs.get());
554  }
555 
556  return *this;
557  }
558 
559  #if ETL_CPP11_SUPPORTED
560  //**********************************************
561  message_packet& operator =(message_packet&& rhs)
562  {
563  delete_current_message();
564  valid = rhs.is_valid();
565  if (valid)
566  {
567  add_new_message(etl::move(rhs.get()));
568  }
569 
570  return *this;
571  }
572  #endif
573 
574  //********************************************
575  ~message_packet()
576  {
577  delete_current_message();
578  }
579 
580  //********************************************
581  etl::imessage& get() ETL_NOEXCEPT
582  {
583  return *static_cast<etl::imessage*>(data);
584  }
585 
586  //********************************************
587  const etl::imessage& get() const ETL_NOEXCEPT
588  {
589  return *static_cast<const etl::imessage*>(data);
590  }
591 
592  //********************************************
593  bool is_valid() const
594  {
595  return valid;
596  }
597 
598  enum
599  {
602  };
603 
604  private:
605 
606  //********************************************
607  void delete_current_message()
608  {
609  if (valid)
610  {
611  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
612 
613  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
614  pmsg->~imessage();
615  #else
616  size_t id = pmsg->message_id;
617 
618  switch (id)
619  {
620  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
621  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
622  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
623  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
624  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
625  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
626  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
627  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
628  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
629  case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
630  case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
631  case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
632  case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
633  case T14::ID: static_cast<T14*>(pmsg)->~T14(); break;
634  default: assert(false); break;
635  }
636  #endif
637  }
638  }
639 
640  //********************************************
641  void add_new_message(const etl::imessage& msg)
642  {
643  const size_t id = msg.message_id;
644  void* p = data;
645 
646  switch (id)
647  {
648  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
649  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
650  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
651  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
652  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
653  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
654  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
655  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
656  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
657  case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
658  case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
659  case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
660  case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
661  case T14::ID: ::new (p) T14(static_cast<const T14&>(msg)); break;
662  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
663  }
664  }
665 
666  #if ETL_CPP11_SUPPORTED
667  //********************************************
668  void add_new_message(etl::imessage&& msg)
669  {
670  const size_t id = msg.message_id;
671  void* p = data;
672 
673  switch (id)
674  {
675  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
676  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
677  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
678  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
679  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
680  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
681  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
682  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
683  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
684  case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
685  case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
686  case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
687  case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
688  case T14::ID: ::new (p) T14(static_cast<T14&&>(msg)); break;
689  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
690  }
691  }
692  #endif
693 
695  bool valid;
696  };
697 
698  //***************************************************************************
699  // Specialisation for 13 message types.
700  //***************************************************************************
701  template <typename T1, typename T2, typename T3, typename T4,
702  typename T5, typename T6, typename T7, typename T8,
703  typename T9, typename T10, typename T11, typename T12,
704  typename T13>
705  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void>
706  {
707  public:
708 
709  //********************************************
711  : valid(false)
712  {
713  }
714 
715  //********************************************
716  explicit message_packet(const etl::imessage& msg)
717  : valid(true)
718  {
719  add_new_message(msg);
720  }
721 
722  #if ETL_CPP11_SUPPORTED
723  //********************************************
724  explicit message_packet(etl::imessage&& msg)
725  : valid(true)
726  {
727  add_new_message(etl::move(msg));
728  }
729  #endif
730 
731  //**********************************************
732  message_packet(const message_packet& other)
733  : valid(other.is_valid())
734  {
735  if (valid)
736  {
737  add_new_message(other.get());
738  }
739  }
740 
741  #if ETL_CPP11_SUPPORTED
742  //**********************************************
744  : valid(other.is_valid())
745  {
746  if (valid)
747  {
748  add_new_message(etl::move(other.get()));
749  }
750  }
751  #endif
752 
753  //**********************************************
754  message_packet& operator =(const message_packet& rhs)
755  {
756  delete_current_message();
757  valid = rhs.is_valid();
758  if (valid)
759  {
760  add_new_message(rhs.get());
761  }
762 
763  return *this;
764  }
765 
766  #if ETL_CPP11_SUPPORTED
767  //**********************************************
768  message_packet& operator =(message_packet&& rhs)
769  {
770  delete_current_message();
771  valid = rhs.is_valid();
772  if (valid)
773  {
774  add_new_message(etl::move(rhs.get()));
775  }
776 
777  return *this;
778  }
779  #endif
780 
781  //********************************************
782  ~message_packet()
783  {
784  delete_current_message();
785  }
786 
787  //********************************************
788  etl::imessage& get() ETL_NOEXCEPT
789  {
790  return *static_cast<etl::imessage*>(data);
791  }
792 
793  //********************************************
794  const etl::imessage& get() const ETL_NOEXCEPT
795  {
796  return *static_cast<const etl::imessage*>(data);
797  }
798 
799  //********************************************
800  bool is_valid() const
801  {
802  return valid;
803  }
804 
805  enum
806  {
809  };
810 
811  private:
812 
813  //********************************************
814  void delete_current_message()
815  {
816  if (valid)
817  {
818  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
819 
820  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
821  pmsg->~imessage();
822  #else
823  size_t id = pmsg->message_id;
824 
825  switch (id)
826  {
827  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
828  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
829  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
830  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
831  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
832  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
833  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
834  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
835  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
836  case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
837  case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
838  case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
839  case T13::ID: static_cast<T13*>(pmsg)->~T13(); break;
840  default: assert(false); break;
841  }
842  #endif
843  }
844  }
845 
846  //********************************************
847  void add_new_message(const etl::imessage& msg)
848  {
849  const size_t id = msg.message_id;
850  void* p = data;
851 
852  switch (id)
853  {
854  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
855  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
856  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
857  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
858  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
859  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
860  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
861  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
862  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
863  case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
864  case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
865  case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
866  case T13::ID: ::new (p) T13(static_cast<const T13&>(msg)); break;
867  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
868  }
869  }
870 
871  #if ETL_CPP11_SUPPORTED
872  //********************************************
873  void add_new_message(etl::imessage&& msg)
874  {
875  const size_t id = msg.message_id;
876  void* p = data;
877 
878  switch (id)
879  {
880  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
881  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
882  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
883  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
884  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
885  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
886  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
887  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
888  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
889  case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
890  case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
891  case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
892  case T13::ID: ::new (p) T13(static_cast<T13&&>(msg)); break;
893  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
894  }
895  }
896  #endif
897 
899  bool valid;
900  };
901 
902  //***************************************************************************
903  // Specialisation for 12 message types.
904  //***************************************************************************
905  template <typename T1, typename T2, typename T3, typename T4,
906  typename T5, typename T6, typename T7, typename T8,
907  typename T9, typename T10, typename T11, typename T12>
908  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void>
909  {
910  public:
911 
912  //********************************************
914  : valid(false)
915  {
916  }
917 
918  //********************************************
919  explicit message_packet(const etl::imessage& msg)
920  : valid(true)
921  {
922  add_new_message(msg);
923  }
924 
925  #if ETL_CPP11_SUPPORTED
926  //********************************************
927  explicit message_packet(etl::imessage&& msg)
928  : valid(true)
929  {
930  add_new_message(etl::move(msg));
931  }
932  #endif
933 
934  //**********************************************
935  message_packet(const message_packet& other)
936  : valid(other.is_valid())
937  {
938  if (valid)
939  {
940  add_new_message(other.get());
941  }
942  }
943 
944  #if ETL_CPP11_SUPPORTED
945  //**********************************************
947  : valid(other.is_valid())
948  {
949  if (valid)
950  {
951  add_new_message(etl::move(other.get()));
952  }
953  }
954  #endif
955 
956  //**********************************************
957  message_packet& operator =(const message_packet& rhs)
958  {
959  delete_current_message();
960  valid = rhs.is_valid();
961  if (valid)
962  {
963  add_new_message(rhs.get());
964  }
965 
966  return *this;
967  }
968 
969  #if ETL_CPP11_SUPPORTED
970  //**********************************************
971  message_packet& operator =(message_packet&& rhs)
972  {
973  delete_current_message();
974  valid = rhs.is_valid();
975  if (valid)
976  {
977  add_new_message(etl::move(rhs.get()));
978  }
979 
980  return *this;
981  }
982  #endif
983 
984  //********************************************
985  ~message_packet()
986  {
987  delete_current_message();
988  }
989 
990  //********************************************
991  etl::imessage& get() ETL_NOEXCEPT
992  {
993  return *static_cast<etl::imessage*>(data);
994  }
995 
996  //********************************************
997  const etl::imessage& get() const ETL_NOEXCEPT
998  {
999  return *static_cast<const etl::imessage*>(data);
1000  }
1001 
1002  //********************************************
1003  bool is_valid() const
1004  {
1005  return valid;
1006  }
1007 
1008  enum
1009  {
1012  };
1013 
1014  private:
1015 
1016  //********************************************
1017  void delete_current_message()
1018  {
1019  if (valid)
1020  {
1021  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1022 
1023  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
1024  pmsg->~imessage();
1025  #else
1026  size_t id = pmsg->message_id;
1027 
1028  switch (id)
1029  {
1030  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
1031  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
1032  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
1033  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
1034  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
1035  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
1036  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
1037  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
1038  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
1039  case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
1040  case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
1041  case T12::ID: static_cast<T12*>(pmsg)->~T12(); break;
1042  default: assert(false); break;
1043  }
1044  #endif
1045  }
1046  }
1047 
1048  //********************************************
1049  void add_new_message(const etl::imessage& msg)
1050  {
1051  const size_t id = msg.message_id;
1052  void* p = data;
1053 
1054  switch (id)
1055  {
1056  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1057  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1058  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1059  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1060  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1061  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1062  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1063  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1064  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
1065  case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
1066  case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
1067  case T12::ID: ::new (p) T12(static_cast<const T12&>(msg)); break;
1068  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1069  }
1070  }
1071 
1072  #if ETL_CPP11_SUPPORTED
1073  //********************************************
1074  void add_new_message(etl::imessage&& msg)
1075  {
1076  const size_t id = msg.message_id;
1077  void* p = data;
1078 
1079  switch (id)
1080  {
1081  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1082  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1083  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1084  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1085  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1086  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1087  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1088  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1089  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
1090  case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
1091  case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
1092  case T12::ID: ::new (p) T12(static_cast<T12&&>(msg)); break;
1093  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1094  }
1095  }
1096  #endif
1097 
1099  bool valid;
1100  };
1101 
1102  //***************************************************************************
1103  // Specialisation for 11 message types.
1104  //***************************************************************************
1105  template <typename T1, typename T2, typename T3, typename T4,
1106  typename T5, typename T6, typename T7, typename T8,
1107  typename T9, typename T10, typename T11>
1108  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void>
1109  {
1110  public:
1111 
1112  //********************************************
1113  message_packet()
1114  : valid(false)
1115  {
1116  }
1117 
1118  //********************************************
1119  explicit message_packet(const etl::imessage& msg)
1120  : valid(true)
1121  {
1122  add_new_message(msg);
1123  }
1124 
1125  #if ETL_CPP11_SUPPORTED
1126  //********************************************
1127  explicit message_packet(etl::imessage&& msg)
1128  : valid(true)
1129  {
1130  add_new_message(etl::move(msg));
1131  }
1132  #endif
1133 
1134  //**********************************************
1135  message_packet(const message_packet& other)
1136  : valid(other.is_valid())
1137  {
1138  if (valid)
1139  {
1140  add_new_message(other.get());
1141  }
1142  }
1143 
1144  #if ETL_CPP11_SUPPORTED
1145  //**********************************************
1147  : valid(other.is_valid())
1148  {
1149  if (valid)
1150  {
1151  add_new_message(etl::move(other.get()));
1152  }
1153  }
1154  #endif
1155 
1156  //**********************************************
1157  message_packet& operator =(const message_packet& rhs)
1158  {
1159  delete_current_message();
1160  valid = rhs.is_valid();
1161  if (valid)
1162  {
1163  add_new_message(rhs.get());
1164  }
1165 
1166  return *this;
1167  }
1168 
1169  #if ETL_CPP11_SUPPORTED
1170  //**********************************************
1171  message_packet& operator =(message_packet&& rhs)
1172  {
1173  delete_current_message();
1174  valid = rhs.is_valid();
1175  if (valid)
1176  {
1177  add_new_message(etl::move(rhs.get()));
1178  }
1179 
1180  return *this;
1181  }
1182  #endif
1183 
1184  //********************************************
1185  ~message_packet()
1186  {
1187  delete_current_message();
1188  }
1189 
1190  //********************************************
1191  etl::imessage& get() ETL_NOEXCEPT
1192  {
1193  return *static_cast<etl::imessage*>(data);
1194  }
1195 
1196  //********************************************
1197  const etl::imessage& get() const ETL_NOEXCEPT
1198  {
1199  return *static_cast<const etl::imessage*>(data);
1200  }
1201 
1202  //********************************************
1203  bool is_valid() const
1204  {
1205  return valid;
1206  }
1207 
1208  enum
1209  {
1212  };
1213 
1214  private:
1215 
1216  //********************************************
1217  void delete_current_message()
1218  {
1219  if (valid)
1220  {
1221  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1222 
1223  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
1224  pmsg->~imessage();
1225  #else
1226  size_t id = pmsg->message_id;
1227 
1228  switch (id)
1229  {
1230  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
1231  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
1232  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
1233  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
1234  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
1235  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
1236  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
1237  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
1238  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
1239  case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
1240  case T11::ID: static_cast<T11*>(pmsg)->~T11(); break;
1241  default: assert(false); break;
1242  }
1243  #endif
1244  }
1245  }
1246 
1247  //********************************************
1248  void add_new_message(const etl::imessage& msg)
1249  {
1250  const size_t id = msg.message_id;
1251  void* p = data;
1252 
1253  switch (id)
1254  {
1255  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1256  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1257  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1258  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1259  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1260  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1261  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1262  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1263  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
1264  case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
1265  case T11::ID: ::new (p) T11(static_cast<const T11&>(msg)); break;
1266  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1267  }
1268  }
1269 
1270  #if ETL_CPP11_SUPPORTED
1271  //********************************************
1272  void add_new_message(etl::imessage&& msg)
1273  {
1274  const size_t id = msg.message_id;
1275  void* p = data;
1276 
1277  switch (id)
1278  {
1279  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1280  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1281  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1282  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1283  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1284  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1285  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1286  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1287  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
1288  case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
1289  case T11::ID: ::new (p) T11(static_cast<T11&&>(msg)); break;
1290  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1291  }
1292  }
1293  #endif
1294 
1296  bool valid;
1297  };
1298 
1299  //***************************************************************************
1300  // Specialisation for 10 message types.
1301  //***************************************************************************
1302  template <typename T1, typename T2, typename T3, typename T4,
1303  typename T5, typename T6, typename T7, typename T8,
1304  typename T9, typename T10>
1305  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void>
1306  {
1307  public:
1308 
1309  //********************************************
1310  message_packet()
1311  : valid(false)
1312  {
1313  }
1314 
1315  //********************************************
1316  explicit message_packet(const etl::imessage& msg)
1317  : valid(true)
1318  {
1319  add_new_message(msg);
1320  }
1321 
1322  #if ETL_CPP11_SUPPORTED
1323  //********************************************
1324  explicit message_packet(etl::imessage&& msg)
1325  : valid(true)
1326  {
1327  add_new_message(etl::move(msg));
1328  }
1329  #endif
1330 
1331  //**********************************************
1332  message_packet(const message_packet& other)
1333  : valid(other.is_valid())
1334  {
1335  if (valid)
1336  {
1337  add_new_message(other.get());
1338  }
1339  }
1340 
1341  #if ETL_CPP11_SUPPORTED
1342  //**********************************************
1344  : valid(other.is_valid())
1345  {
1346  if (valid)
1347  {
1348  add_new_message(etl::move(other.get()));
1349  }
1350  }
1351  #endif
1352 
1353  //**********************************************
1354  message_packet& operator =(const message_packet& rhs)
1355  {
1356  delete_current_message();
1357  valid = rhs.is_valid();
1358  if (valid)
1359  {
1360  add_new_message(rhs.get());
1361  }
1362 
1363  return *this;
1364  }
1365 
1366  #if ETL_CPP11_SUPPORTED
1367  //**********************************************
1368  message_packet& operator =(message_packet&& rhs)
1369  {
1370  delete_current_message();
1371  valid = rhs.is_valid();
1372  if (valid)
1373  {
1374  add_new_message(etl::move(rhs.get()));
1375  }
1376 
1377  return *this;
1378  }
1379  #endif
1380 
1381  //********************************************
1382  ~message_packet()
1383  {
1384  delete_current_message();
1385  }
1386 
1387  //********************************************
1388  etl::imessage& get() ETL_NOEXCEPT
1389  {
1390  return *static_cast<etl::imessage*>(data);
1391  }
1392 
1393  //********************************************
1394  const etl::imessage& get() const ETL_NOEXCEPT
1395  {
1396  return *static_cast<const etl::imessage*>(data);
1397  }
1398 
1399  //********************************************
1400  bool is_valid() const
1401  {
1402  return valid;
1403  }
1404 
1405  enum
1406  {
1409  };
1410 
1411  private:
1412 
1413  //********************************************
1414  void delete_current_message()
1415  {
1416  if (valid)
1417  {
1418  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1419 
1420  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
1421  pmsg->~imessage();
1422  #else
1423  size_t id = pmsg->message_id;
1424 
1425  switch (id)
1426  {
1427  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
1428  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
1429  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
1430  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
1431  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
1432  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
1433  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
1434  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
1435  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
1436  case T10::ID: static_cast<T10*>(pmsg)->~T10(); break;
1437  default: assert(false); break;
1438  }
1439  #endif
1440  }
1441  }
1442 
1443  //********************************************
1444  void add_new_message(const etl::imessage& msg)
1445  {
1446  const size_t id = msg.message_id;
1447  void* p = data;
1448 
1449  switch (id)
1450  {
1451  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1452  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1453  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1454  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1455  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1456  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1457  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1458  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1459  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
1460  case T10::ID: ::new (p) T10(static_cast<const T10&>(msg)); break;
1461  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1462  }
1463  }
1464 
1465  #if ETL_CPP11_SUPPORTED
1466  //********************************************
1467  void add_new_message(etl::imessage&& msg)
1468  {
1469  const size_t id = msg.message_id;
1470  void* p = data;
1471 
1472  switch (id)
1473  {
1474  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1475  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1476  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1477  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1478  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1479  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1480  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1481  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1482  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
1483  case T10::ID: ::new (p) T10(static_cast<T10&&>(msg)); break;
1484  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1485  }
1486  }
1487  #endif
1488 
1490  bool valid;
1491  };
1492 
1493  //***************************************************************************
1494  // Specialisation for 9 message types.
1495  //***************************************************************************
1496  template <typename T1, typename T2, typename T3, typename T4,
1497  typename T5, typename T6, typename T7, typename T8,
1498  typename T9>
1499  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void>
1500  {
1501  public:
1502 
1503  //********************************************
1504  message_packet()
1505  : valid(false)
1506  {
1507  }
1508 
1509  //********************************************
1510  explicit message_packet(const etl::imessage& msg)
1511  : valid(true)
1512  {
1513  add_new_message(msg);
1514  }
1515 
1516  #if ETL_CPP11_SUPPORTED
1517  //********************************************
1518  explicit message_packet(etl::imessage&& msg)
1519  : valid(true)
1520  {
1521  add_new_message(etl::move(msg));
1522  }
1523  #endif
1524 
1525  //**********************************************
1526  message_packet(const message_packet& other)
1527  : valid(other.is_valid())
1528  {
1529  if (valid)
1530  {
1531  add_new_message(other.get());
1532  }
1533  }
1534 
1535  #if ETL_CPP11_SUPPORTED
1536  //**********************************************
1538  : valid(other.is_valid())
1539  {
1540  if (valid)
1541  {
1542  add_new_message(etl::move(other.get()));
1543  }
1544  }
1545  #endif
1546 
1547  //**********************************************
1548  message_packet& operator =(const message_packet& rhs)
1549  {
1550  delete_current_message();
1551  valid = rhs.is_valid();
1552  if (valid)
1553  {
1554  add_new_message(rhs.get());
1555  }
1556 
1557  return *this;
1558  }
1559 
1560  #if ETL_CPP11_SUPPORTED
1561  //**********************************************
1562  message_packet& operator =(message_packet&& rhs)
1563  {
1564  delete_current_message();
1565  valid = rhs.is_valid();
1566  if (valid)
1567  {
1568  add_new_message(etl::move(rhs.get()));
1569  }
1570 
1571  return *this;
1572  }
1573  #endif
1574 
1575  //********************************************
1576  ~message_packet()
1577  {
1578  delete_current_message();
1579  }
1580 
1581  //********************************************
1582  etl::imessage& get() ETL_NOEXCEPT
1583  {
1584  return *static_cast<etl::imessage*>(data);
1585  }
1586 
1587  //********************************************
1588  const etl::imessage& get() const ETL_NOEXCEPT
1589  {
1590  return *static_cast<const etl::imessage*>(data);
1591  }
1592 
1593  //********************************************
1594  bool is_valid() const
1595  {
1596  return valid;
1597  }
1598 
1599  enum
1600  {
1603  };
1604 
1605  private:
1606 
1607  //********************************************
1608  void delete_current_message()
1609  {
1610  if (valid)
1611  {
1612  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1613 
1614  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
1615  pmsg->~imessage();
1616  #else
1617  size_t id = pmsg->message_id;
1618 
1619  switch (id)
1620  {
1621  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
1622  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
1623  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
1624  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
1625  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
1626  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
1627  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
1628  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
1629  case T9::ID: static_cast<T9*>(pmsg)->~T9(); break;
1630  default: assert(false); break;
1631  }
1632  #endif
1633  }
1634  }
1635 
1636  //********************************************
1637  void add_new_message(const etl::imessage& msg)
1638  {
1639  const size_t id = msg.message_id;
1640  void* p = data;
1641 
1642  switch (id)
1643  {
1644  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1645  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1646  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1647  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1648  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1649  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1650  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1651  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1652  case T9::ID: ::new (p) T9(static_cast<const T9&>(msg)); break;
1653  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1654  }
1655  }
1656 
1657  #if ETL_CPP11_SUPPORTED
1658  //********************************************
1659  void add_new_message(etl::imessage&& msg)
1660  {
1661  const size_t id = msg.message_id;
1662  void* p = data;
1663 
1664  switch (id)
1665  {
1666  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1667  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1668  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1669  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1670  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1671  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1672  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1673  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1674  case T9::ID: ::new (p) T9(static_cast<T9&&>(msg)); break;
1675  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1676  }
1677  }
1678  #endif
1679 
1681  bool valid;
1682  };
1683 
1684  //***************************************************************************
1685  // Specialisation for 8 message types.
1686  //***************************************************************************
1687  template <typename T1, typename T2, typename T3, typename T4,
1688  typename T5, typename T6, typename T7, typename T8>
1689  class message_packet<T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void>
1690  {
1691  public:
1692 
1693  //********************************************
1694  message_packet()
1695  : valid(false)
1696  {
1697  }
1698 
1699  //********************************************
1700  explicit message_packet(const etl::imessage& msg)
1701  : valid(true)
1702  {
1703  add_new_message(msg);
1704  }
1705 
1706  #if ETL_CPP11_SUPPORTED
1707  //********************************************
1708  explicit message_packet(etl::imessage&& msg)
1709  : valid(true)
1710  {
1711  add_new_message(etl::move(msg));
1712  }
1713  #endif
1714 
1715  //**********************************************
1716  message_packet(const message_packet& other)
1717  : valid(other.is_valid())
1718  {
1719  if (valid)
1720  {
1721  add_new_message(other.get());
1722  }
1723  }
1724 
1725  #if ETL_CPP11_SUPPORTED
1726  //**********************************************
1728  : valid(other.is_valid())
1729  {
1730  if (valid)
1731  {
1732  add_new_message(etl::move(other.get()));
1733  }
1734  }
1735  #endif
1736 
1737  //**********************************************
1738  message_packet& operator =(const message_packet& rhs)
1739  {
1740  delete_current_message();
1741  valid = rhs.is_valid();
1742  if (valid)
1743  {
1744  add_new_message(rhs.get());
1745  }
1746 
1747  return *this;
1748  }
1749 
1750  #if ETL_CPP11_SUPPORTED
1751  //**********************************************
1752  message_packet& operator =(message_packet&& rhs)
1753  {
1754  delete_current_message();
1755  valid = rhs.is_valid();
1756  if (valid)
1757  {
1758  add_new_message(etl::move(rhs.get()));
1759  }
1760 
1761  return *this;
1762  }
1763  #endif
1764 
1765  //********************************************
1766  ~message_packet()
1767  {
1768  delete_current_message();
1769  }
1770 
1771  //********************************************
1772  etl::imessage& get() ETL_NOEXCEPT
1773  {
1774  return *static_cast<etl::imessage*>(data);
1775  }
1776 
1777  //********************************************
1778  const etl::imessage& get() const ETL_NOEXCEPT
1779  {
1780  return *static_cast<const etl::imessage*>(data);
1781  }
1782 
1783  //********************************************
1784  bool is_valid() const
1785  {
1786  return valid;
1787  }
1788 
1789  enum
1790  {
1793  };
1794 
1795  private:
1796 
1797  //********************************************
1798  void delete_current_message()
1799  {
1800  if (valid)
1801  {
1802  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1803 
1804  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
1805  pmsg->~imessage();
1806  #else
1807  size_t id = pmsg->message_id;
1808 
1809  switch (id)
1810  {
1811  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
1812  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
1813  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
1814  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
1815  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
1816  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
1817  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
1818  case T8::ID: static_cast<T8*>(pmsg)->~T8(); break;
1819  default: assert(false); break;
1820  }
1821  #endif
1822  }
1823  }
1824 
1825  //********************************************
1826  void add_new_message(const etl::imessage& msg)
1827  {
1828  const size_t id = msg.message_id;
1829  void* p = data;
1830 
1831  switch (id)
1832  {
1833  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
1834  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
1835  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
1836  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
1837  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
1838  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
1839  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
1840  case T8::ID: ::new (p) T8(static_cast<const T8&>(msg)); break;
1841  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1842  }
1843  }
1844 
1845  #if ETL_CPP11_SUPPORTED
1846  //********************************************
1847  void add_new_message(etl::imessage&& msg)
1848  {
1849  const size_t id = msg.message_id;
1850  void* p = data;
1851 
1852  switch (id)
1853  {
1854  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
1855  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
1856  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
1857  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
1858  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
1859  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
1860  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
1861  case T8::ID: ::new (p) T8(static_cast<T8&&>(msg)); break;
1862  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
1863  }
1864  }
1865  #endif
1866 
1868  bool valid;
1869  };
1870 
1871  //***************************************************************************
1872  // Specialisation for 7 message types.
1873  //***************************************************************************
1874  template <typename T1, typename T2, typename T3, typename T4,
1875  typename T5, typename T6, typename T7>
1876  class message_packet<T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void>
1877  {
1878  public:
1879 
1880  //********************************************
1881  message_packet()
1882  : valid(false)
1883  {
1884  }
1885 
1886  //********************************************
1887  explicit message_packet(const etl::imessage& msg)
1888  : valid(true)
1889  {
1890  add_new_message(msg);
1891  }
1892 
1893  #if ETL_CPP11_SUPPORTED
1894  //********************************************
1895  explicit message_packet(etl::imessage&& msg)
1896  : valid(true)
1897  {
1898  add_new_message(etl::move(msg));
1899  }
1900  #endif
1901 
1902  //**********************************************
1903  message_packet(const message_packet& other)
1904  : valid(other.is_valid())
1905  {
1906  if (valid)
1907  {
1908  add_new_message(other.get());
1909  }
1910  }
1911 
1912  #if ETL_CPP11_SUPPORTED
1913  //**********************************************
1915  : valid(other.is_valid())
1916  {
1917  if (valid)
1918  {
1919  add_new_message(etl::move(other.get()));
1920  }
1921  }
1922  #endif
1923 
1924  //**********************************************
1925  message_packet& operator =(const message_packet& rhs)
1926  {
1927  delete_current_message();
1928  valid = rhs.is_valid();
1929  if (valid)
1930  {
1931  add_new_message(rhs.get());
1932  }
1933 
1934  return *this;
1935  }
1936 
1937  #if ETL_CPP11_SUPPORTED
1938  //**********************************************
1939  message_packet& operator =(message_packet&& rhs)
1940  {
1941  delete_current_message();
1942  valid = rhs.is_valid();
1943  if (valid)
1944  {
1945  add_new_message(etl::move(rhs.get()));
1946  }
1947 
1948  return *this;
1949  }
1950  #endif
1951 
1952  //********************************************
1953  ~message_packet()
1954  {
1955  delete_current_message();
1956  }
1957 
1958  //********************************************
1959  etl::imessage& get() ETL_NOEXCEPT
1960  {
1961  return *static_cast<etl::imessage*>(data);
1962  }
1963 
1964  //********************************************
1965  const etl::imessage& get() const ETL_NOEXCEPT
1966  {
1967  return *static_cast<const etl::imessage*>(data);
1968  }
1969 
1970  //********************************************
1971  bool is_valid() const
1972  {
1973  return valid;
1974  }
1975 
1976  enum
1977  {
1980  };
1981 
1982  private:
1983 
1984  //********************************************
1985  void delete_current_message()
1986  {
1987  if (valid)
1988  {
1989  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
1990 
1991  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
1992  pmsg->~imessage();
1993  #else
1994  size_t id = pmsg->message_id;
1995 
1996  switch (id)
1997  {
1998  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
1999  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
2000  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
2001  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
2002  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
2003  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
2004  case T7::ID: static_cast<T7*>(pmsg)->~T7(); break;
2005  default: assert(false); break;
2006  }
2007  #endif
2008  }
2009  }
2010 
2011  //********************************************
2012  void add_new_message(const etl::imessage& msg)
2013  {
2014  const size_t id = msg.message_id;
2015  void* p = data;
2016 
2017  switch (id)
2018  {
2019  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2020  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2021  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2022  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
2023  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
2024  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
2025  case T7::ID: ::new (p) T7(static_cast<const T7&>(msg)); break;
2026  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2027  }
2028  }
2029 
2030  #if ETL_CPP11_SUPPORTED
2031  //********************************************
2032  void add_new_message(etl::imessage&& msg)
2033  {
2034  const size_t id = msg.message_id;
2035  void* p = data;
2036 
2037  switch (id)
2038  {
2039  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2040  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2041  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2042  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2043  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
2044  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
2045  case T7::ID: ::new (p) T7(static_cast<T7&&>(msg)); break;
2046  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2047  }
2048  }
2049  #endif
2050 
2052  bool valid;
2053  };
2054 
2055  //***************************************************************************
2056  // Specialisation for 6 message types.
2057  //***************************************************************************
2058  template <typename T1, typename T2, typename T3, typename T4,
2059  typename T5, typename T6>
2060  class message_packet<T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void>
2061  {
2062  public:
2063 
2064  //********************************************
2065  message_packet()
2066  : valid(false)
2067  {
2068  }
2069 
2070  //********************************************
2071  explicit message_packet(const etl::imessage& msg)
2072  : valid(true)
2073  {
2074  add_new_message(msg);
2075  }
2076 
2077  #if ETL_CPP11_SUPPORTED
2078  //********************************************
2079  explicit message_packet(etl::imessage&& msg)
2080  : valid(true)
2081  {
2082  add_new_message(etl::move(msg));
2083  }
2084  #endif
2085 
2086  //**********************************************
2087  message_packet(const message_packet& other)
2088  : valid(other.is_valid())
2089  {
2090  if (valid)
2091  {
2092  add_new_message(other.get());
2093  }
2094  }
2095 
2096  #if ETL_CPP11_SUPPORTED
2097  //**********************************************
2099  : valid(other.is_valid())
2100  {
2101  if (valid)
2102  {
2103  add_new_message(etl::move(other.get()));
2104  }
2105  }
2106  #endif
2107 
2108  //**********************************************
2109  message_packet& operator =(const message_packet& rhs)
2110  {
2111  delete_current_message();
2112  valid = rhs.is_valid();
2113  if (valid)
2114  {
2115  add_new_message(rhs.get());
2116  }
2117 
2118  return *this;
2119  }
2120 
2121  #if ETL_CPP11_SUPPORTED
2122  //**********************************************
2123  message_packet& operator =(message_packet&& rhs)
2124  {
2125  delete_current_message();
2126  valid = rhs.is_valid();
2127  if (valid)
2128  {
2129  add_new_message(etl::move(rhs.get()));
2130  }
2131 
2132  return *this;
2133  }
2134  #endif
2135 
2136  //********************************************
2137  ~message_packet()
2138  {
2139  delete_current_message();
2140  }
2141 
2142  //********************************************
2143  etl::imessage& get() ETL_NOEXCEPT
2144  {
2145  return *static_cast<etl::imessage*>(data);
2146  }
2147 
2148  //********************************************
2149  const etl::imessage& get() const ETL_NOEXCEPT
2150  {
2151  return *static_cast<const etl::imessage*>(data);
2152  }
2153 
2154  //********************************************
2155  bool is_valid() const
2156  {
2157  return valid;
2158  }
2159 
2160  enum
2161  {
2164  };
2165 
2166  private:
2167 
2168  //********************************************
2169  void delete_current_message()
2170  {
2171  if (valid)
2172  {
2173  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2174 
2175  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
2176  pmsg->~imessage();
2177  #else
2178  size_t id = pmsg->message_id;
2179 
2180  switch (id)
2181  {
2182  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
2183  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
2184  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
2185  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
2186  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
2187  case T6::ID: static_cast<T6*>(pmsg)->~T6(); break;
2188  default: assert(false); break;
2189  }
2190  #endif
2191  }
2192  }
2193 
2194  //********************************************
2195  void add_new_message(const etl::imessage& msg)
2196  {
2197  const size_t id = msg.message_id;
2198  void* p = data;
2199 
2200  switch (id)
2201  {
2202  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2203  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2204  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2205  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
2206  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
2207  case T6::ID: ::new (p) T6(static_cast<const T6&>(msg)); break;
2208  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2209  }
2210  }
2211 
2212  #if ETL_CPP11_SUPPORTED
2213  //********************************************
2214  void add_new_message(etl::imessage&& msg)
2215  {
2216  const size_t id = msg.message_id;
2217  void* p = data;
2218 
2219  switch (id)
2220  {
2221  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2222  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2223  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2224  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2225  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
2226  case T6::ID: ::new (p) T6(static_cast<T6&&>(msg)); break;
2227  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2228  }
2229  }
2230  #endif
2231 
2233  bool valid;
2234  };
2235 
2236  //***************************************************************************
2237  // Specialisation for 5 message types.
2238  //***************************************************************************
2239  template <typename T1, typename T2, typename T3, typename T4,
2240  typename T5>
2241  class message_packet<T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void>
2242  {
2243  public:
2244 
2245  //********************************************
2246  message_packet()
2247  : valid(false)
2248  {
2249  }
2250 
2251  //********************************************
2252  explicit message_packet(const etl::imessage& msg)
2253  : valid(true)
2254  {
2255  add_new_message(msg);
2256  }
2257 
2258  #if ETL_CPP11_SUPPORTED
2259  //********************************************
2260  explicit message_packet(etl::imessage&& msg)
2261  : valid(true)
2262  {
2263  add_new_message(etl::move(msg));
2264  }
2265  #endif
2266 
2267  //**********************************************
2268  message_packet(const message_packet& other)
2269  : valid(other.is_valid())
2270  {
2271  if (valid)
2272  {
2273  add_new_message(other.get());
2274  }
2275  }
2276 
2277  #if ETL_CPP11_SUPPORTED
2278  //**********************************************
2280  : valid(other.is_valid())
2281  {
2282  if (valid)
2283  {
2284  add_new_message(etl::move(other.get()));
2285  }
2286  }
2287  #endif
2288 
2289  //**********************************************
2290  message_packet& operator =(const message_packet& rhs)
2291  {
2292  delete_current_message();
2293  valid = rhs.is_valid();
2294  if (valid)
2295  {
2296  add_new_message(rhs.get());
2297  }
2298 
2299  return *this;
2300  }
2301 
2302  #if ETL_CPP11_SUPPORTED
2303  //**********************************************
2304  message_packet& operator =(message_packet&& rhs)
2305  {
2306  delete_current_message();
2307  valid = rhs.is_valid();
2308  if (valid)
2309  {
2310  add_new_message(etl::move(rhs.get()));
2311  }
2312 
2313  return *this;
2314  }
2315  #endif
2316 
2317  //********************************************
2318  ~message_packet()
2319  {
2320  delete_current_message();
2321  }
2322 
2323  //********************************************
2324  etl::imessage& get() ETL_NOEXCEPT
2325  {
2326  return *static_cast<etl::imessage*>(data);
2327  }
2328 
2329  //********************************************
2330  const etl::imessage& get() const ETL_NOEXCEPT
2331  {
2332  return *static_cast<const etl::imessage*>(data);
2333  }
2334 
2335  //********************************************
2336  bool is_valid() const
2337  {
2338  return valid;
2339  }
2340 
2341  enum
2342  {
2345  };
2346 
2347  private:
2348 
2349  //********************************************
2350  void delete_current_message()
2351  {
2352  if (valid)
2353  {
2354  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2355 
2356  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
2357  pmsg->~imessage();
2358  #else
2359  size_t id = pmsg->message_id;
2360 
2361  switch (id)
2362  {
2363  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
2364  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
2365  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
2366  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
2367  case T5::ID: static_cast<T5*>(pmsg)->~T5(); break;
2368  default: assert(false); break;
2369  }
2370  #endif
2371  }
2372  }
2373 
2374  //********************************************
2375  void add_new_message(const etl::imessage& msg)
2376  {
2377  const size_t id = msg.message_id;
2378  void* p = data;
2379 
2380  switch (id)
2381  {
2382  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2383  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2384  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2385  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
2386  case T5::ID: ::new (p) T5(static_cast<const T5&>(msg)); break;
2387  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2388  }
2389  }
2390 
2391  #if ETL_CPP11_SUPPORTED
2392  //********************************************
2393  void add_new_message(etl::imessage&& msg)
2394  {
2395  const size_t id = msg.message_id;
2396  void* p = data;
2397 
2398  switch (id)
2399  {
2400  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2401  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2402  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2403  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2404  case T5::ID: ::new (p) T5(static_cast<T5&&>(msg)); break;
2405  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2406  }
2407  }
2408  #endif
2409 
2411  bool valid;
2412  };
2413 
2414  //***************************************************************************
2415  // Specialisation for 4 message types.
2416  //***************************************************************************
2417  template <typename T1, typename T2, typename T3, typename T4>
2418  class message_packet<T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void>
2419  {
2420  public:
2421 
2422  //********************************************
2423  message_packet()
2424  : valid(false)
2425  {
2426  }
2427 
2428  //********************************************
2429  explicit message_packet(const etl::imessage& msg)
2430  : valid(true)
2431  {
2432  add_new_message(msg);
2433  }
2434 
2435  #if ETL_CPP11_SUPPORTED
2436  //********************************************
2437  explicit message_packet(etl::imessage&& msg)
2438  : valid(true)
2439  {
2440  add_new_message(etl::move(msg));
2441  }
2442  #endif
2443 
2444  //**********************************************
2445  message_packet(const message_packet& other)
2446  : valid(other.is_valid())
2447  {
2448  if (valid)
2449  {
2450  add_new_message(other.get());
2451  }
2452  }
2453 
2454  #if ETL_CPP11_SUPPORTED
2455  //**********************************************
2457  : valid(other.is_valid())
2458  {
2459  if (valid)
2460  {
2461  add_new_message(etl::move(other.get()));
2462  }
2463  }
2464  #endif
2465 
2466  //**********************************************
2467  message_packet& operator =(const message_packet& rhs)
2468  {
2469  delete_current_message();
2470  valid = rhs.is_valid();
2471  if (valid)
2472  {
2473  add_new_message(rhs.get());
2474  }
2475 
2476  return *this;
2477  }
2478 
2479  #if ETL_CPP11_SUPPORTED
2480  //**********************************************
2481  message_packet& operator =(message_packet&& rhs)
2482  {
2483  delete_current_message();
2484  valid = rhs.is_valid();
2485  if (valid)
2486  {
2487  add_new_message(etl::move(rhs.get()));
2488  }
2489 
2490  return *this;
2491  }
2492  #endif
2493 
2494  //********************************************
2495  ~message_packet()
2496  {
2497  delete_current_message();
2498  }
2499 
2500  //********************************************
2501  etl::imessage& get() ETL_NOEXCEPT
2502  {
2503  return *static_cast<etl::imessage*>(data);
2504  }
2505 
2506  //********************************************
2507  const etl::imessage& get() const ETL_NOEXCEPT
2508  {
2509  return *static_cast<const etl::imessage*>(data);
2510  }
2511 
2512  //********************************************
2513  bool is_valid() const
2514  {
2515  return valid;
2516  }
2517 
2518  enum
2519  {
2522  };
2523 
2524  private:
2525 
2526  //********************************************
2527  void delete_current_message()
2528  {
2529  if (valid)
2530  {
2531  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2532 
2533  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
2534  pmsg->~imessage();
2535  #else
2536  size_t id = pmsg->message_id;
2537 
2538  switch (id)
2539  {
2540  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
2541  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
2542  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
2543  case T4::ID: static_cast<T4*>(pmsg)->~T4(); break;
2544  default: assert(false); break;
2545  }
2546  #endif
2547  }
2548  }
2549 
2550  //********************************************
2551  void add_new_message(const etl::imessage& msg)
2552  {
2553  const size_t id = msg.message_id;
2554  void* p = data;
2555 
2556  switch (id)
2557  {
2558  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2559  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2560  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2561  case T4::ID: ::new (p) T4(static_cast<const T4&>(msg)); break;
2562  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2563  }
2564  }
2565 
2566  #if ETL_CPP11_SUPPORTED
2567  //********************************************
2568  void add_new_message(etl::imessage&& msg)
2569  {
2570  const size_t id = msg.message_id;
2571  void* p = data;
2572 
2573  switch (id)
2574  {
2575  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2576  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2577  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2578  case T4::ID: ::new (p) T4(static_cast<T4&&>(msg)); break;
2579  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2580  }
2581  }
2582  #endif
2583 
2585  bool valid;
2586  };
2587 
2588  //***************************************************************************
2589  // Specialisation for 3 message types.
2590  //***************************************************************************
2591  template <typename T1, typename T2, typename T3>
2592  class message_packet<T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void>
2593  {
2594  public:
2595 
2596  //********************************************
2597  message_packet()
2598  : valid(false)
2599  {
2600  }
2601 
2602  //********************************************
2603  explicit message_packet(const etl::imessage& msg)
2604  : valid(true)
2605  {
2606  add_new_message(msg);
2607  }
2608 
2609  #if ETL_CPP11_SUPPORTED
2610  //********************************************
2611  explicit message_packet(etl::imessage&& msg)
2612  : valid(true)
2613  {
2614  add_new_message(etl::move(msg));
2615  }
2616  #endif
2617 
2618  //**********************************************
2619  message_packet(const message_packet& other)
2620  : valid(other.is_valid())
2621  {
2622  if (valid)
2623  {
2624  add_new_message(other.get());
2625  }
2626  }
2627 
2628  #if ETL_CPP11_SUPPORTED
2629  //**********************************************
2631  : valid(other.is_valid())
2632  {
2633  if (valid)
2634  {
2635  add_new_message(etl::move(other.get()));
2636  }
2637  }
2638  #endif
2639 
2640  //**********************************************
2641  message_packet& operator =(const message_packet& rhs)
2642  {
2643  delete_current_message();
2644  valid = rhs.is_valid();
2645  if (valid)
2646  {
2647  add_new_message(rhs.get());
2648  }
2649 
2650  return *this;
2651  }
2652 
2653  #if ETL_CPP11_SUPPORTED
2654  //**********************************************
2655  message_packet& operator =(message_packet&& rhs)
2656  {
2657  delete_current_message();
2658  valid = rhs.is_valid();
2659  if (valid)
2660  {
2661  add_new_message(etl::move(rhs.get()));
2662  }
2663 
2664  return *this;
2665  }
2666  #endif
2667 
2668  //********************************************
2669  ~message_packet()
2670  {
2671  delete_current_message();
2672  }
2673 
2674  //********************************************
2675  etl::imessage& get() ETL_NOEXCEPT
2676  {
2677  return *static_cast<etl::imessage*>(data);
2678  }
2679 
2680  //********************************************
2681  const etl::imessage& get() const ETL_NOEXCEPT
2682  {
2683  return *static_cast<const etl::imessage*>(data);
2684  }
2685 
2686  //********************************************
2687  bool is_valid() const
2688  {
2689  return valid;
2690  }
2691 
2692  enum
2693  {
2696  };
2697 
2698  private:
2699 
2700  //********************************************
2701  void delete_current_message()
2702  {
2703  if (valid)
2704  {
2705  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2706 
2707  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
2708  pmsg->~imessage();
2709  #else
2710  size_t id = pmsg->message_id;
2711 
2712  switch (id)
2713  {
2714  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
2715  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
2716  case T3::ID: static_cast<T3*>(pmsg)->~T3(); break;
2717  default: assert(false); break;
2718  }
2719  #endif
2720  }
2721  }
2722 
2723  //********************************************
2724  void add_new_message(const etl::imessage& msg)
2725  {
2726  const size_t id = msg.message_id;
2727  void* p = data;
2728 
2729  switch (id)
2730  {
2731  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2732  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2733  case T3::ID: ::new (p) T3(static_cast<const T3&>(msg)); break;
2734  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2735  }
2736  }
2737 
2738  #if ETL_CPP11_SUPPORTED
2739  //********************************************
2740  void add_new_message(etl::imessage&& msg)
2741  {
2742  const size_t id = msg.message_id;
2743  void* p = data;
2744 
2745  switch (id)
2746  {
2747  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2748  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2749  case T3::ID: ::new (p) T3(static_cast<T3&&>(msg)); break;
2750  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2751  }
2752  }
2753  #endif
2754 
2756  bool valid;
2757  };
2758 
2759  //***************************************************************************
2760  // Specialisation for 2 message types.
2761  //***************************************************************************
2762  template <typename T1, typename T2>
2763  class message_packet<T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
2764  {
2765  public:
2766 
2767  //********************************************
2768  message_packet()
2769  : valid(false)
2770  {
2771  }
2772 
2773  //********************************************
2774  explicit message_packet(const etl::imessage& msg)
2775  : valid(true)
2776  {
2777  add_new_message(msg);
2778  }
2779 
2780  #if ETL_CPP11_SUPPORTED
2781  //********************************************
2782  explicit message_packet(etl::imessage&& msg)
2783  : valid(true)
2784  {
2785  add_new_message(etl::move(msg));
2786  }
2787  #endif
2788 
2789  //**********************************************
2790  message_packet(const message_packet& other)
2791  : valid(other.is_valid())
2792  {
2793  if (valid)
2794  {
2795  add_new_message(other.get());
2796  }
2797  }
2798 
2799  #if ETL_CPP11_SUPPORTED
2800  //**********************************************
2802  : valid(other.is_valid())
2803  {
2804  if (valid)
2805  {
2806  add_new_message(etl::move(other.get()));
2807  }
2808  }
2809  #endif
2810 
2811  //**********************************************
2812  message_packet& operator =(const message_packet& rhs)
2813  {
2814  delete_current_message();
2815  valid = rhs.is_valid();
2816  if (valid)
2817  {
2818  add_new_message(rhs.get());
2819  }
2820 
2821  return *this;
2822  }
2823 
2824  #if ETL_CPP11_SUPPORTED
2825  //**********************************************
2826  message_packet& operator =(message_packet&& rhs)
2827  {
2828  delete_current_message();
2829  valid = rhs.is_valid();
2830  if (valid)
2831  {
2832  add_new_message(etl::move(rhs.get()));
2833  }
2834 
2835  return *this;
2836  }
2837  #endif
2838 
2839  //********************************************
2840  ~message_packet()
2841  {
2842  delete_current_message();
2843  }
2844 
2845  //********************************************
2846  etl::imessage& get() ETL_NOEXCEPT
2847  {
2848  return *static_cast<etl::imessage*>(data);
2849  }
2850 
2851  //********************************************
2852  const etl::imessage& get() const ETL_NOEXCEPT
2853  {
2854  return *static_cast<const etl::imessage*>(data);
2855  }
2856 
2857  //********************************************
2858  bool is_valid() const
2859  {
2860  return valid;
2861  }
2862 
2863  enum
2864  {
2867  };
2868 
2869  private:
2870 
2871  //********************************************
2872  void delete_current_message()
2873  {
2874  if (valid)
2875  {
2876  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
2877 
2878  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
2879  pmsg->~imessage();
2880  #else
2881  size_t id = pmsg->message_id;
2882 
2883  switch (id)
2884  {
2885  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
2886  case T2::ID: static_cast<T2*>(pmsg)->~T2(); break;
2887  default: assert(false); break;
2888  }
2889  #endif
2890  }
2891  }
2892 
2893  //********************************************
2894  void add_new_message(const etl::imessage& msg)
2895  {
2896  const size_t id = msg.message_id;
2897  void* p = data;
2898 
2899  switch (id)
2900  {
2901  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
2902  case T2::ID: ::new (p) T2(static_cast<const T2&>(msg)); break;
2903  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2904  }
2905  }
2906 
2907  #if ETL_CPP11_SUPPORTED
2908  //********************************************
2909  void add_new_message(etl::imessage&& msg)
2910  {
2911  const size_t id = msg.message_id;
2912  void* p = data;
2913 
2914  switch (id)
2915  {
2916  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
2917  case T2::ID: ::new (p) T2(static_cast<T2&&>(msg)); break;
2918  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
2919  }
2920  }
2921  #endif
2922 
2924  bool valid;
2925  };
2926 
2927  //***************************************************************************
2928  // Specialisation for 1 message type.
2929  //***************************************************************************
2930  template <typename T1>
2931  class message_packet<T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
2932  {
2933  public:
2934 
2935  //********************************************
2936  message_packet()
2937  : valid(false)
2938  {
2939  }
2940 
2941  //********************************************
2942  explicit message_packet(const etl::imessage& msg)
2943  : valid(true)
2944  {
2945  add_new_message(msg);
2946  }
2947 
2948  #if ETL_CPP11_SUPPORTED
2949  //********************************************
2950  explicit message_packet(etl::imessage&& msg)
2951  : valid(true)
2952  {
2953  add_new_message(etl::move(msg));
2954  }
2955  #endif
2956 
2957  //**********************************************
2958  message_packet(const message_packet& other)
2959  : valid(other.is_valid())
2960  {
2961  if (valid)
2962  {
2963  add_new_message(other.get());
2964  }
2965  }
2966 
2967  #if ETL_CPP11_SUPPORTED
2968  //**********************************************
2970  : valid(other.is_valid())
2971  {
2972  if (valid)
2973  {
2974  add_new_message(etl::move(other.get()));
2975  }
2976  }
2977  #endif
2978 
2979  //**********************************************
2980  message_packet& operator =(const message_packet& rhs)
2981  {
2982  delete_current_message();
2983  valid = rhs.is_valid();
2984  if (valid)
2985  {
2986  add_new_message(rhs.get());
2987  }
2988 
2989  return *this;
2990  }
2991 
2992  #if ETL_CPP11_SUPPORTED
2993  //**********************************************
2994  message_packet& operator =(message_packet&& rhs)
2995  {
2996  delete_current_message();
2997  valid = rhs.is_valid();
2998  if (valid)
2999  {
3000  add_new_message(etl::move(rhs.get()));
3001  }
3002 
3003  return *this;
3004  }
3005  #endif
3006 
3007  //********************************************
3008  ~message_packet()
3009  {
3010  delete_current_message();
3011  }
3012 
3013  //********************************************
3014  etl::imessage& get() ETL_NOEXCEPT
3015  {
3016  return *static_cast<etl::imessage*>(data);
3017  }
3018 
3019  //********************************************
3020  const etl::imessage& get() const ETL_NOEXCEPT
3021  {
3022  return *static_cast<const etl::imessage*>(data);
3023  }
3024 
3025  //********************************************
3026  bool is_valid() const
3027  {
3028  return valid;
3029  }
3030 
3031  enum
3032  {
3033  SIZE = etl::largest<T1>::size,
3034  ALIGNMENT = etl::largest<T1>::alignment
3035  };
3036 
3037  private:
3038 
3039  //********************************************
3040  void delete_current_message()
3041  {
3042  if (valid)
3043  {
3044  etl::imessage* pmsg = static_cast<etl::imessage*>(data);
3045 
3046  #if defined(ETL_MESSAGES_ARE_VIRTUAL) || defined(ETL_POLYMORPHIC_MESSAGES)
3047  pmsg->~imessage();
3048  #else
3049  size_t id = pmsg->message_id;
3050 
3051  switch (id)
3052  {
3053  case T1::ID: static_cast<T1*>(pmsg)->~T1(); break;
3054  default: assert(false); break;
3055  }
3056  #endif
3057  }
3058  }
3059 
3060  //********************************************
3061  void add_new_message(const etl::imessage& msg)
3062  {
3063  const size_t id = msg.message_id;
3064  void* p = data;
3065 
3066  switch (id)
3067  {
3068  case T1::ID: ::new (p) T1(static_cast<const T1&>(msg)); break;
3069  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
3070  }
3071  }
3072 
3073  #if ETL_CPP11_SUPPORTED
3074  //********************************************
3075  void add_new_message(etl::imessage&& msg)
3076  {
3077  const size_t id = msg.message_id;
3078  void* p = data;
3079 
3080  switch (id)
3081  {
3082  case T1::ID: ::new (p) T1(static_cast<T1&&>(msg)); break;
3083  default: ETL_ASSERT(false, ETL_ERROR(unhandled_message_exception)); break;
3084  }
3085  }
3086  #endif
3087 
3089  bool valid;
3090  };
3091 }
3092 
3093 #undef ETL_FILE
3094 
3095 #endif
Definition: message.h:68
Definition: message_packet.h:76
Definition: message.h:57
#define ETL_ASSERT(b, e)
Definition: error_handler.h:290
Definition: largest.h:362
Definition: absolute.h:37
Definition: alignment.h:118