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 *reinterpret_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                         handler(fd, *reinterpret_cast< type* >(&ev));
 324                 }
 325
 326 }; // struct event< F >
 327
 328
 329 /**
 330  * This is the specialization of eventxx::event for C-style callbacks.
 331  *
 332  * @see eventxx::event
 333  */
 334 template <>
 335 struct event< ccallback_type >: basic_event
 336 {
 337
 338         /**
 339          * Creates a new event.
 340          *
 341          * @param fd File descriptor to monitor for events.
 342          * @param ev Type of events to monitor (see eventxx::type).
 343          * @param handler C-style callback function.
 344          * @param arg Arbitrary pointer to pass to the handler as argument.
 345          */
 346         event(int fd, type ev, ccallback_type handler, void* arg = 0) throw()
 347         {
 348                 event_set(this, fd, static_cast< short >(ev), handler, arg);
 349         }
 350
 351         protected:
 352                 event() {}
 353
 354 }; // struct event< ccallback_type >
 355
 356
 357 /**
 358  * Timer event object.
 359  *
 360  * This is just a special case of event that is fired only when a timeout is
 361  * reached. It's just a shortcut to:
 362  * @code
 363  * event(-1, 0, handler);
 364  * @endcode
 365  *
 366  * @note This event can't eventxx::PERSIST.
 367  * @see timer< ccallback_type >
 368  */
 369 template < typename F >
 370 struct timer: event< F >
 371 {
 372
 373         /**
 374          * Creates a new timer event.
 375          *
 376          * @param handler Callback functor.
 377          */
 378         timer(F& handler) throw()
 379         {
 380                 evtimer_set(this, &event< F >::wrapper,
 381                         reinterpret_cast< void* >(&handler));
 382         }
 383
 384 }; // struct timer< F >
 385
 386
 387 /**
 388  * This is the specialization of eventxx::timer for C-style callbacks.
 389  *
 390  * @note This event can't eventxx::PERSIST.
 391  * @see timer
 392  */
 393 template <>
 394 struct timer< ccallback_type >: event< ccallback_type >
 395 {
 396
 397         /**
 398          * Creates a new timer event.
 399          *
 400          * @param handler C-style callback function.
 401          * @param arg Arbitrary pointer to pass to the handler as argument.
 402          */
 403         timer(ccallback_type handler, void* arg = 0) throw()
 404         {
 405                 evtimer_set(this, handler, arg);
 406         }
 407
 408 }; // struct timer< ccallback_type >
 409
 410
 411 /**
 412  * Signal event object.
 413  *
 414  * This is just a special case of event that is fired when a signal is raised
 415  * (instead of a file descriptor being active). It's just a shortcut to:
 416  * @code
 417  * event(signum, eventxx::SIGNAL, handler);
 418  * @endcode
 419  *
 420  * @note This event always eventxx::PERSIST.
 421  * @see signal< ccallback_type >
 422  */
 423 template < typename F >
 424 struct signal: event< F >
 425 {
 426
 427         /**
 428          * Creates a new signal event.
 429          *
 430          * @param signum Signal number to monitor.
 431          * @param handler Callback functor.
 432          */
 433         signal(int signum, F& handler) throw()
 434         {
 435                 signal_set(this, signum, &event< F >::wrapper,
 436                         reinterpret_cast< void* >(&handler));
 437         }
 438
 439         /**
 440          * Event's signal number.
 441          *
 442          * @return Event's signal number.
 443          */
 444         int signum() const
 445         {
 446                 return EVENT_SIGNAL(this);
 447         }
 448
 449 }; // struct signal<F>
 450
 451
 452 /**
 453  * This is the specialization of eventxx::signal for C-style callbacks.
 454  *
 455  * @note This event always eventxx::PERSIST.
 456  * @see signal
 457  */
 458 template <>
 459 struct signal< ccallback_type >: event< ccallback_type >
 460 {
 461
 462         /**
 463          * Creates a new signal event.
 464          *
 465          * @param signum Signal number to monitor.
 466          * @param handler C-style callback function.
 467          * @param arg Arbitrary pointer to pass to the handler as argument.
 468          */
 469         signal(int signum, ccallback_type handler, void* arg = 0) throw()
 470         {
 471                 signal_set(this, signum, handler, arg);
 472         }
 473
 474         /**
 475          * Event's signal number.
 476          *
 477          * @return Event's signal number.
 478          */
 479         int signum() const
 480         {
 481                 return EVENT_SIGNAL(this);
 482         }
 483
 484 }; // struct signal< ccallback_type >
 485
 486
 487 /// Shortcut to C-style event.
 488 typedef eventxx::event< ccallback_type > cevent;
 489
 490 /// Shortcut to C-style timer.
 491 typedef eventxx::timer< ccallback_type > ctimer;
 492
 493 /// Shortcut to C-style signal handler.
 494 typedef eventxx::signal< ccallback_type > csignal;
 495
 496 /**
 497  * Helper functor to use an arbitrary member function as an event handler.
 498  *
 499  * With this wrapper, you can use any object method, which accepts the right
 500  * parameters (int, short) and returns void, as an event handler. This way you
 501  * don't have to overload the operator() which can be confusing depending on the
 502  * context.
 503  *
 504  * You can see an usage example in the Examples Section.
 505  */
 506 template < typename O, typename M >
 507 struct mem_cb
 508 {
 509
 510         /**
 511          * Member function callback constructor.
 512          *
 513          * It expects to receive a class as the first parameter (O), and a
 514          * member function (of that class O) as the second parameter.
 515          *
 516          * When this instance is called with fd and ev as function arguments,
 517          * object.method(fd, ev) will be called.
 518          *
 519          * @param object Object to be used.
 520          * @param method Method to be called.
 521          */
 522         mem_cb(O& object, M method) throw():
 523                 _object(object), _method(method) {}
 524
 525         void operator() (int fd, type ev) { (_object.*_method)(fd, ev); }
 526         protected:
 527                 O& _object;
 528                 M _method;
 529
 530 }; // struct mem_cb
 531
 532 //@}
 533
 534
 535 /**
 536  * Event dispatcher.
 537  *
 538  * This class is the responsible for looping and dispatching events. Every time
 539  * you need an event loop you should create an instance of this class.
 540  *
 541  * You can @link dispatcher::add add @endlink events to the dispatcher, and you
 542  * can @link dispatcher::del remove @endlink them later or you can @link
 543  * dispatcher::add_once add events to be processed just once @endlink. You can
 544  * @link dispatcher::dispatch loop once or forever @endlink (well, of course you
 545  * can break that forever removing all the events or by @link dispatcher::exit
 546  * exiting the loop @endlink).
 547  */
 548 struct dispatcher
 549 {
 550
 551         /**
 552          * Creates a default dispatcher (with just 1 priority).
 553          *
 554          * @see dispatcher(int) if you want to create a dispatcher with more
 555          *      priorities.
 556          */
 557         dispatcher() throw()
 558         {
 559                 _event_base = static_cast< internal::event_base* >(
 560                                 internal::event_init());
 561         }
 562
 563         /**
 564          * Creates a dispatcher with npriorities priorities.
 565          *
 566          * @param npriorities Number of priority queues to use.
 567          */
 568         dispatcher(int npriorities) throw(std::bad_alloc)
 569         {
 570                 _event_base = static_cast< internal::event_base* >(
 571                                 internal::event_init());
 572                 if (!_event_base) throw std::bad_alloc();
 573                 // Can't fail because there is no way that it has active events
 574                 internal::event_base_priority_init(_event_base, npriorities);
 575         }
 576
 577 #ifndef EVENTXX_NO_EVENT_BASE_FREE
 578         /// Free dispatcher resources, see @ref Status section for details.
 579         ~dispatcher() throw() { event_base_free(_event_base); }
 580 #endif
 581
 582         /**
 583          * Adds an event to the dispatcher.
 584          *
 585          * @param e Event to add.
 586          * @param priority Priority of the event.
 587          */
 588         void add(basic_event& e, int priority = DEFAULT_PRIORITY)
 589                 throw(invalid_priority)
 590         {
 591                 internal::event_base_set(_event_base, &e);
 592                 if (priority != DEFAULT_PRIORITY
 593                                 && internal::event_priority_set(&e, priority))
 594                         throw invalid_priority();
 595                 internal::event_add(&e, 0);
 596         }
 597
 598         /**
 599          * Adds an event to the dispatcher with a timeout.
 600          *
 601          * The event is fired when there is activity on e or when to has elapsed,
 602          * whatever come first.
 603          *
 604          * @param e Event to add.
 605          * @param to Timeout.
 606          * @param priority Priority of the event.
 607          */
 608         void add(basic_event& e, const time& to,
 609                         int priority = DEFAULT_PRIORITY)
 610                 throw(invalid_priority)
 611         {
 612                 internal::event_base_set(_event_base, &e);
 613                 if (priority != DEFAULT_PRIORITY
 614                                 && internal::event_priority_set(&e, priority))
 615                         throw invalid_priority();
 616                 // XXX HACK libevent don't use const
 617                 internal::event_add(&e, const_cast< time* >(&to));
 618         }
 619
 620         /**
 621          * Adds a temporary event.
 622          *
 623          * Adds a temporary event, without the need of instantiating a new event
 624          * object. Events added this way can't eventxx::PERSIST.
 625          *
 626          * @param fd File descriptor to monitor for events.
 627          * @param ev Type of events to monitor.
 628          * @param handler Callback function.
 629          */
 630         template < typename F >
 631         void add_once(int fd, type ev, F& handler)
 632         {
 633                 internal::event_once(fd, static_cast< short>(ev),
 634                         &dispatcher::wrapper< F >,
 635                         reinterpret_cast< void* >(&handler), 0);
 636         }
 637
 638         /**
 639          * Adds a temporary event to with a C-style callback.
 640          *
 641          * Adds a temporary event, without the need of instantiating a new event
 642          * object. Events added this way can't eventxx::PERSIST.
 643          *
 644          * @param fd File descriptor to monitor for events.
 645          * @param ev Type of events to monitor.
 646          * @param handler Callback function.
 647          * @param arg Arbitrary pointer to pass to the handler as argument.
 648          */
 649         void add_once(int fd, type ev, ccallback_type handler, void* arg)
 650         {
 651                 internal::event_once(fd, static_cast< short >(ev), handler,
 652                         arg, 0);
 653         }
 654
 655         /**
 656          * Adds a temporary event.
 657          *
 658          * Adds a temporary event, without the need of instantiating a new event
 659          * object. Events added this way can't eventxx::PERSIST.
 660          *
 661          * @param fd File descriptor to monitor for events.
 662          * @param ev Type of events to monitor.
 663          * @param handler Callback function.
 664          * @param to Timeout.
 665          */
 666         template < typename F >
 667         void add_once(int fd, type ev, F& handler, const time& to)
 668         {
 669                 internal::event_once(fd, static_cast< short >(ev),
 670                         &dispatcher::wrapper< F >,
 671                         reinterpret_cast< void* >(&handler),
 672                         // XXX HACK libevent don't use const
 673                         const_cast< time* >(&to));
 674         }
 675
 676         /**
 677          * Adds a temporary event with a C-style callback.
 678          *
 679          * Adds a temporary event, without the need of instantiating a new event
 680          * object. Events added this way can't eventxx::PERSIST.
 681          *
 682          * @param fd File descriptor to monitor for events.
 683          * @param ev Type of events to monitor.
 684          * @param handler Callback function.
 685          * @param arg Arbitrary pointer to pass to the handler as argument.
 686          * @param to Timeout.
 687          */
 688         void add_once(int fd, type ev, ccallback_type handler, void* arg,
 689                         const time& to)
 690         {
 691                 internal::event_once(fd, static_cast< short >(ev), handler, arg,
 692                                 // XXX HACK libevent don't use const
 693                                 const_cast< time* >(&to));
 694         }
 695
 696         /**
 697          * Adds a temporary timer.
 698          *
 699          * Adds a temporary timer, without the need of instantiating a new timer
 700          * object.
 701          *
 702          * @param handler Callback function.
 703          * @param to Timer's timeout.
 704          */
 705         template < typename F >
 706         void add_once_timer(F& handler, const time& to)
 707         {
 708                 internal::event_once(-1, EV_TIMEOUT, &dispatcher::wrapper< F >,
 709                                 reinterpret_cast< void* >(&handler),
 710                                 // XXX HACK libevent don't use const
 711                                 const_cast< time* >(&to));
 712         }
 713
 714         /**
 715          * Adds a temporary timer with a C-style callback.
 716          *
 717          * Adds a temporary timer, without the need of instantiating a new timer
 718          * object.
 719          *
 720          * @param handler Callback function.
 721          * @param arg Arbitrary pointer to pass to the handler as argument.
 722          * @param to Timer's timeout.
 723          */
 724         void add_once_timer(ccallback_type handler, void* arg, const time& to)
 725         {
 726                 // XXX HACK libevent don't use const
 727                 internal::event_once(-1, EV_TIMEOUT, handler, arg,
 728                                 const_cast< time* >(&to));
 729         }
 730
 731         /**
 732          * Removes an event.
 733          *
 734          * The event e will be no longer monitored by this dispatcher.
 735          *
 736          * @param e Event to remove.
 737          */
 738         void del(basic_event& e) throw()
 739         {
 740                 internal::event_del(&e);
 741         }
 742
 743         /**
 744          * Main dispatcher loop.
 745          *
 746          * This function takes the control of the program, waiting for an event
 747          * and calling its callbacks when it's fired. It only returns under
 748          * this conditions:
 749          * - exit() was called.
 750          * - All events were del()eted.
 751          * - Another internal error.
 752          * - eventxx::ONCE flag was set.
 753          * - eventxx::NONBLOCK flag was set.
 754          *
 755          * @param flags If eventxx::ONCE is specified, then just one event is
 756          *              processed, if eventxx::NONBLOCK is specified, then this
 757          *              function returns even if there are no pending events.
 758          *
 759          * @return 0 if eventxx::NONBLOCK or eventxx::ONCE is set, 1 if there
 760          *         are no more events registered and EINTR if you use the
 761          *         @libevent's  @c event_gotsig and return -1 in your
 762          *         @c event_sigcb callback.
 763          */
 764         int dispatch(int flags = 0) throw()
 765         {
 766                 return internal::event_base_loop(_event_base, flags);
 767         }
 768
 769         /**
 770          * Exit the dispatch() loop.
 771          *
 772          * @param to If a timeout is given, the loop exits after the specified
 773          *           time is elapsed.
 774          *
 775          * @return Not very well specified by @libevent :-/ that's why it
 776          *         doesn't throw an exception either.
 777          */
 778         int exit(const time& to = time()) throw() // TODO  throw(exception)
 779         {
 780                 // XXX HACK libevent don't use const
 781                 return internal::event_base_loopexit(_event_base,
 782                         const_cast< time* >(&to));
 783         }
 784
 785         protected:
 786                 internal::event_base* _event_base;
 787                 template < typename F >
 788                 static void wrapper(int fd, short ev, void* h)
 789                 {
 790                         F& handler = *reinterpret_cast< F* >(h);
 791                         handler(fd, *reinterpret_cast< type* >(&ev));
 792                 }
 793
 794 }; // struct dispatcher
 795
 796 } // namespace eventxx
 797
 798 #endif // _EVENTXX_HPP_
 799
 800 // vim: set filetype=cpp :