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