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// python -m cogapp -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// python -m cogapp -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
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 //***********************************************
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>
349 };
350
351 //***************************************************************************
353 //***************************************************************************
354 template <typename TRouter, typename TMessage>
355 static
357 send_message(TRouter& destination,
358 const TMessage& message)
359 {
360 destination.receive(message);
361 }
362
363 //***************************************************************************
365 //***************************************************************************
366 template <typename TRouter>
367 static
369 send_message(TRouter& destination,
370 etl::shared_message message)
371 {
372 destination.receive(message);
373 }
375 //***************************************************************************
377 //***************************************************************************
378 template <typename TRouter, typename TMessage>
379 static
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
394 send_message(TRouter& destination,
395 etl::message_router_id_t id,
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>
558 {
559 public:
560
562
563 //**********************************************
566 {
567 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
568 }
569
570 //**********************************************
573 {
574 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
575 }
576
577 //**********************************************
579 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
580 {
581 }
582
583 //**********************************************
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>
631 receive(const TMessage& msg)
632 {
633 static_cast<TDerived*>(this)->on_receive(msg);
634 }
635
636 template <typename TMessage>
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>
702 : public imessage_router
703 {
704 public:
705
707
708 //**********************************************
711 {
712 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
713 }
714
715 //**********************************************
718 {
719 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
720 }
721
722 //**********************************************
724 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
725 {
726 }
727
728 //**********************************************
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>
775 receive(const TMessage& msg)
776 {
777 static_cast<TDerived*>(this)->on_receive(msg);
778 }
779
780 template <typename TMessage>
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>
847 : public imessage_router
848 {
849 public:
850
852
853 //**********************************************
856 {
857 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
858 }
859
860 //**********************************************
863 {
864 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
865 }
866
867 //**********************************************
869 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
870 {
871 }
872
873 //**********************************************
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>
919 receive(const TMessage& msg)
920 {
921 static_cast<TDerived*>(this)->on_receive(msg);
922 }
923
924 template <typename TMessage>
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>
991 : public imessage_router
992 {
993 public:
994
996
997 //**********************************************
1000 {
1001 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1002 }
1003
1004 //**********************************************
1007 {
1008 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1009 }
1010
1011 //**********************************************
1013 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1014 {
1015 }
1016
1017 //**********************************************
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>
1062 receive(const TMessage& msg)
1063 {
1064 static_cast<TDerived*>(this)->on_receive(msg);
1065 }
1066
1067 template <typename TMessage>
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>
1133 : public imessage_router
1134 {
1135 public:
1136
1138
1139 //**********************************************
1142 {
1143 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1144 }
1145
1146 //**********************************************
1149 {
1150 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1151 }
1152
1153 //**********************************************
1155 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1156 {
1157 }
1158
1159 //**********************************************
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>
1203 receive(const TMessage& msg)
1204 {
1205 static_cast<TDerived*>(this)->on_receive(msg);
1206 }
1207
1208 template <typename TMessage>
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>
1274 : public imessage_router
1275 {
1276 public:
1277
1279
1280 //**********************************************
1283 {
1284 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1285 }
1286
1287 //**********************************************
1290 {
1291 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1292 }
1293
1294 //**********************************************
1296 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1297 {
1298 }
1299
1300 //**********************************************
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>
1343 receive(const TMessage& msg)
1344 {
1345 static_cast<TDerived*>(this)->on_receive(msg);
1346 }
1347
1348 template <typename TMessage>
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>
1414 : public imessage_router
1415 {
1416 public:
1417
1419
1420 //**********************************************
1423 {
1424 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1425 }
1426
1427 //**********************************************
1430 {
1431 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1432 }
1433
1434 //**********************************************
1436 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1437 {
1438 }
1439
1440 //**********************************************
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>
1482 receive(const TMessage& msg)
1483 {
1484 static_cast<TDerived*>(this)->on_receive(msg);
1485 }
1486
1487 template <typename TMessage>
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>
1553 : public imessage_router
1554 {
1555 public:
1556
1558
1559 //**********************************************
1562 {
1563 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1564 }
1565
1566 //**********************************************
1569 {
1570 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1571 }
1572
1573 //**********************************************
1575 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1576 {
1577 }
1578
1579 //**********************************************
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>
1620 receive(const TMessage& msg)
1621 {
1622 static_cast<TDerived*>(this)->on_receive(msg);
1623 }
1624
1625 template <typename TMessage>
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>
1690 : public imessage_router
1691 {
1692 public:
1693
1695
1696 //**********************************************
1699 {
1700 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1701 }
1702
1703 //**********************************************
1706 {
1707 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1708 }
1709
1710 //**********************************************
1712 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1713 {
1714 }
1715
1716 //**********************************************
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>
1756 receive(const TMessage& msg)
1757 {
1758 static_cast<TDerived*>(this)->on_receive(msg);
1759 }
1760
1761 template <typename TMessage>
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>
1826 : public imessage_router
1827 {
1828 public:
1829
1831
1832 //**********************************************
1835 {
1836 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1837 }
1838
1839 //**********************************************
1842 {
1843 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1844 }
1845
1846 //**********************************************
1848 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1849 {
1850 }
1851
1852 //**********************************************
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>
1891 receive(const TMessage& msg)
1892 {
1893 static_cast<TDerived*>(this)->on_receive(msg);
1894 }
1895
1896 template <typename TMessage>
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>
1960 : public imessage_router
1961 {
1962 public:
1963
1965
1966 //**********************************************
1969 {
1970 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1971 }
1972
1973 //**********************************************
1976 {
1977 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
1978 }
1979
1980 //**********************************************
1982 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
1983 {
1984 }
1985
1986 //**********************************************
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>
2024 receive(const TMessage& msg)
2025 {
2026 static_cast<TDerived*>(this)->on_receive(msg);
2027 }
2028
2029 template <typename TMessage>
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>
2093 : public imessage_router
2094 {
2095 public:
2096
2098
2099 //**********************************************
2102 {
2103 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2104 }
2105
2106 //**********************************************
2109 {
2110 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2111 }
2112
2113 //**********************************************
2115 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2116 {
2117 }
2118
2119 //**********************************************
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>
2156 receive(const TMessage& msg)
2157 {
2158 static_cast<TDerived*>(this)->on_receive(msg);
2159 }
2160
2161 template <typename TMessage>
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>
2224 : public imessage_router
2225 {
2226 public:
2227
2229
2230 //**********************************************
2233 {
2234 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2235 }
2236
2237 //**********************************************
2240 {
2241 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2242 }
2243
2244 //**********************************************
2246 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2247 {
2248 }
2249
2250 //**********************************************
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>
2286 receive(const TMessage& msg)
2287 {
2288 static_cast<TDerived*>(this)->on_receive(msg);
2289 }
2290
2291 template <typename TMessage>
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>
2354 : public imessage_router
2355 {
2356 public:
2357
2359
2360 //**********************************************
2363 {
2364 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2365 }
2366
2367 //**********************************************
2370 {
2371 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2372 }
2373
2374 //**********************************************
2376 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2377 {
2378 }
2379
2380 //**********************************************
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>
2415 receive(const TMessage& msg)
2416 {
2417 static_cast<TDerived*>(this)->on_receive(msg);
2418 }
2419
2420 template <typename TMessage>
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>
2483 : public imessage_router
2484 {
2485 public:
2486
2488
2489 //**********************************************
2492 {
2493 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2494 }
2495
2496 //**********************************************
2499 {
2500 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2501 }
2502
2503 //**********************************************
2505 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2506 {
2507 }
2508
2509 //**********************************************
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>
2543 receive(const TMessage& msg)
2544 {
2545 static_cast<TDerived*>(this)->on_receive(msg);
2546 }
2547
2548 template <typename TMessage>
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>
2611 : public imessage_router
2612 {
2613 public:
2614
2616
2617 //**********************************************
2620 {
2621 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2622 }
2623
2624 //**********************************************
2627 {
2628 ETL_ASSERT(id_ <= etl::imessage_router::MAX_MESSAGE_ROUTER, ETL_ERROR(etl::message_router_illegal_id));
2629 }
2630
2631 //**********************************************
2633 : imessage_router(etl::imessage_router::MESSAGE_ROUTER)
2634 {
2635 }
2636
2637 //**********************************************
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>
2670 receive(const TMessage& msg)
2671 {
2672 static_cast<TDerived*>(this)->on_receive(msg);
2673 }
2674
2675 template <typename TMessage>
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
This is the base of all message routers.
Definition message_router_generator.h:121
Definition message.h:73
Definition message_packet.h:393
Base exception class for message router.
Definition message_router_generator.h:88
Router id is out of the legal range.
Definition message_router_generator.h:101
Definition message_router.h:558
Definition message.h:91
Definition shared_message.h:49
ETL_NODISCARD etl::imessage & get_message()
Get a reference to the contained message.
Definition shared_message.h:189
Adds successor traits to a class.
Definition successor.h:73
bool has_successor() const
Does this have a successor?
Definition successor.h:184
successor_type & get_successor() const
Definition successor.h:174
successor()
Default constructor.
Definition successor.h:81
#define ETL_ASSERT(b, e)
Definition error_handler.h:356
ETL_CONSTEXPR exception(string_type reason_, string_type, numeric_type line_)
Constructor.
Definition exception.h:69
Definition exception.h:47
bitset_ext
Definition absolute.h:38
etl::imessage_router & get_null_message_router()
null message router functionality.
Definition message_router_generator.h:272
uint_least8_t message_id_t
Allow alternative type for message id.
Definition message_types.h:40
Definition type_traits_generator.h:844
Is T ultimately derived from etl::imessage?
Definition message.h:208
pair holds two objects of arbitrary type
Definition utility.h:164