eventxx

   1 #ifndef _EVENTXX_HPP_
   2 #define _EVENTXX_HPP_
   3
   4 #include <sys/types.h> // timeval
   5 #include <stdexcept>   // std::exception, std::invalid_argument,
   6                        // std::runtime_error, std::bad_alloc
   7
   8 /**
   9  * Namespace for all symbols libevent C++ wrapper defines.
  10  */
  11 namespace eventxx
  12 {
  13
  14
  15 // All libevent C API symbols and other internal stuff goes here.
  16 namespace internal
  17 {
  18 #include <event.h>
  19 }
  20
  21
  22 /** @defgroup exceptions Exceptions
  23  *
  24  * eventxx makes a heavy use of exceptions. Each function has it's exceptions
  25  * specified, so it's very easy to find out what exceptions to expect.
  26  *
  27  * Exceptions are mostly thrown when there is a programming error. So if you get
  28  * an exception check your code.
  29  */
  30 //@{
  31
  32
  33 /**
  34  * Base class for all libevent exceptions.
  35  */
  36 struct exception: public std::exception
  37 {
  38 };
  39
  40
  41 /**
  42  * Invalid event exception.
  43  *
  44  * This exception is thrown when passing an invalid event to a function, the
  45  * reason is given in the what() description but it usually means that the you
  46  * are making some restricted operation with an active event.
  47  *
  48  * If you hit this exception, you probably got a programming error.
  49  */
  50 struct invalid_event: public std::invalid_argument, public exception
  51 {
  52
  53         /**
  54          * Creates an invalid event exception with a reason.
  55          *
  56          * @param what Reason why the event is invalid).
  57          */
  58         explicit invalid_event(const std::string& what) throw():
  59                 std::invalid_argument(what)
  60         {
  61         }
  62
  63 }; // struct invalid_event
  64
  65
  66 /**
  67  * Invalid priority exception.
  68  *
  69  * This exception is thrown when passing an invalid priority to a function. This
  70  * usually means you don't have enough priority queues in your dispatcher, so
  71  * you should have allocated more in the constructor.
  72  *
  73  * If you hit this exception, you probably got a programming error.
  74  *
  75  * @see dispatcher::dispatcher(int) to allocate more priority queues.
  76  */
  77 struct invalid_priority: public std::invalid_argument, public exception
  78 {
  79
  80         /**
  81          * Creates an invalid priority exception with a reason.
  82          *
  83          * @param what Reason why the priority is invalid).
  84          */
  85         explicit invalid_priority(const std::string& what
  86                         = "invalid priority value") throw():
  87                 std::invalid_argument(what)
  88         {
  89         }
  90
  91 }; // struct invalid_priority
  92
  93 //@}
  94
  95
  96 /// Miscellaneous constants
  97 enum
  98 {
  99         DEFAULT_PRIORITY = -1,      ///< Default priority (the middle value).
 100         ONCE = EVLOOP_ONCE,         ///< Loop just once.
 101         NONBLOCK = EVLOOP_NONBLOCK  ///< Don't block the event loop.
 102 };
 103
 104
 105 /**
 106  * Time used for timeout values.
 107  *
 108  * This timeout is compose of seconds and microseconds.
 109  */
 110 struct time: ::timeval
 111 {
 112
 113         /**
 114          * Creates a new time with @p sec seconds and @p usec microseconds.
 115          *
 116          * @param sec Number of seconds.
 117          * @param usec Number of microseconds.
 118          */
 119         time(long sec = 0l, long usec = 0l) throw()
 120                 { tv_sec = sec; tv_usec = usec; }
 121
 122         /**
 123          * Gets the number of seconds.
 124          *
 125          * @return Number of seconds.
 126          */
 127         long sec() const throw() { return tv_sec; };
 128
 129         /**
 130          * Gets the number of microseconds.
 131          *
 132          * @return Number of microseconds.
 133          */
 134         long usec() const throw() { return tv_usec; };
 135
 136         /**
 137          * Sets the number of seconds.
 138          *
 139          * @param s Number of seconds.
 140          */
 141         void sec(long s) throw() { tv_sec = s; };
 142
 143         /**
 144          * Sets the number of microseconds.
 145          *
 146          * @param u Number of microseconds.
 147          */
 148         void usec(long u) throw() { tv_usec = u; };
 149
 150 }; // struct time
 151
 152
 153 /** @defgroup events Events
 154  *
 155  * There are many ways to specify how to handle an event. You can use use the
 156  * same plain functions callbacks (see eventxx::cevent, eventxx::ctimer and
 157  * eventxx::csignal) like in C or the other kind of more advanced, stateful
 158  * function objects (see eventxx::event, eventxx::timer and eventxx::signal
 159  * templates). The former are just typedef'ed specialization of the later.
 160  *
 161  * A member function wrapper functor (eventxx::mem_cb) is also included,
 162  * so you can use any member function (method) as an event handler.
 163  *
 164  * Please note that C-like function callback take a short as the type of event,
 165  * while functors (or member functions) use eventxx::type.
 166  *
 167  * All events derive from a plain class (not template) eventxx::basic_event, one
 168  * of the main utilities of it (besides containing common code ;) is to be used
 169  * in STL containers.
 170  *
 171  * Please see each class documentation for details and examples.
 172  */
 173 //@{
 174
 175
 176 /// C function used as callback in the C API.
 177 typedef void (*ccallback_type)(int, short, void*);
 178
 179
 180 /**
 181  * Type of events.
 182  *
 183  * There are 4 kind of events: eventxx::TIMEOUT, eventxx::READ, eventxx::WRITE
 184  * or eventxx::SIGNAL. eventxx::PERSIST is not an event, is an event modifier
 185  * flag, that tells eventxx that this event should live until dispatcher::del()
 186  * is called. You can use, for example:
 187  * @code
 188  * eventxx::event(fd, eventxx::READ | eventxx::PERSIST, ...);
 189  * @endcode
 190  */
 191 enum type
 192 {
 193         TIMEOUT = EV_TIMEOUT, ///< Timeout event.
 194         READ = EV_READ,       ///< Read event.
 195         WRITE = EV_WRITE,     ///< Write event.
 196         SIGNAL = EV_SIGNAL,   ///< Signal event.
 197         PERSIST = EV_PERSIST  ///< Not really an event, is an event modifier.
 198 };
 199
 200 inline
 201 type operator| (const type& t1, const type& t2)
 202 {
 203         int r = static_cast< int >(t1) | static_cast< int >(t2);
 204         return static_cast< type >(r);
 205 }
 206
 207
 208 /**
 209  * Basic event from which all events derive.
 210  *
 211  * All events derive from this class, so it's useful for use in containers,
 212  * like:
 213  * @code
 214  * std::list< eventxx::basic_event* > events;
 215  * @endcode
 216  */
 217 struct basic_event: internal::event
 218 {
 219
 220         /**
 221          * Checks if there is an event pending.
 222          *
 223          * @param ev Type of event to check.
 224          *
 225          * @return true if there is a pending event, false if not.
 226          */
 227         bool pending(type ev) const throw()
 228         {
 229                 // HACK libevent don't use const
 230                 return event_pending(const_cast< basic_event* >(this), ev, 0);
 231         }
 232
 233         /**
 234          * Timeout of the event.
 235          *
 236          * @return Timeout of the event.
 237          */
 238         time timeout() const throw()
 239         {
 240                 time tv;
 241                 // HACK libevent don't use const
 242                 event_pending(const_cast< basic_event* >(this), EV_TIMEOUT, &tv);
 243                 return tv;
 244         }
 245
 246         /**
 247          * Sets the event's priority.
 248          *
 249          * @param priority New event priority.
 250          *
 251          * @pre The event must be added to some dispatcher.
 252          *
 253          * @see dispatcher::dispatcher(int)
 254          */
 255         void priority(int priority) const throw(invalid_event, invalid_priority)
 256         {
 257                 if (ev_flags & EVLIST_ACTIVE)
 258                         throw invalid_event("can't change the priority of an "
 259                                         "active event");
 260                 // HACK libevent don't use const
 261                 if (event_priority_set(const_cast< basic_event* >(this),
 262                                         priority))
 263                         throw invalid_priority();
 264         }
 265
 266         /**
 267          * Event's file descriptor.
 268          *
 269          * @return Event's file descriptor.
 270          */
 271         int fd() const throw()
 272         {
 273                 return EVENT_FD(this);
 274         }
 275
 276         /// @note This is an abstract class, you can't instantiate it.
 277         protected:
 278                 basic_event() throw() {}
 279                 basic_event(const basic_event&);
 280                 basic_event& operator= (const basic_event&);
 281
 282 }; // struct basic_event
 283
 284
 285 /**
 286  * Generic event object.
 287  *
 288  * This object stores all the information about an event, including a callback
 289  * functor, which is called when the event is fired. The template parameter
 290  * must be a functor (callable object or function) that can take 2 parameters:
 291  * an integer (the file descriptor of the fired event) and an event::type (the
 292  * type of event being fired).
 293  * There is a specialized version of this class which takes as the template
 294  * parameter a C function with the eventxx::ccallback_type signature, just like
 295  * C @libevent API does.
 296  *
 297  * @see eventxx::event< ccallback_type >
 298  */
 299 template < typename F >
 300 struct event: basic_event
 301 {
 302
 303         /**
 304          * Creates a new event.
 305          *
 306          * @param fd File descriptor to monitor for events.
 307          * @param ev Type of events to monitor (see eventxx::type).
 308          * @param handler Callback functor.
 309          */
 310         event(int fd, type ev, F& handler) throw()
 311         {
 312                 event_set(this, fd, static_cast< short >(ev), &wrapper,
 313                                 reinterpret_cast< void* >(&handler));
 314         }
 315
 316         protected:
 317                 event() {}
 318                 static void wrapper(int fd, short ev, void* h)
 319                 {
 320                         F& handler = *reinterpret_cast< F* >(h);
 321                         // Hackish, but this way the handler can get a clean
 322                         // event type
 323                         short* pev = &ev; // Avoid some weird warning about
 324                                           // dereferencing type-punned pointer
 325                                           // will break strict-aliasing rules
 326                         handler(fd, *reinterpret_cast< type* >(pev));
 327                 }
 328
 329 }; // struct event< F >
 330
 331
 332 /**
 333  * This is the specialization of eventxx::event for C-style callbacks.
 334  *
 335  * @see eventxx::event
 336  */
 337 template <>
 338 struct event< ccallback_type >: basic_event
 339 {
 340
 341         /**
 342          * Creates a new event.
 343          *
 344          * @param fd File descriptor to monitor for events.
 345          * @param ev Type of events to monitor (see eventxx::type).
 346          * @param handler C-style callback function.
 347          * @param arg Arbitrary pointer to pass to the handler as argument.
 348          */
 349         event(int fd, type ev, ccallback_type handler, void* arg = 0) throw()
 350         {
 351                 event_set(this, fd, static_cast< short >(ev), handler, arg);
 352         }
 353
 354         protected:
 355                 event() {}
 356
 357 }; // struct event< ccallback_type >
 358
 359
 360 /**
 361  * Timer event object.
 362  *
 363  * This is just a special case of event that is fired only when a timeout is
 364  * reached. It's just a shortcut to:
 365  * @code
 366  * event(-1, 0, handler);
 367  * @endcode
 368  *
 369  * @note This event can't eventxx::PERSIST.
 370  * @see timer< ccallback_type >
 371  */
 372 template < typename F >
 373 struct timer: event< F >
 374 {
 375
 376         /**
 377          * Creates a new timer event.
 378          *
 379          * @param handler Callback functor.
 380          */
 381         timer(F& handler) throw()
 382         {
 383                 evtimer_set(this, &event< F >::wrapper,
 384                         reinterpret_cast< void* >(&handler));
 385         }
 386
 387 }; // struct timer< F >
 388
 389
 390 /**
 391  * This is the specialization of eventxx::timer for C-style callbacks.
 392  *
 393  * @note This event can't eventxx::PERSIST.
 394  * @see timer
 395  */
 396 template <>
 397 struct timer< ccallback_type >: event< ccallback_type >
 398 {
 399
 400         /**
 401          * Creates a new timer event.
 402          *
 403          * @param handler C-style callback function.
 404          * @param arg Arbitrary pointer to pass to the handler as argument.
 405          */
 406         timer(ccallback_type handler, void* arg = 0) throw()
 407         {
 408                 evtimer_set(this, handler, arg);
 409         }
 410
 411 }; // struct timer< ccallback_type >
 412
 413
 414 /**
 415  * Signal event object.
 416  *
 417  * This is just a special case of event that is fired when a signal is raised
 418  * (instead of a file descriptor being active). It's just a shortcut to:
 419  * @code
 420  * event(signum, eventxx::SIGNAL, handler);
 421  * @endcode
 422  *
 423  * @note This event always eventxx::PERSIST.
 424  * @see signal< ccallback_type >
 425  */
 426 template < typename F >
 427 struct signal: event< F >
 428 {
 429
 430         /**
 431          * Creates a new signal event.
 432          *
 433          * @param signum Signal number to monitor.
 434          * @param handler Callback functor.
 435          */
 436         signal(int signum, F& handler) throw()
 437         {
 438                 signal_set(this, signum, &event< F >::wrapper,
 439                         reinterpret_cast< void* >(&handler));
 440         }
 441
 442         /**
 443          * Event's signal number.
 444          *
 445          * @return Event's signal number.
 446          */
 447         int signum() const
 448         {
 449                 return EVENT_SIGNAL(this);
 450         }
 451
 452 }; // struct signal<F>
 453
 454
 455 /**
 456  * This is the specialization of eventxx::signal for C-style callbacks.
 457  *
 458  * @note This event always eventxx::PERSIST.
 459  * @see signal
 460  */
 461 template <>
 462 struct signal< ccallback_type >: event< ccallback_type >
 463 {
 464
 465         /**
 466          * Creates a new signal event.
 467          *
 468          * @param signum Signal number to monitor.
 469          * @param handler C-style callback function.
 470          * @param arg Arbitrary pointer to pass to the handler as argument.
 471          */
 472         signal(int signum, ccallback_type handler, void* arg = 0) throw()
 473         {
 474                 signal_set(this, signum, handler, arg);
 475         }
 476
 477         /**
 478          * Event's signal number.
 479          *
 480          * @return Event's signal number.
 481          */
 482         int signum() const
 483         {
 484                 return EVENT_SIGNAL(this);
 485         }
 486
 487 }; // struct signal< ccallback_type >
 488
 489
 490 /// Shortcut to C-style event.
 491 typedef eventxx::event< ccallback_type > cevent;
 492
 493 /// Shortcut to C-style timer.
 494 typedef eventxx::timer< ccallback_type > ctimer;
 495
 496 /// Shortcut to C-style signal handler.
 497 typedef eventxx::signal< ccallback_type > csignal;
 498
 499 /**
 500  * Helper functor to use an arbitrary member function as an event handler.
 501  *
 502  * With this wrapper, you can use any object method, which accepts the right
 503  * parameters (int, short) and returns void, as an event handler. This way you
 504  * don't have to overload the operator() which can be confusing depending on the
 505  * context.
 506  *
 507  * You can see an usage example in the Examples Section.
 508  */
 509 template < typename O, typename M >
 510 struct mem_cb
 511 {
 512
 513         /**
 514          * Member function callback constructor.
 515          *
 516          * It expects to receive a class as the first parameter (O), and a
 517          * member function (of that class O) as the second parameter.
 518          *
 519          * When this instance is called with fd and ev as function arguments,
 520          * object.method(fd, ev) will be called.
 521          *
 522          * @param object Object to be used.
 523          * @param method Method to be called.
 524          */
 525         mem_cb(O& object, M method) throw():
 526                 _object(object), _method(method) {}
 527
 528         void operator() (int fd, type ev) { (_object.*_method)(fd, ev); }
 529         protected:
 530                 O& _object;
 531                 M _method;
 532
 533 }; // struct mem_cb
 534
 535 //@}
 536
 537
 538 /**
 539  * Event dispatcher.
 540  *
 541  * This class is the responsible for looping and dispatching events. Every time
 542  * you need an event loop you should create an instance of this class.
 543  *
 544  * You can @link dispatcher::add add @endlink events to the dispatcher, and you
 545  * can @link dispatcher::del remove @endlink them later or you can @link
 546  * dispatcher::add_once add events to be processed just once @endlink. You can
 547  * @link dispatcher::dispatch loop once or forever @endlink (well, of course you
 548  * can break that forever removing all the events or by @link dispatcher::exit
 549  * exiting the loop @endlink).
 550  */
 551 struct dispatcher
 552 {
 553
 554         /**
 555          * Creates a default dispatcher (with just 1 priority).
 556          *
 557          * @see dispatcher(int) if you want to create a dispatcher with more
 558          *      priorities.
 559          */
 560         dispatcher() throw()
 561         {
 562                 _event_base = static_cast< internal::event_base* >(
 563                                 internal::event_init());
 564         }
 565
 566         /**
 567          * Creates a dispatcher with npriorities priorities.
 568          *
 569          * @param npriorities Number of priority queues to use.
 570          */
 571         dispatcher(int npriorities) throw(std::bad_alloc)
 572         {
 573                 _event_base = static_cast< internal::event_base* >(
 574                                 internal::event_init());
 575                 if (!_event_base) throw std::bad_alloc();
 576                 // Can't fail because there is no way that it has active events
 577                 internal::event_base_priority_init(_event_base, npriorities);
 578         }
 579
 580 #ifndef EVENTXX_NO_EVENT_BASE_FREE
 581         /// Free dispatcher resources, see @ref Status section for details.
 582         ~dispatcher() throw() { event_base_free(_event_base); }
 583 #endif
 584
 585         /**
 586          * Adds an event to the dispatcher.
 587          *
 588          * @param e Event to add.
 589          * @param priority Priority of the event.
 590          */
 591         void add(basic_event& e, int priority = DEFAULT_PRIORITY)
 592                 throw(invalid_priority)
 593         {
 594                 internal::event_base_set(_event_base, &e);
 595                 if (priority != DEFAULT_PRIORITY
 596                                 && internal::event_priority_set(&e, priority))
 597                         throw invalid_priority();
 598                 internal::event_add(&e, 0);
 599         }
 600
 601         /**
 602          * Adds an event to the dispatcher with a timeout.
 603          *
 604          * The event is fired when there is activity on e or when to has elapsed,
 605          * whatever come first.
 606          *
 607          * @param e Event to add.
 608          * @param to Timeout.
 609          * @param priority Priority of the event.
 610          */
 611         void add(basic_event& e, const time& to,
 612                         int priority = DEFAULT_PRIORITY)
 613                 throw(invalid_priority)
 614         {
 615                 internal::event_base_set(_event_base, &e);
 616                 if (priority != DEFAULT_PRIORITY
 617                                 && internal::event_priority_set(&e, priority))
 618                         throw invalid_priority();
 619                 // XXX HACK libevent don't use const
 620                 internal::event_add(&e, const_cast< time* >(&to));
 621         }
 622
 623         /**
 624          * Adds a temporary event.
 625          *
 626          * Adds a temporary event, without the need of instantiating a new event
 627          * object. Events added this way can't eventxx::PERSIST.
 628          *
 629          * @param fd File descriptor to monitor for events.
 630          * @param ev Type of events to monitor.
 631          * @param handler Callback function.
 632          */
 633         template < typename F >
 634         void add_once(int fd, type ev, F& handler)
 635         {
 636                 internal::event_once(fd, static_cast< short>(ev),
 637                         &dispatcher::wrapper< F >,
 638                         reinterpret_cast< void* >(&handler), 0);
 639         }
 640
 641         /**
 642          * Adds a temporary event to with a C-style callback.
 643          *
 644          * Adds a temporary event, without the need of instantiating a new event
 645          * object. Events added this way can't eventxx::PERSIST.
 646          *
 647          * @param fd File descriptor to monitor for events.
 648          * @param ev Type of events to monitor.
 649          * @param handler Callback function.
 650          * @param arg Arbitrary pointer to pass to the handler as argument.
 651          */
 652         void add_once(int fd, type ev, ccallback_type handler, void* arg)
 653         {
 654                 internal::event_once(fd, static_cast< short >(ev), handler,
 655                         arg, 0);
 656         }
 657
 658         /**
 659          * Adds a temporary event.
 660          *
 661          * Adds a temporary event, without the need of instantiating a new event
 662          * object. Events added this way can't eventxx::PERSIST.
 663          *
 664          * @param fd File descriptor to monitor for events.
 665          * @param ev Type of events to monitor.
 666          * @param handler Callback function.
 667          * @param to Timeout.
 668          */
 669         template < typename F >
 670         void add_once(int fd, type ev, F& handler, const time& to)
 671         {
 672                 internal::event_once(fd, static_cast< short >(ev),
 673                         &dispatcher::wrapper< F >,
 674                         reinterpret_cast< void* >(&handler),
 675                         // XXX HACK libevent don't use const
 676                         const_cast< time* >(&to));
 677         }
 678
 679         /**
 680          * Adds a temporary event with a C-style callback.
 681          *
 682          * Adds a temporary event, without the need of instantiating a new event
 683          * object. Events added this way can't eventxx::PERSIST.
 684          *
 685          * @param fd File descriptor to monitor for events.
 686          * @param ev Type of events to monitor.
 687          * @param handler Callback function.
 688          * @param arg Arbitrary pointer to pass to the handler as argument.
 689          * @param to Timeout.
 690          */
 691         void add_once(int fd, type ev, ccallback_type handler, void* arg,
 692                         const time& to)
 693         {
 694                 internal::event_once(fd, static_cast< short >(ev), handler, arg,
 695                                 // XXX HACK libevent don't use const
 696                                 const_cast< time* >(&to));
 697         }
 698
 699         /**
 700          * Adds a temporary timer.
 701          *
 702          * Adds a temporary timer, without the need of instantiating a new timer
 703          * object.
 704          *
 705          * @param handler Callback function.
 706          * @param to Timer's timeout.
 707          */
 708         template < typename F >
 709         void add_once_timer(F& handler, const time& to)
 710         {
 711                 internal::event_once(-1, EV_TIMEOUT, &dispatcher::wrapper< F >,
 712                                 reinterpret_cast< void* >(&handler),
 713                                 // XXX HACK libevent don't use const
 714                                 const_cast< time* >(&to));
 715         }
 716
 717         /**
 718          * Adds a temporary timer with a C-style callback.
 719          *
 720          * Adds a temporary timer, without the need of instantiating a new timer
 721          * object.
 722          *
 723          * @param handler Callback function.
 724          * @param arg Arbitrary pointer to pass to the handler as argument.
 725          * @param to Timer's timeout.
 726          */
 727         void add_once_timer(ccallback_type handler, void* arg, const time& to)
 728         {
 729                 // XXX HACK libevent don't use const
 730                 internal::event_once(-1, EV_TIMEOUT, handler, arg,
 731                                 const_cast< time* >(&to));
 732         }
 733
 734         /**
 735          * Removes an event.
 736          *
 737          * The event e will be no longer monitored by this dispatcher.
 738          *
 739          * @param e Event to remove.
 740          */
 741         void del(basic_event& e) throw()
 742         {
 743                 internal::event_del(&e);
 744         }
 745
 746         /**
 747          * Main dispatcher loop.
 748          *
 749          * This function takes the control of the program, waiting for an event
 750          * and calling its callbacks when it's fired. It only returns under
 751          * this conditions:
 752          * - exit() was called.
 753          * - All events were del()eted.
 754          * - Another internal error.
 755          * - eventxx::ONCE flag was set.
 756          * - eventxx::NONBLOCK flag was set.
 757          *
 758          * @param flags If eventxx::ONCE is specified, then just one event is
 759          *              processed, if eventxx::NONBLOCK is specified, then this
 760          *              function returns even if there are no pending events.
 761          *
 762          * @return 0 if eventxx::NONBLOCK or eventxx::ONCE is set, 1 if there
 763          *         are no more events registered and EINTR if you use the
 764          *         @libevent's  @c event_gotsig and return -1 in your
 765          *         @c event_sigcb callback.
 766          */
 767         int dispatch(int flags = 0) throw()
 768         {
 769                 return internal::event_base_loop(_event_base, flags);
 770         }
 771
 772         /**
 773          * Exit the dispatch() loop.
 774          *
 775          * @param to If a timeout is given, the loop exits after the specified
 776          *           time is elapsed.
 777          *
 778          * @return Not very well specified by @libevent :-/ that's why it
 779          *         doesn't throw an exception either.
 780          */
 781         int exit(const time& to = time()) throw() // TODO  throw(exception)
 782         {
 783                 // XXX HACK libevent don't use const
 784                 return internal::event_base_loopexit(_event_base,
 785                         const_cast< time* >(&to));
 786         }
 787
 788         protected:
 789                 internal::event_base* _event_base;
 790                 template < typename F >
 791                 static void wrapper(int fd, short ev, void* h)
 792                 {
 793                         F& handler = *reinterpret_cast< F* >(h);
 794                         handler(fd, *reinterpret_cast< type* >(&ev));
 795                 }
 796
 797 }; // struct dispatcher
 798
 799 } // namespace eventxx
 800
 801 #endif // _EVENTXX_HPP_
 802
 803 // vim: set filetype=cpp :