Embedded Template Library 1.0
Loading...
Searching...
No Matches
message_router.h
1/******************************************************************************
2The MIT License(MIT)
3
4Embedded Template Library.
5https://github.com/ETLCPP/etl
6https://www.etlcpp.com
7
8Copyright(c) 2017 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// cog -d -e -omessage_router.h -DHandlers=<n> message_router_generator.h
42// Where <n> is the maximum number of messages to support.
43//
44// e.g.
45// To generate handlers for up to 16 messages...
46// cog -d -e -omessage_router.h -DHandlers=16 message_router_generator.h
47//
48// See generate.bat
49//***************************************************************************
50
51#ifndef ETL_MESSAGE_ROUTER_INCLUDED
52#define ETL_MESSAGE_ROUTER_INCLUDED
53
54#include "platform.h"
55#include "message.h"
56#include "shared_message.h"
57#include "message_packet.h"
58#include "message_types.h"
59#include "alignment.h"
60#include "error_handler.h"
61#include "exception.h"
62#include "largest.h"
63#include "nullptr.h"
64#include "placement_new.h"
65#include "successor.h"
66#include "type_traits.h"
67
68#include <stdint.h>
69
70namespace etl
71{
72 //***************************************************************************
74 //***************************************************************************
75 class message_router_exception : public etl::exception
76 {
77 public:
78
79 message_router_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
80 : etl::exception(reason_, file_name_, line_number_)
81 {
82 }
83 };
84
85 //***************************************************************************
87 //***************************************************************************
88 class message_router_illegal_id : public etl::message_router_exception
89 {
90 public:
91
92 message_router_illegal_id(string_type file_name_, numeric_type line_number_)
93 : message_router_exception(ETL_ERROR_TEXT("message router:illegal id", ETL_MESSAGE_ROUTER_FILE_ID"A"), file_name_, line_number_)
94 {
95 }
96 };
97
98 //***************************************************************************
100 //***************************************************************************
101 class imessage_router;
102
103 etl::imessage_router& get_null_message_router();
104
105 //***************************************************************************
107 //***************************************************************************
108 class imessage_router : public etl::successor<imessage_router>
109 {
110 public:
111
112 virtual ~imessage_router() {}
113 virtual void receive(const etl::imessage&) = 0;
114 virtual bool accepts(etl::message_id_t) const = 0;
115 virtual bool is_null_router() const = 0;
116 virtual bool is_producer() const = 0;
117 virtual bool is_consumer() const = 0;
118
119 //********************************************
120 virtual void receive(etl::message_router_id_t destination_router_id, const etl::imessage& message)
121 {
122 if ((destination_router_id == get_message_router_id()) || (destination_router_id == imessage_router::ALL_MESSAGE_ROUTERS))
123 {
124 receive(message);
125 }
126 }
127
128 //********************************************
129 virtual void receive(etl::shared_message shared_msg)
130 {
131 receive(shared_msg.get_message());
132 }
133
134 //********************************************
135 virtual void receive(etl::message_router_id_t destination_router_id, etl::shared_message shared_msg)
136 {
137 if ((destination_router_id == get_message_router_id()) || (destination_router_id == imessage_router::ALL_MESSAGE_ROUTERS))
138 {
139 receive(shared_msg);
140 }
141 }
142
143 //********************************************
144 bool accepts(const etl::imessage& msg) const
145 {
146 return accepts(msg.get_message_id());
147 }
148
149 //********************************************
150 etl::message_router_id_t get_message_router_id() const
151 {
152 return message_router_id;
153 }
154
155 enum
156 {
157 NULL_MESSAGE_ROUTER = 255,
158 MESSAGE_BUS = 254,
159 ALL_MESSAGE_ROUTERS = 253,
160 MESSAGE_BROKER = 252,
161 MESSAGE_ROUTER = 251,
162 MAX_MESSAGE_ROUTER = 249
163 };
164
165 protected:
166
167 imessage_router(etl::message_router_id_t id_)
168 : message_router_id(id_)
169 {
170 }
171
172 imessage_router(etl::message_router_id_t id_, imessage_router& successor_)
173 : successor(successor_)
174 , message_router_id(id_)
175 {
176 }
177
178 private:
179
180 // Disabled.
181 imessage_router(const imessage_router&);
182 imessage_router& operator =(const imessage_router&);
183
184 etl::message_router_id_t message_router_id;
185 };
186
187 //***************************************************************************
189 //***************************************************************************
190 class null_message_router : public imessage_router
191 {
192 public:
193
194 //********************************************
195 null_message_router()
196 : imessage_router(imessage_router::NULL_MESSAGE_ROUTER)
197 {
198 }
199
200 //********************************************
201 null_message_router(etl::imessage_router& successor_)
202 : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
203 {
204 }
205
206 //********************************************
207 using etl::imessage_router::receive;
208
209 void receive(const etl::imessage& msg) ETL_OVERRIDE
210 {
211 if (has_successor())
212 {
213 get_successor().receive(msg);
214 }
215 }
216
217 //********************************************
218 using etl::imessage_router::accepts;
219
220 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
221 {
222 if (has_successor())
223 {
224 return get_successor().accepts(id);
225 }
226 else
227 {
228 return false;
229 }
230 }
231
232 //********************************************
233 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
234 {
235 return true;
236 }
237
238 //********************************************
239 bool is_producer() const ETL_OVERRIDE
240 {
241 return false;
242 }
243
244 //********************************************
245 bool is_consumer() const ETL_OVERRIDE
246 {
247 return false;
248 }
249
250 //********************************************
251 static null_message_router& instance()
252 {
253 static null_message_router nmr;
254 return nmr;
255 }
256 };
257
258 //***********************************************
260 inline etl::imessage_router& get_null_message_router()
261 {
262 return etl::null_message_router::instance();
263 }
264
265 //***************************************************************************
267 //***************************************************************************
268 class message_producer : public imessage_router
269 {
270 public:
271
272 //********************************************
273 message_producer()
274 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
275 {
276 }
277
278 //********************************************
279 message_producer(etl::imessage_router& successor_)
280 : imessage_router(imessage_router::NULL_MESSAGE_ROUTER, successor_)
281 {
282 }
283
284 //********************************************
285 message_producer(etl::message_router_id_t id_)
286 : imessage_router(id_)
287 {
288 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
289 }
290
291 //********************************************
292 message_producer(etl::message_router_id_t id_, etl::imessage_router& successor_)
293 : imessage_router(id_, successor_)
294 {
295 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
296 }
297
298 //********************************************
299 using etl::imessage_router::receive;
300
301 void receive(const etl::imessage& msg) ETL_OVERRIDE
302 {
303 if (has_successor())
304 {
305 get_successor().receive(msg);
306 }
307 }
308
309 //********************************************
310 using etl::imessage_router::accepts;
311
312 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
313 {
314 if (has_successor())
315 {
316 return get_successor().accepts(id);
317 }
318 else
319 {
320 return false;
321 }
322 }
323
324 //********************************************
325 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
326 {
327 return false;
328 }
329
330 //********************************************
331 bool is_producer() const ETL_OVERRIDE
332 {
333 return true;
334 }
335
336 //********************************************
337 bool is_consumer() const ETL_OVERRIDE
338 {
339 return false;
340 }
341 };
342
343 //***************************************************************************
345 //***************************************************************************
346 template <typename T>
347 struct is_message_router : public etl::bool_constant<etl::is_base_of<etl::imessage_router, typename etl::remove_cvref<T>::type>::value>
348 {
349 };
350
351 //***************************************************************************
353 //***************************************************************************
354 template <typename TRouter, typename TMessage>
355 static
356 typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
357 send_message(TRouter& destination,
358 const TMessage& message)
359 {
360 destination.receive(message);
361 }
362
363 //***************************************************************************
365 //***************************************************************************
366 template <typename TRouter>
367 static
368 typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
369 send_message(TRouter& destination,
370 etl::shared_message message)
371 {
372 destination.receive(message);
373 }
374
375 //***************************************************************************
377 //***************************************************************************
378 template <typename TRouter, typename TMessage>
379 static
380 typename etl::enable_if<etl::is_message_router<TRouter>::value && etl::is_message<TMessage>::value, void>::type
381 send_message(TRouter& destination,
382 etl::message_router_id_t id,
383 const TMessage& message)
384 {
385 destination.receive(id, message);
386 }
387
388 //***************************************************************************
390 //***************************************************************************
391 template <typename TRouter>
392 static
393 typename etl::enable_if<etl::is_message_router<TRouter>::value, void>::type
394 send_message(TRouter& destination,
395 etl::message_router_id_t id,
396 etl::shared_message message)
397 {
398 destination.receive(id, message);
399 }
400
401//*************************************************************************************************
402// For C++17 and above.
403//*************************************************************************************************
404#if ETL_USING_CPP17 && !defined(ETL_MESSAGE_ROUTER_FORCE_CPP03_IMPLEMENTATION)
405 //***************************************************************************
406 // The definition for all message types.
407 //***************************************************************************
408 template <typename TDerived, typename... TMessageTypes>
409 class message_router : public imessage_router
410 {
411 public:
412
413 typedef etl::message_packet<TMessageTypes...> message_packet;
414
415 //**********************************************
416 message_router()
417 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
418 {
419 }
420
421 //**********************************************
422 message_router(etl::imessage_router& successor_)
423 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
424 {
425 }
426
427 //**********************************************
428 message_router(etl::message_router_id_t id_)
429 : imessage_router(id_)
430 {
431 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
432 }
433
434 //**********************************************
435 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
436 : imessage_router(id_, successor_)
437 {
438 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
439 }
440
441 //**********************************************
442 using etl::imessage_router::receive;
443
444 void receive(const etl::imessage& msg) ETL_OVERRIDE
445 {
446 const bool was_handled = (receive_message_type<TMessageTypes>(msg) || ...);
447
448 if (!was_handled)
449 {
450 if (has_successor())
451 {
452 get_successor().receive(msg);
453 }
454 else
455 {
456 static_cast<TDerived*>(this)->on_receive_unknown(msg);
457 }
458 }
459 }
460
461 template <typename TMessage, typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value, int>::type = 0>
462 void receive(const TMessage& msg)
463 {
464 if constexpr (etl::is_one_of<TMessage, TMessageTypes...>::value)
465 {
466 static_cast<TDerived*>(this)->on_receive(msg);
467 }
468 else
469 {
470 if (has_successor())
471 {
472 get_successor().receive(msg);
473 }
474 else
475 {
476 static_cast<TDerived*>(this)->on_receive_unknown(msg);
477 }
478 }
479 }
480
481 //**********************************************
482 using imessage_router::accepts;
483
484 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
485 {
486 return (accepts_type<TMessageTypes>(id) || ...);
487 }
488
489 //********************************************
490 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
491 {
492 return false;
493 }
494
495 //********************************************
496 bool is_producer() const ETL_OVERRIDE
497 {
498 return true;
499 }
500
501 //********************************************
502 bool is_consumer() const ETL_OVERRIDE
503 {
504 return true;
505 }
506
507 private:
508
509 //********************************************
510 template <typename TMessage>
511 bool receive_message_type(const etl::imessage& msg)
512 {
513 if (TMessage::ID == msg.get_message_id())
514 {
515 static_cast<TDerived*>(this)->on_receive(static_cast<const TMessage&>(msg));
516 return true;
517 }
518 else
519 {
520 return false;
521 }
522 }
523
524 //********************************************
525 template <typename TMessage>
526 bool accepts_type(etl::message_id_t id) const
527 {
528 if (TMessage::ID == id)
529 {
530 return true;
531 }
532 else
533 {
534 if (has_successor())
535 {
536 return get_successor().accepts(id);
537 }
538 else
539 {
540 return false;
541 }
542 }
543 }
544 };
545#else
546//*************************************************************************************************
547// For C++14 and below.
548//*************************************************************************************************
549 //***************************************************************************
550 // The definition for all 16 message types.
551 //***************************************************************************
552 template <typename TDerived,
553 typename T1, typename T2 = void, typename T3 = void, typename T4 = void,
554 typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void,
555 typename T9 = void, typename T10 = void, typename T11 = void, typename T12 = void,
556 typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void>
557 class message_router : public imessage_router
558 {
559 public:
560
561 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> message_packet;
562
563 //**********************************************
564 message_router(etl::message_router_id_t id_)
565 : imessage_router(id_)
566 {
567 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
568 }
569
570 //**********************************************
571 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
572 : imessage_router(id_, successor_)
573 {
574 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
575 }
576
577 //**********************************************
578 message_router()
579 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
580 {
581 }
582
583 //**********************************************
584 message_router(etl::imessage_router& successor_)
585 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
586 {
587 }
588
589 //**********************************************
590 using etl::imessage_router::receive;
591
592 void receive(const etl::imessage& msg) ETL_OVERRIDE
593 {
594 const etl::message_id_t id = msg.get_message_id();
595
596 switch (id)
597 {
598 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
599 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
600 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
601 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
602 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
603 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
604 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
605 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
606 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
607 case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
608 case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
609 case T12::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T12&>(msg)); break;
610 case T13::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T13&>(msg)); break;
611 case T14::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T14&>(msg)); break;
612 case T15::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T15&>(msg)); break;
613 case T16::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T16&>(msg)); break;
614 default:
615 {
616 if (has_successor())
617 {
618 get_successor().receive(msg);
619 }
620 else
621 {
622 static_cast<TDerived*>(this)->on_receive_unknown(msg);
623 }
624 break;
625 }
626 }
627 }
628
629 template <typename TMessage>
630 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, void>::type
631 receive(const TMessage& msg)
632 {
633 static_cast<TDerived*>(this)->on_receive(msg);
634 }
635
636 template <typename TMessage>
637 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>::value, void>::type
638 receive(const TMessage& msg)
639 {
640 if (has_successor())
641 {
642 get_successor().receive(msg);
643 }
644 else
645 {
646 static_cast<TDerived*>(this)->on_receive_unknown(msg);
647 }
648 }
649
650 //**********************************************
651 using imessage_router::accepts;
652
653 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
654 {
655 switch (id)
656 {
657 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
658 case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID: case T14::ID: case T15::ID: case T16::ID:
659 return true;
660 default:
661 {
662 if (has_successor())
663 {
664 return get_successor().accepts(id);
665 }
666 else
667 {
668 return false;
669 }
670 }
671 }
672 }
673
674 //********************************************
675 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
676 {
677 return false;
678 }
679
680 //********************************************
681 bool is_producer() const ETL_OVERRIDE
682 {
683 return true;
684 }
685
686 //********************************************
687 bool is_consumer() const ETL_OVERRIDE
688 {
689 return true;
690 }
691 };
692
693 //***************************************************************************
694 // Specialisation for 15 message types.
695 //***************************************************************************
696 template <typename TDerived,
697 typename T1, typename T2, typename T3, typename T4,
698 typename T5, typename T6, typename T7, typename T8,
699 typename T9, typename T10, typename T11, typename T12,
700 typename T13, typename T14, typename T15>
701 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void>
702 : public imessage_router
703 {
704 public:
705
706 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> message_packet;
707
708 //**********************************************
709 message_router(etl::message_router_id_t id_)
710 : imessage_router(id_)
711 {
712 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
713 }
714
715 //**********************************************
716 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
717 : imessage_router(id_, successor_)
718 {
719 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
720 }
721
722 //**********************************************
723 message_router()
724 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
725 {
726 }
727
728 //**********************************************
729 message_router(etl::imessage_router& successor_)
730 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
731 {
732 }
733
734 //**********************************************
735 using etl::imessage_router::receive;
736
737 void receive(const etl::imessage& msg) ETL_OVERRIDE
738 {
739 const size_t id = msg.get_message_id();
740
741 switch (id)
742 {
743 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
744 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
745 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
746 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
747 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
748 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
749 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
750 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
751 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
752 case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
753 case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
754 case T12::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T12&>(msg)); break;
755 case T13::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T13&>(msg)); break;
756 case T14::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T14&>(msg)); break;
757 case T15::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T15&>(msg)); break;
758 default:
759 {
760 if (has_successor())
761 {
762 get_successor().receive(msg);
763 }
764 else
765 {
766 static_cast<TDerived*>(this)->on_receive_unknown(msg);
767 }
768 break;
769 }
770 }
771 }
772
773 template <typename TMessage>
774 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, void>::type
775 receive(const TMessage& msg)
776 {
777 static_cast<TDerived*>(this)->on_receive(msg);
778 }
779
780 template <typename TMessage>
781 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::value, void>::type
782 receive(const TMessage& msg)
783 {
784 if (has_successor())
785 {
786 get_successor().receive(msg);
787 }
788 else
789 {
790 static_cast<TDerived*>(this)->on_receive_unknown(msg);
791 }
792 }
793
794
795 //**********************************************
796 using imessage_router::accepts;
797
798 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
799 {
800 switch (id)
801 {
802 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
803 case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID: case T14::ID: case T15::ID:
804 return true;
805 default:
806 {
807 if (has_successor())
808 {
809 return get_successor().accepts(id);
810 }
811 else
812 {
813 return false;
814 }
815 }
816 }
817 }
818
819 //********************************************
820 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
821 {
822 return false;
823 }
824
825 //********************************************
826 bool is_producer() const ETL_OVERRIDE
827 {
828 return true;
829 }
830
831 //********************************************
832 bool is_consumer() const ETL_OVERRIDE
833 {
834 return true;
835 }
836 };
837
838 //***************************************************************************
839 // Specialisation for 14 message types.
840 //***************************************************************************
841 template <typename TDerived,
842 typename T1, typename T2, typename T3, typename T4,
843 typename T5, typename T6, typename T7, typename T8,
844 typename T9, typename T10, typename T11, typename T12,
845 typename T13, typename T14>
846 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void>
847 : public imessage_router
848 {
849 public:
850
851 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> message_packet;
852
853 //**********************************************
854 message_router(etl::message_router_id_t id_)
855 : imessage_router(id_)
856 {
857 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
858 }
859
860 //**********************************************
861 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
862 : imessage_router(id_, successor_)
863 {
864 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
865 }
866
867 //**********************************************
868 message_router()
869 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
870 {
871 }
872
873 //**********************************************
874 message_router(etl::imessage_router& successor_)
875 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
876 {
877 }
878
879 //**********************************************
880 using etl::imessage_router::receive;
881
882 void receive(const etl::imessage& msg) ETL_OVERRIDE
883 {
884 const size_t id = msg.get_message_id();
885
886 switch (id)
887 {
888 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
889 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
890 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
891 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
892 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
893 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
894 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
895 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
896 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
897 case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
898 case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
899 case T12::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T12&>(msg)); break;
900 case T13::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T13&>(msg)); break;
901 case T14::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T14&>(msg)); break;
902 default:
903 {
904 if (has_successor())
905 {
906 get_successor().receive(msg);
907 }
908 else
909 {
910 static_cast<TDerived*>(this)->on_receive_unknown(msg);
911 }
912 break;
913 }
914 }
915 }
916
917 template <typename TMessage>
918 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, void>::type
919 receive(const TMessage& msg)
920 {
921 static_cast<TDerived*>(this)->on_receive(msg);
922 }
923
924 template <typename TMessage>
925 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::value, void>::type
926 receive(const TMessage& msg)
927 {
928 if (has_successor())
929 {
930 get_successor().receive(msg);
931 }
932 else
933 {
934 static_cast<TDerived*>(this)->on_receive_unknown(msg);
935 }
936 }
937
938
939 //**********************************************
940 using imessage_router::accepts;
941
942 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
943 {
944 switch (id)
945 {
946 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
947 case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID: case T14::ID:
948 return true;
949 default:
950 {
951 if (has_successor())
952 {
953 return get_successor().accepts(id);
954 }
955 else
956 {
957 return false;
958 }
959 }
960 }
961 }
962
963 //********************************************
964 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
965 {
966 return false;
967 }
968
969 //********************************************
970 bool is_producer() const ETL_OVERRIDE
971 {
972 return true;
973 }
974
975 //********************************************
976 bool is_consumer() const ETL_OVERRIDE
977 {
978 return true;
979 }
980 };
981
982 //***************************************************************************
983 // Specialisation for 13 message types.
984 //***************************************************************************
985 template <typename TDerived,
986 typename T1, typename T2, typename T3, typename T4,
987 typename T5, typename T6, typename T7, typename T8,
988 typename T9, typename T10, typename T11, typename T12,
989 typename T13>
990 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void>
991 : public imessage_router
992 {
993 public:
994
995 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> message_packet;
996
997 //**********************************************
998 message_router(etl::message_router_id_t id_)
999 : imessage_router(id_)
1000 {
1001 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1002 }
1003
1004 //**********************************************
1005 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1006 : imessage_router(id_, successor_)
1007 {
1008 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1009 }
1010
1011 //**********************************************
1012 message_router()
1013 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1014 {
1015 }
1016
1017 //**********************************************
1018 message_router(etl::imessage_router& successor_)
1019 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1020 {
1021 }
1022
1023 //**********************************************
1024 using etl::imessage_router::receive;
1025
1026 void receive(const etl::imessage& msg) ETL_OVERRIDE
1027 {
1028 const size_t id = msg.get_message_id();
1029
1030 switch (id)
1031 {
1032 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
1033 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
1034 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
1035 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
1036 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
1037 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
1038 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
1039 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
1040 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
1041 case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
1042 case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
1043 case T12::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T12&>(msg)); break;
1044 case T13::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T13&>(msg)); break;
1045 default:
1046 {
1047 if (has_successor())
1048 {
1049 get_successor().receive(msg);
1050 }
1051 else
1052 {
1053 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1054 }
1055 break;
1056 }
1057 }
1058 }
1059
1060 template <typename TMessage>
1061 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, void>::type
1062 receive(const TMessage& msg)
1063 {
1064 static_cast<TDerived*>(this)->on_receive(msg);
1065 }
1066
1067 template <typename TMessage>
1068 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::value, void>::type
1069 receive(const TMessage& msg)
1070 {
1071 if (has_successor())
1072 {
1073 get_successor().receive(msg);
1074 }
1075 else
1076 {
1077 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1078 }
1079 }
1080
1081
1082 //**********************************************
1083 using imessage_router::accepts;
1084
1085 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
1086 {
1087 switch (id)
1088 {
1089 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
1090 case T9::ID: case T10::ID: case T11::ID: case T12::ID: case T13::ID:
1091 return true;
1092 default:
1093 {
1094 if (has_successor())
1095 {
1096 return get_successor().accepts(id);
1097 }
1098 else
1099 {
1100 return false;
1101 }
1102 }
1103 }
1104 }
1105
1106 //********************************************
1107 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
1108 {
1109 return false;
1110 }
1111
1112 //********************************************
1113 bool is_producer() const ETL_OVERRIDE
1114 {
1115 return true;
1116 }
1117
1118 //********************************************
1119 bool is_consumer() const ETL_OVERRIDE
1120 {
1121 return true;
1122 }
1123 };
1124
1125 //***************************************************************************
1126 // Specialisation for 12 message types.
1127 //***************************************************************************
1128 template <typename TDerived,
1129 typename T1, typename T2, typename T3, typename T4,
1130 typename T5, typename T6, typename T7, typename T8,
1131 typename T9, typename T10, typename T11, typename T12>
1132 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void>
1133 : public imessage_router
1134 {
1135 public:
1136
1137 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> message_packet;
1138
1139 //**********************************************
1140 message_router(etl::message_router_id_t id_)
1141 : imessage_router(id_)
1142 {
1143 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1144 }
1145
1146 //**********************************************
1147 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1148 : imessage_router(id_, successor_)
1149 {
1150 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1151 }
1152
1153 //**********************************************
1154 message_router()
1155 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1156 {
1157 }
1158
1159 //**********************************************
1160 message_router(etl::imessage_router& successor_)
1161 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1162 {
1163 }
1164
1165 //**********************************************
1166 using etl::imessage_router::receive;
1167
1168 void receive(const etl::imessage& msg) ETL_OVERRIDE
1169 {
1170 const size_t id = msg.get_message_id();
1171
1172 switch (id)
1173 {
1174 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
1175 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
1176 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
1177 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
1178 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
1179 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
1180 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
1181 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
1182 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
1183 case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
1184 case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
1185 case T12::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T12&>(msg)); break;
1186 default:
1187 {
1188 if (has_successor())
1189 {
1190 get_successor().receive(msg);
1191 }
1192 else
1193 {
1194 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1195 }
1196 break;
1197 }
1198 }
1199 }
1200
1201 template <typename TMessage>
1202 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, void>::type
1203 receive(const TMessage& msg)
1204 {
1205 static_cast<TDerived*>(this)->on_receive(msg);
1206 }
1207
1208 template <typename TMessage>
1209 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::value, void>::type
1210 receive(const TMessage& msg)
1211 {
1212 if (has_successor())
1213 {
1214 get_successor().receive(msg);
1215 }
1216 else
1217 {
1218 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1219 }
1220 }
1221
1222
1223 //**********************************************
1224 using imessage_router::accepts;
1225
1226 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
1227 {
1228 switch (id)
1229 {
1230 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
1231 case T9::ID: case T10::ID: case T11::ID: case T12::ID:
1232 return true;
1233 default:
1234 {
1235 if (has_successor())
1236 {
1237 return get_successor().accepts(id);
1238 }
1239 else
1240 {
1241 return false;
1242 }
1243 }
1244 }
1245 }
1246
1247 //********************************************
1248 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
1249 {
1250 return false;
1251 }
1252
1253 //********************************************
1254 bool is_producer() const ETL_OVERRIDE
1255 {
1256 return true;
1257 }
1258
1259 //********************************************
1260 bool is_consumer() const ETL_OVERRIDE
1261 {
1262 return true;
1263 }
1264 };
1265
1266 //***************************************************************************
1267 // Specialisation for 11 message types.
1268 //***************************************************************************
1269 template <typename TDerived,
1270 typename T1, typename T2, typename T3, typename T4,
1271 typename T5, typename T6, typename T7, typename T8,
1272 typename T9, typename T10, typename T11>
1273 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void>
1274 : public imessage_router
1275 {
1276 public:
1277
1278 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> message_packet;
1279
1280 //**********************************************
1281 message_router(etl::message_router_id_t id_)
1282 : imessage_router(id_)
1283 {
1284 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1285 }
1286
1287 //**********************************************
1288 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1289 : imessage_router(id_, successor_)
1290 {
1291 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1292 }
1293
1294 //**********************************************
1295 message_router()
1296 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1297 {
1298 }
1299
1300 //**********************************************
1301 message_router(etl::imessage_router& successor_)
1302 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1303 {
1304 }
1305
1306 //**********************************************
1307 using etl::imessage_router::receive;
1308
1309 void receive(const etl::imessage& msg) ETL_OVERRIDE
1310 {
1311 const size_t id = msg.get_message_id();
1312
1313 switch (id)
1314 {
1315 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
1316 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
1317 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
1318 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
1319 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
1320 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
1321 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
1322 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
1323 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
1324 case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
1325 case T11::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T11&>(msg)); break;
1326 default:
1327 {
1328 if (has_successor())
1329 {
1330 get_successor().receive(msg);
1331 }
1332 else
1333 {
1334 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1335 }
1336 break;
1337 }
1338 }
1339 }
1340
1341 template <typename TMessage>
1342 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, void>::type
1343 receive(const TMessage& msg)
1344 {
1345 static_cast<TDerived*>(this)->on_receive(msg);
1346 }
1347
1348 template <typename TMessage>
1349 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::value, void>::type
1350 receive(const TMessage& msg)
1351 {
1352 if (has_successor())
1353 {
1354 get_successor().receive(msg);
1355 }
1356 else
1357 {
1358 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1359 }
1360 }
1361
1362
1363 //**********************************************
1364 using imessage_router::accepts;
1365
1366 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
1367 {
1368 switch (id)
1369 {
1370 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
1371 case T9::ID: case T10::ID: case T11::ID:
1372 return true;
1373 default:
1374 {
1375 if (has_successor())
1376 {
1377 return get_successor().accepts(id);
1378 }
1379 else
1380 {
1381 return false;
1382 }
1383 }
1384 }
1385 }
1386
1387 //********************************************
1388 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
1389 {
1390 return false;
1391 }
1392
1393 //********************************************
1394 bool is_producer() const ETL_OVERRIDE
1395 {
1396 return true;
1397 }
1398
1399 //********************************************
1400 bool is_consumer() const ETL_OVERRIDE
1401 {
1402 return true;
1403 }
1404 };
1405
1406 //***************************************************************************
1407 // Specialisation for 10 message types.
1408 //***************************************************************************
1409 template <typename TDerived,
1410 typename T1, typename T2, typename T3, typename T4,
1411 typename T5, typename T6, typename T7, typename T8,
1412 typename T9, typename T10>
1413 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void>
1414 : public imessage_router
1415 {
1416 public:
1417
1418 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> message_packet;
1419
1420 //**********************************************
1421 message_router(etl::message_router_id_t id_)
1422 : imessage_router(id_)
1423 {
1424 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1425 }
1426
1427 //**********************************************
1428 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1429 : imessage_router(id_, successor_)
1430 {
1431 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1432 }
1433
1434 //**********************************************
1435 message_router()
1436 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1437 {
1438 }
1439
1440 //**********************************************
1441 message_router(etl::imessage_router& successor_)
1442 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1443 {
1444 }
1445
1446 //**********************************************
1447 using etl::imessage_router::receive;
1448
1449 void receive(const etl::imessage& msg) ETL_OVERRIDE
1450 {
1451 const size_t id = msg.get_message_id();
1452
1453 switch (id)
1454 {
1455 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
1456 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
1457 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
1458 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
1459 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
1460 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
1461 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
1462 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
1463 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
1464 case T10::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T10&>(msg)); break;
1465 default:
1466 {
1467 if (has_successor())
1468 {
1469 get_successor().receive(msg);
1470 }
1471 else
1472 {
1473 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1474 }
1475 break;
1476 }
1477 }
1478 }
1479
1480 template <typename TMessage>
1481 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, void>::type
1482 receive(const TMessage& msg)
1483 {
1484 static_cast<TDerived*>(this)->on_receive(msg);
1485 }
1486
1487 template <typename TMessage>
1488 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value, void>::type
1489 receive(const TMessage& msg)
1490 {
1491 if (has_successor())
1492 {
1493 get_successor().receive(msg);
1494 }
1495 else
1496 {
1497 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1498 }
1499 }
1500
1501
1502 //**********************************************
1503 using imessage_router::accepts;
1504
1505 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
1506 {
1507 switch (id)
1508 {
1509 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
1510 case T9::ID: case T10::ID:
1511 return true;
1512 default:
1513 {
1514 if (has_successor())
1515 {
1516 return get_successor().accepts(id);
1517 }
1518 else
1519 {
1520 return false;
1521 }
1522 }
1523 }
1524 }
1525
1526 //********************************************
1527 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
1528 {
1529 return false;
1530 }
1531
1532 //********************************************
1533 bool is_producer() const ETL_OVERRIDE
1534 {
1535 return true;
1536 }
1537
1538 //********************************************
1539 bool is_consumer() const ETL_OVERRIDE
1540 {
1541 return true;
1542 }
1543 };
1544
1545 //***************************************************************************
1546 // Specialisation for 9 message types.
1547 //***************************************************************************
1548 template <typename TDerived,
1549 typename T1, typename T2, typename T3, typename T4,
1550 typename T5, typename T6, typename T7, typename T8,
1551 typename T9>
1552 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void>
1553 : public imessage_router
1554 {
1555 public:
1556
1557 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8, T9> message_packet;
1558
1559 //**********************************************
1560 message_router(etl::message_router_id_t id_)
1561 : imessage_router(id_)
1562 {
1563 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1564 }
1565
1566 //**********************************************
1567 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1568 : imessage_router(id_, successor_)
1569 {
1570 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1571 }
1572
1573 //**********************************************
1574 message_router()
1575 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1576 {
1577 }
1578
1579 //**********************************************
1580 message_router(etl::imessage_router& successor_)
1581 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1582 {
1583 }
1584
1585 //**********************************************
1586 using etl::imessage_router::receive;
1587
1588 void receive(const etl::imessage& msg) ETL_OVERRIDE
1589 {
1590 const size_t id = msg.get_message_id();
1591
1592 switch (id)
1593 {
1594 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
1595 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
1596 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
1597 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
1598 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
1599 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
1600 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
1601 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
1602 case T9::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T9&>(msg)); break;
1603 default:
1604 {
1605 if (has_successor())
1606 {
1607 get_successor().receive(msg);
1608 }
1609 else
1610 {
1611 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1612 }
1613 break;
1614 }
1615 }
1616 }
1617
1618 template <typename TMessage>
1619 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, void>::type
1620 receive(const TMessage& msg)
1621 {
1622 static_cast<TDerived*>(this)->on_receive(msg);
1623 }
1624
1625 template <typename TMessage>
1626 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8, T9>::value, void>::type
1627 receive(const TMessage& msg)
1628 {
1629 if (has_successor())
1630 {
1631 get_successor().receive(msg);
1632 }
1633 else
1634 {
1635 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1636 }
1637 }
1638
1639
1640 //**********************************************
1641 using imessage_router::accepts;
1642
1643 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
1644 {
1645 switch (id)
1646 {
1647 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
1648 case T9::ID:
1649 return true;
1650 default:
1651 {
1652 if (has_successor())
1653 {
1654 return get_successor().accepts(id);
1655 }
1656 else
1657 {
1658 return false;
1659 }
1660 }
1661 }
1662 }
1663
1664 //********************************************
1665 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
1666 {
1667 return false;
1668 }
1669
1670 //********************************************
1671 bool is_producer() const ETL_OVERRIDE
1672 {
1673 return true;
1674 }
1675
1676 //********************************************
1677 bool is_consumer() const ETL_OVERRIDE
1678 {
1679 return true;
1680 }
1681 };
1682
1683 //***************************************************************************
1684 // Specialisation for 8 message types.
1685 //***************************************************************************
1686 template <typename TDerived,
1687 typename T1, typename T2, typename T3, typename T4,
1688 typename T5, typename T6, typename T7, typename T8>
1689 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void>
1690 : public imessage_router
1691 {
1692 public:
1693
1694 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7, T8> message_packet;
1695
1696 //**********************************************
1697 message_router(etl::message_router_id_t id_)
1698 : imessage_router(id_)
1699 {
1700 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1701 }
1702
1703 //**********************************************
1704 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1705 : imessage_router(id_, successor_)
1706 {
1707 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1708 }
1709
1710 //**********************************************
1711 message_router()
1712 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1713 {
1714 }
1715
1716 //**********************************************
1717 message_router(etl::imessage_router& successor_)
1718 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1719 {
1720 }
1721
1722 //**********************************************
1723 using etl::imessage_router::receive;
1724
1725 void receive(const etl::imessage& msg) ETL_OVERRIDE
1726 {
1727 const size_t id = msg.get_message_id();
1728
1729 switch (id)
1730 {
1731 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
1732 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
1733 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
1734 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
1735 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
1736 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
1737 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
1738 case T8::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T8&>(msg)); break;
1739 default:
1740 {
1741 if (has_successor())
1742 {
1743 get_successor().receive(msg);
1744 }
1745 else
1746 {
1747 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1748 }
1749 break;
1750 }
1751 }
1752 }
1753
1754 template <typename TMessage>
1755 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8>::value, void>::type
1756 receive(const TMessage& msg)
1757 {
1758 static_cast<TDerived*>(this)->on_receive(msg);
1759 }
1760
1761 template <typename TMessage>
1762 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7, T8>::value, void>::type
1763 receive(const TMessage& msg)
1764 {
1765 if (has_successor())
1766 {
1767 get_successor().receive(msg);
1768 }
1769 else
1770 {
1771 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1772 }
1773 }
1774
1775
1776 //**********************************************
1777 using imessage_router::accepts;
1778
1779 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
1780 {
1781 switch (id)
1782 {
1783 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID: case T8::ID:
1784
1785 return true;
1786 default:
1787 {
1788 if (has_successor())
1789 {
1790 return get_successor().accepts(id);
1791 }
1792 else
1793 {
1794 return false;
1795 }
1796 }
1797 }
1798 }
1799
1800 //********************************************
1801 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
1802 {
1803 return false;
1804 }
1805
1806 //********************************************
1807 bool is_producer() const ETL_OVERRIDE
1808 {
1809 return true;
1810 }
1811
1812 //********************************************
1813 bool is_consumer() const ETL_OVERRIDE
1814 {
1815 return true;
1816 }
1817 };
1818
1819 //***************************************************************************
1820 // Specialisation for 7 message types.
1821 //***************************************************************************
1822 template <typename TDerived,
1823 typename T1, typename T2, typename T3, typename T4,
1824 typename T5, typename T6, typename T7>
1825 class message_router<TDerived, T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void>
1826 : public imessage_router
1827 {
1828 public:
1829
1830 typedef etl::message_packet<T1, T2, T3, T4, T5, T6, T7> message_packet;
1831
1832 //**********************************************
1833 message_router(etl::message_router_id_t id_)
1834 : imessage_router(id_)
1835 {
1836 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1837 }
1838
1839 //**********************************************
1840 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1841 : imessage_router(id_, successor_)
1842 {
1843 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1844 }
1845
1846 //**********************************************
1847 message_router()
1848 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1849 {
1850 }
1851
1852 //**********************************************
1853 message_router(etl::imessage_router& successor_)
1854 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1855 {
1856 }
1857
1858 //**********************************************
1859 using etl::imessage_router::receive;
1860
1861 void receive(const etl::imessage& msg) ETL_OVERRIDE
1862 {
1863 const size_t id = msg.get_message_id();
1864
1865 switch (id)
1866 {
1867 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
1868 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
1869 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
1870 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
1871 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
1872 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
1873 case T7::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T7&>(msg)); break;
1874 default:
1875 {
1876 if (has_successor())
1877 {
1878 get_successor().receive(msg);
1879 }
1880 else
1881 {
1882 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1883 }
1884 break;
1885 }
1886 }
1887 }
1888
1889 template <typename TMessage>
1890 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7>::value, void>::type
1891 receive(const TMessage& msg)
1892 {
1893 static_cast<TDerived*>(this)->on_receive(msg);
1894 }
1895
1896 template <typename TMessage>
1897 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6, T7>::value, void>::type
1898 receive(const TMessage& msg)
1899 {
1900 if (has_successor())
1901 {
1902 get_successor().receive(msg);
1903 }
1904 else
1905 {
1906 static_cast<TDerived*>(this)->on_receive_unknown(msg);
1907 }
1908 }
1909
1910
1911 //**********************************************
1912 using imessage_router::accepts;
1913
1914 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
1915 {
1916 switch (id)
1917 {
1918 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID: case T7::ID:
1919 return true;
1920 default:
1921 {
1922 if (has_successor())
1923 {
1924 return get_successor().accepts(id);
1925 }
1926 else
1927 {
1928 return false;
1929 }
1930 }
1931 }
1932 }
1933
1934 //********************************************
1935 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
1936 {
1937 return false;
1938 }
1939
1940 //********************************************
1941 bool is_producer() const ETL_OVERRIDE
1942 {
1943 return true;
1944 }
1945
1946 //********************************************
1947 bool is_consumer() const ETL_OVERRIDE
1948 {
1949 return true;
1950 }
1951 };
1952
1953 //***************************************************************************
1954 // Specialisation for 6 message types.
1955 //***************************************************************************
1956 template <typename TDerived,
1957 typename T1, typename T2, typename T3, typename T4,
1958 typename T5, typename T6>
1959 class message_router<TDerived, T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void>
1960 : public imessage_router
1961 {
1962 public:
1963
1964 typedef etl::message_packet<T1, T2, T3, T4, T5, T6> message_packet;
1965
1966 //**********************************************
1967 message_router(etl::message_router_id_t id_)
1968 : imessage_router(id_)
1969 {
1970 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1971 }
1972
1973 //**********************************************
1974 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
1975 : imessage_router(id_, successor_)
1976 {
1977 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1978 }
1979
1980 //**********************************************
1981 message_router()
1982 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1983 {
1984 }
1985
1986 //**********************************************
1987 message_router(etl::imessage_router& successor_)
1988 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
1989 {
1990 }
1991
1992 //**********************************************
1993 using etl::imessage_router::receive;
1994
1995 void receive(const etl::imessage& msg) ETL_OVERRIDE
1996 {
1997 const size_t id = msg.get_message_id();
1998
1999 switch (id)
2000 {
2001 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
2002 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
2003 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
2004 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
2005 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
2006 case T6::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T6&>(msg)); break;
2007 default:
2008 {
2009 if (has_successor())
2010 {
2011 get_successor().receive(msg);
2012 }
2013 else
2014 {
2015 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2016 }
2017 break;
2018 }
2019 }
2020 }
2021
2022 template <typename TMessage>
2023 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6>::value, void>::type
2024 receive(const TMessage& msg)
2025 {
2026 static_cast<TDerived*>(this)->on_receive(msg);
2027 }
2028
2029 template <typename TMessage>
2030 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5, T6>::value, void>::type
2031 receive(const TMessage& msg)
2032 {
2033 if (has_successor())
2034 {
2035 get_successor().receive(msg);
2036 }
2037 else
2038 {
2039 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2040 }
2041 }
2042
2043
2044 //**********************************************
2045 using imessage_router::accepts;
2046
2047 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
2048 {
2049 switch (id)
2050 {
2051 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID: case T6::ID:
2052 return true;
2053 default:
2054 {
2055 if (has_successor())
2056 {
2057 return get_successor().accepts(id);
2058 }
2059 else
2060 {
2061 return false;
2062 }
2063 }
2064 }
2065 }
2066
2067 //********************************************
2068 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
2069 {
2070 return false;
2071 }
2072
2073 //********************************************
2074 bool is_producer() const ETL_OVERRIDE
2075 {
2076 return true;
2077 }
2078
2079 //********************************************
2080 bool is_consumer() const ETL_OVERRIDE
2081 {
2082 return true;
2083 }
2084 };
2085
2086 //***************************************************************************
2087 // Specialisation for 5 message types.
2088 //***************************************************************************
2089 template <typename TDerived,
2090 typename T1, typename T2, typename T3, typename T4,
2091 typename T5>
2092 class message_router<TDerived, T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void>
2093 : public imessage_router
2094 {
2095 public:
2096
2097 typedef etl::message_packet<T1, T2, T3, T4, T5> message_packet;
2098
2099 //**********************************************
2100 message_router(etl::message_router_id_t id_)
2101 : imessage_router(id_)
2102 {
2103 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2104 }
2105
2106 //**********************************************
2107 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
2108 : imessage_router(id_, successor_)
2109 {
2110 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2111 }
2112
2113 //**********************************************
2114 message_router()
2115 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2116 {
2117 }
2118
2119 //**********************************************
2120 message_router(etl::imessage_router& successor_)
2121 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
2122 {
2123 }
2124
2125 //**********************************************
2126 using etl::imessage_router::receive;
2127
2128 void receive(const etl::imessage& msg) ETL_OVERRIDE
2129 {
2130 const size_t id = msg.get_message_id();
2131
2132 switch (id)
2133 {
2134 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
2135 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
2136 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
2137 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
2138 case T5::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T5&>(msg)); break;
2139 default:
2140 {
2141 if (has_successor())
2142 {
2143 get_successor().receive(msg);
2144 }
2145 else
2146 {
2147 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2148 }
2149 break;
2150 }
2151 }
2152 }
2153
2154 template <typename TMessage>
2155 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4, T5>::value, void>::type
2156 receive(const TMessage& msg)
2157 {
2158 static_cast<TDerived*>(this)->on_receive(msg);
2159 }
2160
2161 template <typename TMessage>
2162 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4, T5>::value, void>::type
2163 receive(const TMessage& msg)
2164 {
2165 if (has_successor())
2166 {
2167 get_successor().receive(msg);
2168 }
2169 else
2170 {
2171 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2172 }
2173 }
2174
2175
2176 //**********************************************
2177 using imessage_router::accepts;
2178
2179 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
2180 {
2181 switch (id)
2182 {
2183 case T1::ID: case T2::ID: case T3::ID: case T4::ID: case T5::ID:
2184 return true;
2185 default:
2186 {
2187 if (has_successor())
2188 {
2189 return get_successor().accepts(id);
2190 }
2191 else
2192 {
2193 return false;
2194 }
2195 }
2196 }
2197 }
2198
2199 //********************************************
2200 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
2201 {
2202 return false;
2203 }
2204
2205 //********************************************
2206 bool is_producer() const ETL_OVERRIDE
2207 {
2208 return true;
2209 }
2210
2211 //********************************************
2212 bool is_consumer() const ETL_OVERRIDE
2213 {
2214 return true;
2215 }
2216 };
2217
2218 //***************************************************************************
2219 // Specialisation for 4 message types.
2220 //***************************************************************************
2221 template <typename TDerived,
2222 typename T1, typename T2, typename T3, typename T4>
2223 class message_router<TDerived, T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void>
2224 : public imessage_router
2225 {
2226 public:
2227
2228 typedef etl::message_packet<T1, T2, T3, T4> message_packet;
2229
2230 //**********************************************
2231 message_router(etl::message_router_id_t id_)
2232 : imessage_router(id_)
2233 {
2234 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2235 }
2236
2237 //**********************************************
2238 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
2239 : imessage_router(id_, successor_)
2240 {
2241 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2242 }
2243
2244 //**********************************************
2245 message_router()
2246 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2247 {
2248 }
2249
2250 //**********************************************
2251 message_router(etl::imessage_router& successor_)
2252 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
2253 {
2254 }
2255
2256 //**********************************************
2257 using etl::imessage_router::receive;
2258
2259 void receive(const etl::imessage& msg) ETL_OVERRIDE
2260 {
2261 const size_t id = msg.get_message_id();
2262
2263 switch (id)
2264 {
2265 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
2266 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
2267 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
2268 case T4::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T4&>(msg)); break;
2269 default:
2270 {
2271 if (has_successor())
2272 {
2273 get_successor().receive(msg);
2274 }
2275 else
2276 {
2277 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2278 }
2279 break;
2280 }
2281 }
2282 }
2283
2284 template <typename TMessage>
2285 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3, T4>::value, void>::type
2286 receive(const TMessage& msg)
2287 {
2288 static_cast<TDerived*>(this)->on_receive(msg);
2289 }
2290
2291 template <typename TMessage>
2292 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3, T4>::value, void>::type
2293 receive(const TMessage& msg)
2294 {
2295 if (has_successor())
2296 {
2297 get_successor().receive(msg);
2298 }
2299 else
2300 {
2301 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2302 }
2303 }
2304
2305
2306 //**********************************************
2307 using imessage_router::accepts;
2308
2309 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
2310 {
2311 switch (id)
2312 {
2313 case T1::ID: case T2::ID: case T3::ID: case T4::ID:
2314 return true;
2315 default:
2316 {
2317 if (has_successor())
2318 {
2319 return get_successor().accepts(id);
2320 }
2321 else
2322 {
2323 return false;
2324 }
2325 }
2326 }
2327 }
2328
2329 //********************************************
2330 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
2331 {
2332 return false;
2333 }
2334
2335 //********************************************
2336 bool is_producer() const ETL_OVERRIDE
2337 {
2338 return true;
2339 }
2340
2341 //********************************************
2342 bool is_consumer() const ETL_OVERRIDE
2343 {
2344 return true;
2345 }
2346 };
2347
2348 //***************************************************************************
2349 // Specialisation for 3 message types.
2350 //***************************************************************************
2351 template <typename TDerived,
2352 typename T1, typename T2, typename T3>
2353 class message_router<TDerived, T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void>
2354 : public imessage_router
2355 {
2356 public:
2357
2358 typedef etl::message_packet<T1, T2, T3> message_packet;
2359
2360 //**********************************************
2361 message_router(etl::message_router_id_t id_)
2362 : imessage_router(id_)
2363 {
2364 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2365 }
2366
2367 //**********************************************
2368 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
2369 : imessage_router(id_, successor_)
2370 {
2371 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2372 }
2373
2374 //**********************************************
2375 message_router()
2376 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2377 {
2378 }
2379
2380 //**********************************************
2381 message_router(etl::imessage_router& successor_)
2382 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
2383 {
2384 }
2385
2386 //**********************************************
2387 using etl::imessage_router::receive;
2388
2389 void receive(const etl::imessage& msg) ETL_OVERRIDE
2390 {
2391 const size_t id = msg.get_message_id();
2392
2393 switch (id)
2394 {
2395 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
2396 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
2397 case T3::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T3&>(msg)); break;
2398 default:
2399 {
2400 if (has_successor())
2401 {
2402 get_successor().receive(msg);
2403 }
2404 else
2405 {
2406 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2407 }
2408 break;
2409 }
2410 }
2411 }
2412
2413 template <typename TMessage>
2414 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2, T3>::value, void>::type
2415 receive(const TMessage& msg)
2416 {
2417 static_cast<TDerived*>(this)->on_receive(msg);
2418 }
2419
2420 template <typename TMessage>
2421 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2, T3>::value, void>::type
2422 receive(const TMessage& msg)
2423 {
2424 if (has_successor())
2425 {
2426 get_successor().receive(msg);
2427 }
2428 else
2429 {
2430 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2431 }
2432 }
2433
2434
2435 //**********************************************
2436 using imessage_router::accepts;
2437
2438 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
2439 {
2440 switch (id)
2441 {
2442 case T1::ID: case T2::ID: case T3::ID:
2443 return true;
2444 default:
2445 {
2446 if (has_successor())
2447 {
2448 return get_successor().accepts(id);
2449 }
2450 else
2451 {
2452 return false;
2453 }
2454 }
2455 }
2456 }
2457
2458 //********************************************
2459 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
2460 {
2461 return false;
2462 }
2463
2464 //********************************************
2465 bool is_producer() const ETL_OVERRIDE
2466 {
2467 return true;
2468 }
2469
2470 //********************************************
2471 bool is_consumer() const ETL_OVERRIDE
2472 {
2473 return true;
2474 }
2475 };
2476
2477 //***************************************************************************
2478 // Specialisation for 2 message types.
2479 //***************************************************************************
2480 template <typename TDerived,
2481 typename T1, typename T2>
2482 class message_router<TDerived, T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
2483 : public imessage_router
2484 {
2485 public:
2486
2487 typedef etl::message_packet<T1, T2> message_packet;
2488
2489 //**********************************************
2490 message_router(etl::message_router_id_t id_)
2491 : imessage_router(id_)
2492 {
2493 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2494 }
2495
2496 //**********************************************
2497 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
2498 : imessage_router(id_, successor_)
2499 {
2500 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2501 }
2502
2503 //**********************************************
2504 message_router()
2505 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2506 {
2507 }
2508
2509 //**********************************************
2510 message_router(etl::imessage_router& successor_)
2511 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
2512 {
2513 }
2514
2515 //**********************************************
2516 using etl::imessage_router::receive;
2517
2518 void receive(const etl::imessage& msg) ETL_OVERRIDE
2519 {
2520 const size_t id = msg.get_message_id();
2521
2522 switch (id)
2523 {
2524 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
2525 case T2::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T2&>(msg)); break;
2526 default:
2527 {
2528 if (has_successor())
2529 {
2530 get_successor().receive(msg);
2531 }
2532 else
2533 {
2534 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2535 }
2536 break;
2537 }
2538 }
2539 }
2540
2541 template <typename TMessage>
2542 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1, T2>::value, void>::type
2543 receive(const TMessage& msg)
2544 {
2545 static_cast<TDerived*>(this)->on_receive(msg);
2546 }
2547
2548 template <typename TMessage>
2549 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1, T2>::value, void>::type
2550 receive(const TMessage& msg)
2551 {
2552 if (has_successor())
2553 {
2554 get_successor().receive(msg);
2555 }
2556 else
2557 {
2558 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2559 }
2560 }
2561
2562
2563 //**********************************************
2564 using imessage_router::accepts;
2565
2566 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
2567 {
2568 switch (id)
2569 {
2570 case T1::ID: case T2::ID:
2571 return true;
2572 default:
2573 {
2574 if (has_successor())
2575 {
2576 return get_successor().accepts(id);
2577 }
2578 else
2579 {
2580 return false;
2581 }
2582 }
2583 }
2584 }
2585
2586 //********************************************
2587 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
2588 {
2589 return false;
2590 }
2591
2592 //********************************************
2593 bool is_producer() const ETL_OVERRIDE
2594 {
2595 return true;
2596 }
2597
2598 //********************************************
2599 bool is_consumer() const ETL_OVERRIDE
2600 {
2601 return true;
2602 }
2603 };
2604
2605 //***************************************************************************
2606 // Specialisation for 1 message type.
2607 //***************************************************************************
2608 template <typename TDerived,
2609 typename T1>
2610 class message_router<TDerived, T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void>
2611 : public imessage_router
2612 {
2613 public:
2614
2615 typedef etl::message_packet< T1> message_packet;
2616
2617 //**********************************************
2618 message_router(etl::message_router_id_t id_)
2619 : imessage_router(id_)
2620 {
2621 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2622 }
2623
2624 //**********************************************
2625 message_router(etl::message_router_id_t id_, etl::imessage_router& successor_)
2626 : imessage_router(id_, successor_)
2627 {
2628 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2629 }
2630
2631 //**********************************************
2632 message_router()
2633 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2634 {
2635 }
2636
2637 //**********************************************
2638 message_router(etl::imessage_router& successor_)
2639 : imessage_router(etl::imessage_router::MESSAGE_ROUTER, successor_)
2640 {
2641 }
2642
2643 //**********************************************
2644 using etl::imessage_router::receive;
2645
2646 void receive(const etl::imessage& msg) ETL_OVERRIDE
2647 {
2648 const size_t id = msg.get_message_id();
2649
2650 switch (id)
2651 {
2652 case T1::ID: static_cast<TDerived*>(this)->on_receive(static_cast<const T1&>(msg)); break;
2653 default:
2654 {
2655 if (has_successor())
2656 {
2657 get_successor().receive(msg);
2658 }
2659 else
2660 {
2661 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2662 }
2663 break;
2664 }
2665 }
2666 }
2667
2668 template <typename TMessage>
2669 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && etl::is_one_of<TMessage, T1>::value, void>::type
2670 receive(const TMessage& msg)
2671 {
2672 static_cast<TDerived*>(this)->on_receive(msg);
2673 }
2674
2675 template <typename TMessage>
2676 typename etl::enable_if<etl::is_base_of<imessage, TMessage>::value && !etl::is_one_of<TMessage, T1>::value, void>::type
2677 receive(const TMessage& msg)
2678 {
2679 if (has_successor())
2680 {
2681 get_successor().receive(msg);
2682 }
2683 else
2684 {
2685 static_cast<TDerived*>(this)->on_receive_unknown(msg);
2686 }
2687 }
2688
2689
2690 //**********************************************
2691 using imessage_router::accepts;
2692
2693 bool accepts(etl::message_id_t id) const ETL_OVERRIDE
2694 {
2695 switch (id)
2696 {
2697 case T1::ID:
2698 return true;
2699 default:
2700 {
2701 if (has_successor())
2702 {
2703 return get_successor().accepts(id);
2704 }
2705 else
2706 {
2707 return false;
2708 }
2709 }
2710 }
2711 }
2712
2713 //********************************************
2714 ETL_DEPRECATED bool is_null_router() const ETL_OVERRIDE
2715 {
2716 return false;
2717 }
2718
2719 //********************************************
2720 bool is_producer() const ETL_OVERRIDE
2721 {
2722 return true;
2723 }
2724
2725 //********************************************
2726 bool is_consumer() const ETL_OVERRIDE
2727 {
2728 return true;
2729 }
2730 };
2731#endif
2732}
2733
2734#endif
etl::imessage_router
This is the base of all message routers.
Definition message_router_generator.h:121
etl::imessage
Definition message.h:73
etl::message_packet
Definition message_packet.h:393
etl::message_producer
This router can be used as a producer-only of messages, such an interrupt routine.
Definition message_router_generator.h:281
etl::message_router_exception
Base exception class for message router.
Definition message_router_generator.h:88
etl::message_router_illegal_id
Router id is out of the legal range.
Definition message_router_generator.h:101
etl::message_router
Definition message_router.h:558
etl::message
Definition message.h:91
etl::null_message_router
This router can be used as a sink for messages or a 'null source' router.
Definition message_router_generator.h:203
etl::shared_message::get_message
ETL_NODISCARD etl::imessage & get_message()
Get a reference to the contained message.
Definition shared_message.h:189
etl::successor< imessage_router >::has_successor
bool has_successor() const
Definition successor.h:184
etl::successor< imessage_router >::get_successor
successor_type & get_successor() const
Definition successor.h:174
etl::successor< imessage_router >::successor
successor()
Definition successor.h:81
error_handler.h
ETL_ASSERT
#define ETL_ASSERT(b, e)
Definition error_handler.h:356
etl::exception::exception
ETL_CONSTEXPR exception(string_type reason_, string_type, numeric_type line_)
Constructor.
Definition exception.h:69
etl::enable_if
enable_if
Definition type_traits_generator.h:1254
etl
bitset_ext
Definition absolute.h:39
etl::get_null_message_router
etl::imessage_router & get_null_message_router()
null message router functionality.
Definition message_router_generator.h:272
etl::message_id_t
uint_least8_t message_id_t
Allow alternative type for message id.
Definition message_types.h:40
placement_new.h
shared_message.h
etl::is_message_router
Is T ultimately derived from etl::imessage_router?
Definition message_router_generator.h:360
etl::type
type_traits.h