yasmine
guard_caller.hpp
Go to the documentation of this file.
1 // //
3 // This file is part of the Seadex yasmine ecosystem (http://yasmine.seadex.de). //
4 // Copyright (C) 2016-2017 Seadex GmbH //
5 // //
6 // Licensing information is available in the folder "license" which is part of this distribution. //
7 // The same information is available on the www @ http://yasmine.seadex.de/Licenses.html. //
8 // //
10 
11 
12 #ifndef GUARD_CALLER_739F1B72_B584_4F9E_AD3B_56149B96F7BE
13 #define GUARD_CALLER_739F1B72_B584_4F9E_AD3B_56149B96F7BE
14 
15 
16 #include "essentials/base.hpp"
17 #include "essentials/exception.hpp"
18 
19 #include "event.hpp"
20 #include "adapter.hpp"
21 #include "event_adjuster.hpp"
22 #include "event_collector.hpp"
23 
24 
25 namespace sxy
26 {
27 
28 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
29  const sxe::function<bool()>& _function );
30 
31 
32 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
33  const sxe::function<bool( sxy::event_collector& _event_collector )>& _function );
34 
35 
36 template< typename _event_type >
37 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
38  const sxe::function<bool( const _event_type& )>& _function )
39 {
40  SX_UNUSED_PARAMETER( _event_collector );
41  bool enabled = false;
42 
43 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
44 
45 
46  const _event_type* specialized_event = dynamic_cast< const _event_type* >( &_event );
47  if( specialized_event )
48  {
49  enabled = _function( *specialized_event );
50  }
51  else
52  {
53  throw sxe::exception( "Invalid event type!" );
54  }
55 
56 
57 #else
58 
59 
60  auto& specialized_event = sxy::adjust_event_type< _event_type >( _event );
61  enabled = _function( specialized_event );
62 
63 
64 
65 #endif
66 
67  return( enabled );
68 }
69 
70 
71 template< typename _event_type >
72 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
73  const sxe::function<bool( const _event_type&, sxy::event_collector& _event_collector )>& _function )
74 {
75  bool enabled = false;
76 
77 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
78 
79 
80  const _event_type* specialized_event = dynamic_cast< const _event_type* >( &_event );
81  if( specialized_event )
82  {
83  enabled = _function( *specialized_event, _event_collector );
84  }
85  else
86  {
87  throw sxe::exception( "Invalid event type!" );
88  }
89 
90 
91 #else
92 
93 
94  auto& specialized_event = sxy::adjust_event_type< _event_type >( _event );
95  enabled = _function( specialized_event, _event_collector );
96 
97 
98 
99 #endif
100 
101  return( enabled );
102 }
103 
104 
105 template< typename _event_type1, typename _event_type2 >
106 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
107  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
108  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2 )
109 {
110  bool enabled = false;
111 
112 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
113 
114 
115  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
116  if( specialized_event )
117  {
118  enabled = _function1( *specialized_event, _event_collector );
119  }
120  else
121  {
122  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
123  if( specialized_event2 )
124  {
125  enabled = _function2( *specialized_event2, _event_collector );
126  }
127  else
128  {
129  throw sxe::exception( "Invalid event type!" );
130  }
131  }
132 
133 
134 #else
135 
136 
137  switch( _event.get_id() )
138  {
139  case _event_type1::get_event_id():
140  {
141  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
142  enabled = _function1( specialized_event, _event_collector );
143  break;
144  }
145 
146  case _event_type2::get_event_id():
147  {
148  const auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
149  enabled = _function2( specialized_event, _event_collector );
150  break;
151  }
152 
153  default:
154  SX_ASSERT( false, "Invalid event type!" );
155  }
156 
157 
158 #endif
159 
160  return( enabled );
161 }
162 
163 
164 template< typename _event_type1, typename _event_type2, typename _event_type3 >
165 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
166  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
167  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
168  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3 )
169 {
170  bool enabled = false;
171 
172 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
173 
174 
175  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
176  if( specialized_event )
177  {
178  enabled = _function1( *specialized_event, _event_collector );
179  }
180  else
181  {
182  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
183  if( specialized_event2 )
184  {
185  enabled = _function2( *specialized_event2, _event_collector );
186  }
187  else
188  {
189  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
190  if( specialized_event3 )
191  {
192  enabled = _function3( *specialized_event3, _event_collector );
193  }
194  else
195  {
196  throw sxe::exception( "Invalid event type!" );
197  }
198  }
199  }
200 
201 
202 #else
203 
204 
205  switch( _event.get_id() )
206  {
207  case _event_type1::get_event_id():
208  {
209  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
210  enabled = _function1( specialized_event, _event_collector );
211  break;
212  }
213 
214  case _event_type2::get_event_id():
215  {
216  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
217  enabled = _function2( specialized_event, _event_collector );
218  break;
219  }
220 
221  case _event_type3::get_event_id():
222  {
223  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
224  enabled = _function3( specialized_event, _event_collector );
225  break;
226  }
227 
228  default:
229  SX_ASSERT( false, "Invalid event type!" );
230  }
231 
232 
233 #endif
234 
235  return( enabled );
236 }
237 
238 
239 template< typename _event_type1, typename _event_type2, typename _event_type3, typename _event_type4 >
240 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
241  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
242  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
243  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3,
244  const sxe::function<bool( const _event_type4&, sxy::event_collector& )>& _function4 )
245 {
246  bool enabled = false;
247 
248 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
249 
250 
251  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
252  if( specialized_event )
253  {
254  enabled = _function1( *specialized_event, _event_collector );
255  }
256  else
257  {
258  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
259  if( specialized_event2 )
260  {
261  enabled = _function2( *specialized_event2, _event_collector );
262  }
263  else
264  {
265  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
266  if( specialized_event3 )
267  {
268  enabled = _function3( *specialized_event3, _event_collector );
269  }
270  else
271  {
272  const _event_type4* specialized_event4 = dynamic_cast< const _event_type4* >( &_event );
273  if( specialized_event4 )
274  {
275  enabled = _function4( *specialized_event4, _event_collector );
276  }
277  else
278  {
279  throw sxe::exception( "Invalid event type!" );
280  }
281  }
282  }
283  }
284 
285 
286 #else
287 
288 
289  switch( _event.get_id() )
290  {
291  case _event_type1::get_event_id():
292  {
293  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
294  enabled = _function1( specialized_event, _event_collector );
295  break;
296  }
297 
298  case _event_type2::get_event_id():
299  {
300  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
301  enabled = _function2( specialized_event, _event_collector );
302  break;
303  }
304 
305  case _event_type3::get_event_id():
306  {
307  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
308  enabled = _function3( specialized_event, _event_collector );
309  break;
310  }
311 
312  case _event_type4::get_event_id():
313  {
314  auto& specialized_event = sxy::adjust_event_type< _event_type4 >( _event );
315  enabled = _function4( specialized_event, _event_collector );
316  break;
317  }
318 
319  default:
320  SX_ASSERT( false, "Invalid event type!" );
321  }
322 
323 
324 #endif
325 
326  return( enabled );
327 }
328 
329 
330 template< typename _event_type1, typename _event_type2, typename _event_type3, typename _event_type4,
331  typename _event_type5 >
332 bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
333  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
334  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
335  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3,
336  const sxe::function<bool( const _event_type4&, sxy::event_collector& )>& _function4,
337  const sxe::function<bool( const _event_type5&, sxy::event_collector& )>& _function5 )
338 {
339  bool enabled = false;
340 
341 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
342 
343 
344  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
345  if( specialized_event )
346  {
347  enabled = _function1( *specialized_event, _event_collector );
348  }
349  else
350  {
351  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
352  if( specialized_event2 )
353  {
354  enabled = _function2( *specialized_event2, _event_collector );
355  }
356  else
357  {
358  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
359  if( specialized_event3 )
360  {
361  enabled = _function3( *specialized_event3, _event_collector );
362  }
363  else
364  {
365  const _event_type4* specialized_event4 = dynamic_cast< const _event_type4* >( &_event );
366  if( specialized_event4 )
367  {
368  enabled = _function4( *specialized_event4, _event_collector );
369  }
370  else
371  {
372  const _event_type5* specialized_event5 = dynamic_cast< const _event_type5* >( &_event );
373  if( specialized_event5 )
374  {
375  enabled = _function5( *specialized_event5, _event_collector );
376  }
377  else
378  {
379  throw sxe::exception( "Invalid event type!" );
380  }
381  }
382  }
383  }
384  }
385 
386 
387 #else
388 
389 
390  switch( _event.get_id() )
391  {
392  case _event_type1::get_event_id():
393  {
394  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
395  enabled = _function1( specialized_event, _event_collector );
396  break;
397  }
398 
399  case _event_type2::get_event_id():
400  {
401  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
402  enabled = _function2( specialized_event, _event_collector );
403  break;
404  }
405 
406  case _event_type3::get_event_id():
407  {
408  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
409  enabled = _function3( specialized_event, _event_collector );
410  break;
411  }
412 
413  case _event_type4::get_event_id():
414  {
415  auto& specialized_event = sxy::adjust_event_type< _event_type4 >( _event );
416  enabled = _function4( specialized_event, _event_collector );
417  break;
418  }
419 
420  case _event_type5::get_event_id():
421  {
422  auto& specialized_event = sxy::adjust_event_type< _event_type5 >( _event );
423  enabled = _function5( specialized_event, _event_collector );
424  break;
425  }
426 
427  default:
428  SX_ASSERT( false, "Invalid event type!" );
429  }
430 
431 
432 #endif
433 
434  return( enabled );
435 }
436 
437 
438 template< typename _event_type1, typename _event_type2, typename _event_type3, typename _event_type4,
439  typename _event_type5, typename _event_type6 >
440  bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
441  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
442  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
443  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3,
444  const sxe::function<bool( const _event_type4&, sxy::event_collector& )>& _function4,
445  const sxe::function<bool( const _event_type5&, sxy::event_collector& )>& _function5,
446  const sxe::function<bool( const _event_type6&, sxy::event_collector& )>& _function6 )
447 {
448  bool enabled = false;
449 
450 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
451 
452 
453  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
454  if( specialized_event )
455  {
456  enabled = _function1( *specialized_event, _event_collector );
457  }
458  else
459  {
460  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
461  if( specialized_event2 )
462  {
463  enabled = _function2( *specialized_event2, _event_collector );
464  }
465  else
466  {
467  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
468  if( specialized_event3 )
469  {
470  enabled = _function3( *specialized_event3, _event_collector );
471  }
472  else
473  {
474  const _event_type4* specialized_event4 = dynamic_cast< const _event_type4* >( &_event );
475  if( specialized_event4 )
476  {
477  enabled = _function4( *specialized_event4, _event_collector );
478  }
479  else
480  {
481  const _event_type5* specialized_event5 = dynamic_cast< const _event_type5* >( &_event );
482  if( specialized_event5 )
483  {
484  enabled = _function5( *specialized_event5, _event_collector );
485  }
486  else
487  {
488  const _event_type6* specialized_event6 = dynamic_cast< const _event_type6* >( &_event );
489  if( specialized_event6 )
490  {
491  enabled = _function6( *specialized_event6, _event_collector );
492  }
493  else
494  {
495  throw sxe::exception( "Invalid event type!" );
496  }
497  }
498  }
499  }
500  }
501  }
502 
503 
504 #else
505 
506 
507  switch( _event.get_id() )
508  {
509  case _event_type1::get_event_id():
510  {
511  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
512  enabled = _function1( specialized_event, _event_collector );
513  break;
514  }
515 
516  case _event_type2::get_event_id():
517  {
518  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
519  enabled = _function2( specialized_event, _event_collector );
520  break;
521  }
522 
523  case _event_type3::get_event_id():
524  {
525  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
526  enabled = _function3( specialized_event, _event_collector );
527  break;
528  }
529 
530  case _event_type4::get_event_id():
531  {
532  auto& specialized_event = sxy::adjust_event_type< _event_type4 >( _event );
533  enabled = _function4( specialized_event, _event_collector );
534  break;
535  }
536 
537  case _event_type5::get_event_id():
538  {
539  auto& specialized_event = sxy::adjust_event_type< _event_type5 >( _event );
540  enabled = _function5( specialized_event, _event_collector );
541  break;
542  }
543 
544  case _event_type6::get_event_id():
545  {
546  auto& specialized_event = sxy::adjust_event_type< _event_type6 >( _event );
547  enabled = _function6( specialized_event, _event_collector );
548  break;
549  }
550 
551  default:
552  SX_ASSERT( false, "Invalid event type!" );
553  }
554 
555 
556 #endif
557 
558  return( enabled );
559 }
560 
561 
562 template< typename _event_type1, typename _event_type2, typename _event_type3, typename _event_type4,
563  typename _event_type5, typename _event_type6, typename _event_type7 >
564  bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
565  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
566  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
567  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3,
568  const sxe::function<bool( const _event_type4&, sxy::event_collector& )>& _function4,
569  const sxe::function<bool( const _event_type5&, sxy::event_collector& )>& _function5,
570  const sxe::function<bool( const _event_type6&, sxy::event_collector& )>& _function6,
571  const sxe::function<bool( const _event_type7&, sxy::event_collector& )>& _function7 )
572 {
573  bool enabled = false;
574 
575 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
576 
577 
578  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
579  if( specialized_event )
580  {
581  enabled = _function1( *specialized_event, _event_collector );
582  }
583  else
584  {
585  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
586  if( specialized_event2 )
587  {
588  enabled = _function2( *specialized_event2, _event_collector );
589  }
590  else
591  {
592  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
593  if( specialized_event3 )
594  {
595  enabled = _function3( *specialized_event3, _event_collector );
596  }
597  else
598  {
599  const _event_type4* specialized_event4 = dynamic_cast< const _event_type4* >( &_event );
600  if( specialized_event4 )
601  {
602  enabled = _function4( *specialized_event4, _event_collector );
603  }
604  else
605  {
606  const _event_type5* specialized_event5 = dynamic_cast< const _event_type5* >( &_event );
607  if( specialized_event5 )
608  {
609  enabled = _function5( *specialized_event5, _event_collector );
610  }
611  else
612  {
613  const _event_type6* specialized_event6 = dynamic_cast< const _event_type6* >( &_event );
614  if( specialized_event6 )
615  {
616  enabled = _function6( *specialized_event6, _event_collector );
617  }
618  else
619  {
620  const _event_type7* specialized_event7 = dynamic_cast< const _event_type7* >( &_event );
621  if( specialized_event7 )
622  {
623  enabled = _function7( *specialized_event7, _event_collector );
624  }
625  else
626  {
627  throw sxe::exception( "Invalid event type!" );
628  }
629  }
630  }
631  }
632  }
633  }
634  }
635 
636 
637 #else
638 
639 
640  switch( _event.get_id() )
641  {
642  case _event_type1::get_event_id():
643  {
644  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
645  enabled = _function1( specialized_event, _event_collector );
646  break;
647  }
648 
649  case _event_type2::get_event_id():
650  {
651  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
652  enabled = _function2( specialized_event, _event_collector );
653  break;
654  }
655 
656  case _event_type3::get_event_id():
657  {
658  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
659  enabled = _function3( specialized_event, _event_collector );
660  break;
661  }
662 
663  case _event_type4::get_event_id():
664  {
665  auto& specialized_event = sxy::adjust_event_type< _event_type4 >( _event );
666  enabled = _function4( specialized_event, _event_collector );
667  break;
668  }
669 
670  case _event_type5::get_event_id():
671  {
672  auto& specialized_event = sxy::adjust_event_type< _event_type5 >( _event );
673  enabled = _function5( specialized_event, _event_collector );
674  break;
675  }
676 
677  case _event_type6::get_event_id():
678  {
679  auto& specialized_event = sxy::adjust_event_type< _event_type6 >( _event );
680  enabled = _function6( specialized_event, _event_collector );
681  break;
682  }
683 
684  case _event_type7::get_event_id():
685  {
686  auto& specialized_event = sxy::adjust_event_type< _event_type7 >( _event );
687  enabled = _function7( specialized_event, _event_collector );
688  break;
689  }
690 
691  default:
692  SX_ASSERT( false, "Invalid event type!" );
693  }
694 
695 
696 #endif
697 
698  return( enabled );
699 }
700 
701 
702 template< typename _event_type1, typename _event_type2, typename _event_type3, typename _event_type4,
703  typename _event_type5, typename _event_type6, typename _event_type7, typename _event_type8 >
704  bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
705  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
706  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
707  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3,
708  const sxe::function<bool( const _event_type4&, sxy::event_collector& )>& _function4,
709  const sxe::function<bool( const _event_type5&, sxy::event_collector& )>& _function5,
710  const sxe::function<bool( const _event_type6&, sxy::event_collector& )>& _function6,
711  const sxe::function<bool( const _event_type7&, sxy::event_collector& )>& _function7,
712  const sxe::function<bool( const _event_type8&, sxy::event_collector& )>& _function8 )
713 {
714  bool enabled = false;
715 
716 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
717 
718 
719  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
720  if( specialized_event )
721  {
722  enabled = _function1( *specialized_event, _event_collector );
723  }
724  else
725  {
726  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
727  if( specialized_event2 )
728  {
729  enabled = _function2( *specialized_event2, _event_collector );
730  }
731  else
732  {
733  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
734  if( specialized_event3 )
735  {
736  enabled = _function3( *specialized_event3, _event_collector );
737  }
738  else
739  {
740  const _event_type4* specialized_event4 = dynamic_cast< const _event_type4* >( &_event );
741  if( specialized_event4 )
742  {
743  enabled = _function4( *specialized_event4, _event_collector );
744  }
745  else
746  {
747  const _event_type5* specialized_event5 = dynamic_cast< const _event_type5* >( &_event );
748  if( specialized_event5 )
749  {
750  enabled = _function5( *specialized_event5, _event_collector );
751  }
752  else
753  {
754  const _event_type6* specialized_event6 = dynamic_cast< const _event_type6* >( &_event );
755  if( specialized_event6 )
756  {
757  enabled = _function6( *specialized_event6, _event_collector );
758  }
759  else
760  {
761  const _event_type7* specialized_event7 = dynamic_cast< const _event_type7* >( &_event );
762  if( specialized_event7 )
763  {
764  enabled = _function7( *specialized_event7, _event_collector );
765  }
766  else
767  {
768  const _event_type8* specialized_event8 = dynamic_cast< const _event_type8* >( &_event );
769  if( specialized_event8 )
770  {
771  enabled = _function8( *specialized_event8, _event_collector );
772  }
773  else
774  {
775  throw sxe::exception( "Invalid event type!" );
776  }
777  }
778  }
779  }
780  }
781  }
782  }
783  }
784 
785 
786 #else
787 
788 
789  switch( _event.get_id() )
790  {
791  case _event_type1::get_event_id():
792  {
793  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
794  enabled = _function1( specialized_event, _event_collector );
795  break;
796  }
797 
798  case _event_type2::get_event_id():
799  {
800  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
801  enabled = _function2( specialized_event, _event_collector );
802  break;
803  }
804 
805  case _event_type3::get_event_id():
806  {
807  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
808  enabled = _function3( specialized_event, _event_collector );
809  break;
810  }
811 
812  case _event_type4::get_event_id():
813  {
814  auto& specialized_event = sxy::adjust_event_type< _event_type4 >( _event );
815  enabled = _function4( specialized_event, _event_collector );
816  break;
817  }
818 
819  case _event_type5::get_event_id():
820  {
821  auto& specialized_event = sxy::adjust_event_type< _event_type5 >( _event );
822  enabled = _function5( specialized_event, _event_collector );
823  break;
824  }
825 
826  case _event_type6::get_event_id():
827  {
828  auto& specialized_event = sxy::adjust_event_type< _event_type6 >( _event );
829  enabled = _function6( specialized_event, _event_collector );
830  break;
831  }
832 
833  case _event_type7::get_event_id():
834  {
835  auto& specialized_event = sxy::adjust_event_type< _event_type7 >( _event );
836  enabled = _function7( specialized_event, _event_collector );
837  break;
838  }
839 
840  case _event_type8::get_event_id():
841  {
842  auto& specialized_event = sxy::adjust_event_type< _event_type8 >( _event );
843  enabled = _function8( specialized_event, _event_collector );
844  break;
845  }
846 
847  default:
848  SX_ASSERT( false, "Invalid event type!" );
849  }
850 
851 
852 #endif
853 
854  return( enabled );
855 }
856 
857 
858 template< typename _event_type1, typename _event_type2, typename _event_type3, typename _event_type4,
859  typename _event_type5, typename _event_type6, typename _event_type7, typename _event_type8, typename _event_type9 >
860  bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
861  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
862  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
863  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3,
864  const sxe::function<bool( const _event_type4&, sxy::event_collector& )>& _function4,
865  const sxe::function<bool( const _event_type5&, sxy::event_collector& )>& _function5,
866  const sxe::function<bool( const _event_type6&, sxy::event_collector& )>& _function6,
867  const sxe::function<bool( const _event_type7&, sxy::event_collector& )>& _function7,
868  const sxe::function<bool( const _event_type8&, sxy::event_collector& )>& _function8,
869  const sxe::function<bool( const _event_type9&, sxy::event_collector& )>& _function9 )
870 {
871  bool enabled = false;
872 
873 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
874 
875 
876  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
877  if( specialized_event )
878  {
879  enabled = _function1( *specialized_event, _event_collector );
880  }
881  else
882  {
883  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
884  if( specialized_event2 )
885  {
886  enabled = _function2( *specialized_event2, _event_collector );
887  }
888  else
889  {
890  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
891  if( specialized_event3 )
892  {
893  enabled = _function3( *specialized_event3, _event_collector );
894  }
895  else
896  {
897  const _event_type4* specialized_event4 = dynamic_cast< const _event_type4* >( &_event );
898  if( specialized_event4 )
899  {
900  enabled = _function4( *specialized_event4, _event_collector );
901  }
902  else
903  {
904  const _event_type5* specialized_event5 = dynamic_cast< const _event_type5* >( &_event );
905  if( specialized_event5 )
906  {
907  enabled = _function5( *specialized_event5, _event_collector );
908  }
909  else
910  {
911  const _event_type6* specialized_event6 = dynamic_cast< const _event_type6* >( &_event );
912  if( specialized_event6 )
913  {
914  enabled = _function6( *specialized_event6, _event_collector );
915  }
916  else
917  {
918  const _event_type7* specialized_event7 = dynamic_cast< const _event_type7* >( &_event );
919  if( specialized_event7 )
920  {
921  enabled = _function7( *specialized_event7, _event_collector );
922  }
923  else
924  {
925  const _event_type8* specialized_event8 = dynamic_cast< const _event_type8* >( &_event );
926  if( specialized_event8 )
927  {
928  enabled = _function8( *specialized_event8, _event_collector );
929  }
930  else
931  {
932  const _event_type9* specialized_event9 = dynamic_cast< const _event_type9* >( &_event );
933  if( specialized_event9 )
934  {
935  enabled = _function9( *specialized_event9, _event_collector );
936  }
937  else
938  {
939  throw sxe::exception( "Invalid event type!" );
940  }
941  }
942  }
943  }
944  }
945  }
946  }
947  }
948  }
949 
950 
951 #else
952 
953 
954  switch( _event.get_id() )
955  {
956  case _event_type1::get_event_id():
957  {
958  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
959  enabled = _function1( specialized_event, _event_collector );
960  break;
961  }
962 
963  case _event_type2::get_event_id():
964  {
965  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
966  enabled = _function2( specialized_event, _event_collector );
967  break;
968  }
969 
970  case _event_type3::get_event_id():
971  {
972  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
973  enabled = _function3( specialized_event, _event_collector );
974  break;
975  }
976 
977  case _event_type4::get_event_id():
978  {
979  auto& specialized_event = sxy::adjust_event_type< _event_type4 >( _event );
980  enabled = _function4( specialized_event, _event_collector );
981  break;
982  }
983 
984  case _event_type5::get_event_id():
985  {
986  auto& specialized_event = sxy::adjust_event_type< _event_type5 >( _event );
987  enabled = _function5( specialized_event, _event_collector );
988  break;
989  }
990 
991  case _event_type6::get_event_id():
992  {
993  auto& specialized_event = sxy::adjust_event_type< _event_type6 >( _event );
994  enabled = _function6( specialized_event, _event_collector );
995  break;
996  }
997 
998  case _event_type7::get_event_id():
999  {
1000  auto& specialized_event = sxy::adjust_event_type< _event_type7 >( _event );
1001  enabled = _function7( specialized_event, _event_collector );
1002  break;
1003  }
1004 
1005  case _event_type8::get_event_id():
1006  {
1007  auto& specialized_event = sxy::adjust_event_type< _event_type8 >( _event );
1008  enabled = _function8( specialized_event, _event_collector );
1009  break;
1010  }
1011 
1012  case _event_type9::get_event_id():
1013  {
1014  auto& specialized_event = sxy::adjust_event_type< _event_type9 >( _event );
1015  enabled = _function9( specialized_event, _event_collector );
1016  break;
1017  }
1018 
1019  default:
1020  SX_ASSERT( false, "Invalid event type!" );
1021  }
1022 
1023 
1024 #endif
1025 
1026  return( enabled );
1027 }
1028 
1029 
1030 template< typename _event_type1, typename _event_type2, typename _event_type3, typename _event_type4,
1031  typename _event_type5, typename _event_type6, typename _event_type7, typename _event_type8, typename _event_type9,
1032  typename _event_type10 >
1033  bool guard_caller( const sxy::event& _event, sxy::event_collector& _event_collector,
1034  const sxe::function<bool( const _event_type1&, sxy::event_collector& )>& _function1,
1035  const sxe::function<bool( const _event_type2&, sxy::event_collector& )>& _function2,
1036  const sxe::function<bool( const _event_type3&, sxy::event_collector& )>& _function3,
1037  const sxe::function<bool( const _event_type4&, sxy::event_collector& )>& _function4,
1038  const sxe::function<bool( const _event_type5&, sxy::event_collector& )>& _function5,
1039  const sxe::function<bool( const _event_type6&, sxy::event_collector& )>& _function6,
1040  const sxe::function<bool( const _event_type7&, sxy::event_collector& )>& _function7,
1041  const sxe::function<bool( const _event_type8&, sxy::event_collector& )>& _function8,
1042  const sxe::function<bool( const _event_type9&, sxy::event_collector& )>& _function9,
1043  const sxe::function<bool( const _event_type10&, sxy::event_collector& )>& _function10 )
1044 {
1045  bool enabled = false;
1046 
1047 #if defined( SX_CPP03_BOOST ) || ( defined(_MSC_VER) && _MSC_VER <=1800 )
1048 
1049 
1050  const _event_type1* specialized_event = dynamic_cast< const _event_type1* >( &_event );
1051  if( specialized_event )
1052  {
1053  enabled = _function1( *specialized_event, _event_collector );
1054  }
1055  else
1056  {
1057  const _event_type2* specialized_event2 = dynamic_cast< const _event_type2* >( &_event );
1058  if( specialized_event2 )
1059  {
1060  enabled = _function2( *specialized_event2, _event_collector );
1061  }
1062  else
1063  {
1064  const _event_type3* specialized_event3 = dynamic_cast< const _event_type3* >( &_event );
1065  if( specialized_event3 )
1066  {
1067  enabled = _function3( *specialized_event3, _event_collector );
1068  }
1069  else
1070  {
1071  const _event_type4* specialized_event4 = dynamic_cast< const _event_type4* >( &_event );
1072  if( specialized_event4 )
1073  {
1074  enabled = _function4( *specialized_event4, _event_collector );
1075  }
1076  else
1077  {
1078  const _event_type5* specialized_event5 = dynamic_cast< const _event_type5* >( &_event );
1079  if( specialized_event5 )
1080  {
1081  enabled = _function5( *specialized_event5, _event_collector );
1082  }
1083  else
1084  {
1085  const _event_type6* specialized_event6 = dynamic_cast< const _event_type6* >( &_event );
1086  if( specialized_event6 )
1087  {
1088  enabled = _function6( *specialized_event6, _event_collector );
1089  }
1090  else
1091  {
1092  const _event_type7* specialized_event7 = dynamic_cast< const _event_type7* >( &_event );
1093  if( specialized_event7 )
1094  {
1095  enabled = _function7( *specialized_event7, _event_collector );
1096  }
1097  else
1098  {
1099  const _event_type8* specialized_event8 = dynamic_cast< const _event_type8* >( &_event );
1100  if( specialized_event8 )
1101  {
1102  enabled = _function8( *specialized_event8, _event_collector );
1103  }
1104  else
1105  {
1106  const _event_type9* specialized_event9 = dynamic_cast< const _event_type9* >( &_event );
1107  if( specialized_event9 )
1108  {
1109  enabled = _function9( *specialized_event9, _event_collector );
1110  }
1111  else
1112  {
1113  const _event_type10* specialized_event10 = dynamic_cast< const _event_type10* >( &_event );
1114  if( specialized_event10 )
1115  {
1116  enabled = _function10( *specialized_event10, _event_collector );
1117  }
1118  else
1119  {
1120  throw sxe::exception( "Invalid event type!" );
1121  }
1122  }
1123  }
1124  }
1125  }
1126  }
1127  }
1128  }
1129  }
1130  }
1131 
1132 
1133 #else
1134 
1135 
1136  switch( _event.get_id() )
1137  {
1138  case _event_type1::get_event_id():
1139  {
1140  auto& specialized_event = sxy::adjust_event_type< _event_type1 >( _event );
1141  enabled = _function1( specialized_event, _event_collector );
1142  break;
1143  }
1144 
1145  case _event_type2::get_event_id():
1146  {
1147  auto& specialized_event = sxy::adjust_event_type< _event_type2 >( _event );
1148  enabled = _function2( specialized_event, _event_collector );
1149  break;
1150  }
1151 
1152  case _event_type3::get_event_id():
1153  {
1154  auto& specialized_event = sxy::adjust_event_type< _event_type3 >( _event );
1155  enabled = _function3( specialized_event, _event_collector );
1156  break;
1157  }
1158 
1159  case _event_type4::get_event_id():
1160  {
1161  auto& specialized_event = sxy::adjust_event_type< _event_type4 >( _event );
1162  enabled = _function4( specialized_event, _event_collector );
1163  break;
1164  }
1165 
1166  case _event_type5::get_event_id():
1167  {
1168  auto& specialized_event = sxy::adjust_event_type< _event_type5 >( _event );
1169  enabled = _function5( specialized_event, _event_collector );
1170  break;
1171  }
1172 
1173  case _event_type6::get_event_id():
1174  {
1175  auto& specialized_event = sxy::adjust_event_type< _event_type6 >( _event );
1176  enabled = _function6( specialized_event, _event_collector );
1177  break;
1178  }
1179 
1180  case _event_type7::get_event_id():
1181  {
1182  auto& specialized_event = sxy::adjust_event_type< _event_type7 >( _event );
1183  enabled = _function7( specialized_event, _event_collector );
1184  break;
1185  }
1186 
1187  case _event_type8::get_event_id():
1188  {
1189  auto& specialized_event = sxy::adjust_event_type< _event_type8 >( _event );
1190  enabled = _function8( specialized_event, _event_collector );
1191  break;
1192  }
1193 
1194  case _event_type9::get_event_id():
1195  {
1196  auto& specialized_event = sxy::adjust_event_type< _event_type9 >( _event );
1197  enabled = _function9( specialized_event, _event_collector );
1198  break;
1199  }
1200 
1201  case _event_type10::get_event_id():
1202  {
1203  auto& specialized_event = sxy::adjust_event_type< _event_type10 >( _event );
1204  enabled = _function10( specialized_event, _event_collector );
1205  break;
1206  }
1207 
1208  default:
1209  SX_ASSERT( false, "Invalid event type!" );
1210  }
1211 
1212 
1213 #endif
1214 
1215  return( enabled );
1216 }
1217 
1218 
1219 }
1220 
1221 #endif
sxy::event_collector
Definition: event_collector.hpp:25
sxy::event::get_id
virtual event_id get_id() const =0
Getter of event&#39;s ID.
sxy::event
Interface of an event. An event has an ID, a name and a priority (for processing by the async state m...
Definition: event.hpp:28
sxy
Definition: adapter_cpp11.hpp:21
event_adjuster.hpp
sxy::specialized_event
Class that inherits event_impl and provides a fixed event ID and priority as well as create methods f...
Definition: specialized_event.hpp:26
event_collector.hpp
sxy::guard_caller
bool guard_caller(const sxy::event &_event, sxy::event_collector &_event_collector, const sxe::function< bool()> &_function)
Definition: guard_caller.cpp:18