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