ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/cfperl.h
(Generate patch)

Comparing deliantra/server/include/cfperl.h (file contents):
Revision 1.12 by root, Mon Aug 28 14:05:24 2006 UTC vs.
Revision 1.108 by root, Mon Oct 12 14:00:58 2009 UTC

1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
21 *
22 * The authors can be reached via e-mail to <support@deliantra.net>
23 */
24
1// 25//
2// cfperl.h perl interface 26// cfperl.h perl interface
3// 27//
4#ifndef CFPERL_H__ 28#ifndef CFPERL_H__
5#define CFPERL_H__ 29#define CFPERL_H__
6 30
7struct pl; 31#include <cstdarg>
8struct object; 32#include <cstdio>
9struct mapstruct; 33#include <bitset>
34
35using namespace std;
36
37#include <EXTERN.h>
38#include <perl.h>
39#include <XSUB.h>
40
41#include <EVAPI.h>
42#include <CoroAPI.h>
43
44#include "util.h"
45#include "keyword.h"
46#include "dynbuf.h"
47#include "callback.h"
48
49//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
50
51// optimisations/workaround for functions requiring my_perl in scope (anti-bloat)
52#undef localtime
53#undef srand48
54#undef drand48
55#undef srandom
56#undef opendir
57#undef readdir
58#undef closedir
59#undef getprotobyname
60#undef gethostbyname
61#undef ctime
62#undef strerror
63#undef _
64
65// same here, massive symbol spamming
66#undef do_open
67#undef do_close
68#undef ref
69#undef seed
70
71// perl bug #40256: perl does overwrite those with reentrant versions
72// but does not initialise their state structures.
73#undef random
74#undef crypt
75
76//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
77
78#define _(msg) (msg)
79#define N_(msg) (msg)
80
81//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
82
83// some macros to simplify perl in-calls
84
85#define CHECK_ERROR \
86 if (SvTRUE (ERRSV)) \
87 LOG (llevError, "runtime error in %s: %s", __func__, SvPVutf8_nolen (ERRSV));
88
89inline int call_pvsv (const char *ob, I32 flags) { return call_pv (ob, flags); }
90inline int call_pvsv (SV *ob, I32 flags) { return call_sv (ob, flags); }
91
92#define CALL_BEGIN(args) dSP; ENTER; SAVETMPS; PUSHMARK (SP); EXTEND (SP, args)
93#define CALL_ARG_SV(sv) PUSHs (sv_2mortal (sv)) // separate because no refcount inc
94#define CALL_ARG(expr) PUSHs (sv_2mortal (to_sv (expr)))
95#define CALL_CALL(name, flags) PUTBACK; int count = call_pvsv (name, (flags) | G_EVAL); SPAGAIN;
96#define CALL_END PUTBACK; CHECK_ERROR; FREETMPS; LEAVE
97
98//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
10 99
11void cfperl_init (); 100void cfperl_init ();
12void cfperl_main (); 101void cfperl_main ();
102void cfperl_tick ();
103void cfperl_emergency_save ();
104void cfperl_cleanup (int make_core);
105void cfperl_make_book (object *book, int level);
106void cfperl_send_msg (client *ns, int color, const char *type, const char *msg);
107int cfperl_can_merge (object *ob1, object *ob2);
108void cfperl_mapscript_activate (object *ob, int state, object *activator, object *originator = 0);
13 109
14// could have used templates, but a more traditional C api 110bool is_match_expr (const char *expr);
15// uses more explicit typing which is ok for this purpose. 111/* applies the match expression and returns true if it matches */
16enum data_type 112bool match (const char *expr, object *ob, object *self = 0, object *source = 0, object *originator = 0);
17{
18 DT_END, // no further arguments
19 DT_AV, // perl-only av that needs to be flattened out
20 DT_INT,
21 DT_INT64,
22 DT_DOUBLE,
23 DT_STRING, // 0-terminated string
24 DT_DATA, // string + length
25 DT_OBJECT,
26 DT_MAP,
27 DT_PLAYER,
28 DT_ARCH,
29 DT_PARTY,
30 DT_REGION,
31 113
32 NUM_DATA_TYPES 114//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
33}; 115
116#if IVSIZE >= 8
117 typedef IV val64;
118 typedef IV uval64;
119# define newSVval64 newSViv
120# define SvVAL64 SvIV
121# define newSVuval64 newSVuv
122# define SvUVAL64 SvUV
123#else
124 typedef double val64;
125 typedef double uval64;
126# define newSVval64 newSVnv
127# define SvVAL64 SvNV
128# define newSVuval64 newSVnv
129# define SvUVAL64 SvNV
130#endif
131
132extern tstamp runtime; // virtual server time, excluding time jumps and lag
133extern tstamp NOW; // real time of current server tick
34 134
35enum event_klass 135enum event_klass
36{ 136{
37 KLASS_NONE, 137 KLASS_NONE,
38 KLASS_GLOBAL, 138 KLASS_GLOBAL,
139 KLASS_ATTACHABLE,
140 KLASS_CLIENT,
39 KLASS_PLAYER, 141 KLASS_PLAYER,
40 KLASS_OBJECT, 142 KLASS_OBJECT,
41 KLASS_MAP, 143 KLASS_MAP,
144 KLASS_COMMAND,
42}; 145};
43 146
44enum event_type 147enum event_type
45{ 148{
46# define def(klass,name) EVENT_ ## klass ## _ ## name, 149# define def(klass,name) EVENT_ ## klass ## _ ## name,
47# include "eventinc.h" 150# include "eventinc.h"
48# undef def 151# undef def
49 NUM_EVENT_TYPES 152 NUM_EVENT_TYPES
50}; 153};
51 154
155// in which global events or per-type events are we interested
156extern bitset<NUM_EVENT_TYPES> ev_want_event;
157extern bitset<NUM_TYPES> ev_want_type;
158
52#define ARG_AV(o) DT_AV , static_cast<AV *> (o) 159#define ARG_AV(o) DT_AV , static_cast<AV *> (o)
53#define ARG_INT(v) DT_INT , static_cast<int> (v) 160#define ARG_INT(v) DT_INT , static_cast<int> (v)
54#define ARG_INT64(v) DT_INT64 , static_cast<sint64> (v) 161#define ARG_INT64(v) DT_INT64 , static_cast<sint64> (v)
55#define ARG_DOUBLE(v) DT_DOUBLE, static_cast<double> (v) 162#define ARG_DOUBLE(v) DT_DOUBLE, static_cast<double> (v)
56#define ARG_STRING(v) DT_STRING, static_cast<const char *> (v) 163#define ARG_STRING(v) DT_STRING, static_cast<const char *> (v)
57#define ARG_DATA(s,l) DT_DATA , static_cast<const void *> (s), (l) 164#define ARG_DATA(s,l) DT_DATA , static_cast<const void *> (s), int (l)
58#define ARG_OBJECT(o) DT_OBJECT, (void *)static_cast<struct object *> (o) 165#define ARG_OBJECT(o) DT_OBJECT, (void *)(static_cast<object *> (o))
59#define ARG_MAP(o) DT_MAP , (void *)static_cast<struct mapstruct *> (o) 166#define ARG_MAP(o) DT_MAP , (void *)(static_cast<maptile *> (o))
60#define ARG_PLAYER(o) DT_PLAYER, (void *)static_cast<struct pl *> (o) 167#define ARG_PLAYER(o) DT_PLAYER, (void *)(static_cast<player *> (o))
61#define ARG_ARCH(o) DT_ARCH , (void *)static_cast<struct archetype *> (o) 168#define ARG_ARCH(o) DT_ARCH , (void *)(static_cast<archetype *> (o))
169#define ARG_CLIENT(o) DT_CLIENT, (void *)(static_cast<client *> (o))
62#define ARG_PARTY(o) DT_PARTY , (void *)static_cast<struct party *> (o) 170#define ARG_PARTY(o) DT_PARTY , (void *)(static_cast<party *> (o))
63#define ARG_REGION(o) DT_REGION, (void *)static_cast<struct region *> (o) 171#define ARG_REGION(o) DT_REGION, (void *)(static_cast<region *> (o))
64 172
65// the ", ## __VA_ARGS" is, unfortunately, a gnu-cpp extension 173// the ", ## __VA_ARGS" is, unfortunately, a gnu-cpp extension
66 174#define INVOKE(obj,event, ...) (expect_false ((obj)->should_invoke (event)) ? (obj)->invoke (event, ## __VA_ARGS__, DT_END) : 0)
67// all these return true when the normal event processing should be skipped (if any)
68#define INVOKE_(event, ...) cfperl_invoke (event, ## __VA_ARGS__, DT_END)
69
70#define INVOKE(klass, event, ...) INVOKE_(EVENT_ ## klass ## _ ## event, ## __VA_ARGS__)
71#define INVOKE_GLOBAL(event, ...) INVOKE_(EVENT_ ## GLOBAL ## _ ## event, ## __VA_ARGS__) 175#define INVOKE_GLOBAL(event, ...) INVOKE (&gbl_ev, EVENT_ ## GLOBAL ## _ ## event, ## __VA_ARGS__)
176#define INVOKE_ATTACHABLE(event, obj, ...) INVOKE (obj , EVENT_ ## ATTACHABLE ## _ ## event, ## __VA_ARGS__)
72#define INVOKE_OBJECT(event, op, ...) INVOKE_(EVENT_ ## OBJECT ## _ ## event, ARG_OBJECT (op), ## __VA_ARGS__) 177#define INVOKE_OBJECT(event, obj, ...) INVOKE (obj , EVENT_ ## OBJECT ## _ ## event, ## __VA_ARGS__)
178#define INVOKE_CLIENT(event, obj, ...) INVOKE (obj , EVENT_ ## CLIENT ## _ ## event, ## __VA_ARGS__)
73#define INVOKE_PLAYER(event, pl, ...) INVOKE_(EVENT_ ## PLAYER ## _ ## event, ARG_PLAYER (pl), ## __VA_ARGS__) 179#define INVOKE_PLAYER(event, obj, ...) INVOKE (obj , EVENT_ ## PLAYER ## _ ## event, ## __VA_ARGS__)
74#define INVOKE_MAP(event, map, ...) INVOKE_(EVENT_ ## MAP ## _ ## event, ARG_MAP (map) , ## __VA_ARGS__) 180#define INVOKE_MAP(event, obj, ...) INVOKE (obj , EVENT_ ## MAP ## _ ## event, ## __VA_ARGS__)
75 181
76//TODO should index into @result 182//TODO should index into @result
77#define RESULT(idx,type) cfperl_result_ ## type (idx) 183#define RESULT(idx,type) cfperl_result_ ## type (idx)
184#define RESULT_DOUBLE(idx) RESULT(idx, DOUBLE)
78#define RESULT_INT(idx) RESULT(idx, INT) 185#define RESULT_INT(idx) RESULT(idx, INT)
79 186
80bool cfperl_invoke (event_type event, ...); 187double cfperl_result_DOUBLE (int idx);
81int cfperl_result_INT (int idx); 188int cfperl_result_INT (int idx);
82 189
190//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
191
192INTERFACE_CLASS (attachable)
83struct attachable_base 193struct attachable : refcnt_base
84{ 194{
85 void *self, *cb; // CF+ perl self and callback 195 static MGVTBL vtbl;
196
197 enum {
198 F_DESTROYED = 0x01,
199 F_DEBUG_TRACE = 0x02,
200 };
201 uint8 ACC (RW, flags);
202
203 static unordered_vector<attachable *> mortals;
204 MTH static void check_mortals ();
205
206 // object is delete'd after the refcount reaches 0
207 MTH int refcnt_cnt () const;
208 // check wether the object has died and destroy
209 MTH void refcnt_chk () { if (expect_false (refcnt <= 0)) do_check (); }
210
211 // destroy the object unless it was already destroyed
212 // this politely asks everybody interested the reduce
213 // the refcount to 0 as soon as possible.
214 MTH void destroy ();
215
216 // return wether an object was destroyed already
217 MTH bool destroyed () const { return flags & F_DESTROYED; }
218
219 virtual void gather_callbacks (AV *&callbacks, event_type event) const;
220
221#if 0
222private:
223 static refcounted *rc_first;
224 refcounted *rc_next;
225#endif
226
227 HV *self; // CF+ perl self
228 AV *cb; // CF+ callbacks
86 const char *attach; // generic extension attachment information 229 shstr attach; // generic extension attachment information
87 230
88 void clear (); // called when free'ing objects 231 void sever_self (); // sever this object from its self, if it has one.
89 void optimise (); // possibly save some memory by destroying unneeded data 232 void optimise (); // possibly save some memory by destroying unneeded data
90 233
91 void attachable_init () 234 attachable ()
235 : flags (0), self (0), cb (0), attach (0)
92 { 236 {
93 self = cb = 0;
94 attach = 0;
95 } 237 }
96};
97 238
98// objects attachable from perl (or any other extension) should include or 239 attachable (const attachable &src)
99// derive using the curiously recurring template pattern, to avoid 240 : flags (0), self (0), cb (0), attach (src.attach)
100// virtual method calls etc.
101template<class subclass>
102struct attachable : attachable_base
103{
104 static data_type get_dt ()
105 { 241 {
106 subclass::get_dt ();
107 } 242 }
108};
109 243
110struct object_freezethaw 244 // set a custom key to the given value, or delete it if value = 0
111{ 245 void set_key (const char *key, const char *value = 0, bool is_utf8 = 0);
112 void *av;
113 FILE *fp;
114 246
115 operator FILE *() { return fp; } 247 void set_key_text (const char *key, const char *value = 0)
116}; 248 {
249 set_key (key, value, 1);
250 }
117 251
118struct object_freezer : object_freezethaw 252 void set_key_data (const char *key, const char *value = 0)
119{ 253 {
120 void *filename; 254 set_key (key, value, 0);
255 }
121 256
122 object_freezer (const char *filename); 257 attachable &operator =(const attachable &src);
258
259 // used to _quickly_ device wether to shortcut the evaluation
260 bool should_invoke (event_type event)
261 {
262 return ev_want_event [event] || cb;
263 }
264
265 bool invoke (event_type event, ...);
266
267 MTH void instantiate ();
268 void reattach ();
269
270protected:
271 // do the real refcount checking work
272 void do_check ();
273
274 // the method that does the real destroy work
275 virtual void do_destroy ();
276
277 // destructor is protected, should not be called by anybody
278 virtual ~attachable ();
279};
280
281// the global object is a pseudo object that cares for the global events
282struct global : attachable
283{
284 void gather_callbacks (AV *&callbacks, event_type event) const;
285};
286
287extern struct global gbl_ev;
288
289//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
290
291INTERFACE_CLASS(object_freezer)
292struct object_freezer : dynbuf_text
293{
294 AV *av;
295
296 object_freezer ();
123 ~object_freezer (); 297 ~object_freezer ();
124 298
125 void put (attachable_base *ext); 299 void put (attachable *ext);
126 300
127 template<class subclass> 301 // used only for user-defined key-value pairs
128 void put (attachable<subclass> *obj) 302 void put (shstr_tmp k, shstr_tmp v)
129 { 303 {
130 put ((attachable_base *)obj); 304 add (k);
131 }
132};
133 305
134struct object_thawer : object_freezethaw 306 if (expect_true (v))
307 add (' '), add (v);
308
309 add ('\n');
310 }
311
312 template<typename T>
313 void put_kw_string (keyword k, const T &v)
314 {
315 int klen = keyword_len [k];
316 int vlen = v ? strlen (v) + 1 : 0;
317
318 char *p = (char *)alloc (klen + vlen + 1);
319
320 memcpy (p, keyword_str [k], klen); p += klen;
321
322 if (expect_true (v))
323 {
324 *p++ = ' '; vlen--;
325 memcpy (p, v, vlen); p += vlen;
326 }
327
328 *p = '\n';
329 }
330
331 void put (keyword k, const char *v = 0)
332 {
333 put_kw_string (k, v);
334 }
335
336 void put (keyword k, shstr_tmp v)
337 {
338 put_kw_string (k, v);
339 }
340
341 void put (keyword k, double v)
342 {
343 force (MAX_KEYWORD_LEN + 2 + 32);
344 fadd (keyword_str [k], keyword_len [k]);
345 fadd (' ');
346 falloc (sprintf (ptr, "%.7g", v));
347 fadd ('\n');
348 }
349
350 void put_(keyword k, sint64 v)
351 {
352 force (MAX_KEYWORD_LEN + 2 + sint64_digits);
353 fadd (keyword_str [k], keyword_len [k]);
354 fadd (' ');
355 add (v);
356 fadd ('\n');
357 }
358
359 void put_(keyword k, sint32 v)
360 {
361 force (MAX_KEYWORD_LEN + 2 + sint32_digits);
362 fadd (keyword_str [k], keyword_len [k]);
363 fadd (' ');
364 add (v);
365 fadd ('\n');
366 }
367
368 void put (keyword k, float v) { put (k, (double)v); }
369 void put (keyword k, signed char v) { put_(k, (sint32)v); }
370 void put (keyword k, unsigned char v) { put_(k, (sint32)v); }
371 void put (keyword k, signed short v) { put_(k, (sint32)v); }
372 void put (keyword k, unsigned short v) { put_(k, (sint32)v); }
373 void put (keyword k, signed int v) { put_(k, (sint32)v); }
374 void put (keyword k, unsigned int v) { put_(k, (sint64)v); }
375 void put (keyword k, signed long v) { put_(k, (sint64)v); }
376 void put (keyword k, unsigned long v) { put_(k, (sint64)v); }
377 void put (keyword k, signed long long v) { put_(k, (sint64)v); }
378 void put (keyword k, unsigned long long v) { put_(k, (sint64)v); }
379
380 void put (keyword kbeg, keyword kend, shstr_tmp v)
381 {
382 force (MAX_KEYWORD_LEN + 1);
383 fadd (keyword_str [kbeg], keyword_len [kbeg]); fadd ('\n');
384
385 if (expect_true (v))
386 {
387 add (v);
388 add ('\n');
389 }
390
391 force (MAX_KEYWORD_LEN + 1);
392 fadd (keyword_str [kend], keyword_len [kend]); fadd ('\n');
393 }
394
395 void put (keyword k, archetype *v);
396 void put (keyword k, treasurelist *v);
397 void put (keyword k, faceinfo *v);
398
399 template<typename T>
400 void put (keyword k, const refptr<T> &v)
401 {
402 put (k, (T *)v);
403 }
404
405 MTH bool save (const_octet_string path);
406 char *as_string (); // like strdup
407
408 operator bool () { return !!av; }
409};
410
411INTERFACE_CLASS(object_thawer)
412struct object_thawer
135{ 413{
414 char *line; // current beginning of line
415 SV *text; // text part
416 AV *av; // perl part
417 int linenum;
418 keyword kw;
419 char *kw_str; // the keyword parsed, as string
420 char *value; // the value, or 0 if no value
421 const char *value_nn; // the value, or the empty string if no value
422 const char *name;
423
424 operator bool () const { return !!text; }
425
136 object_thawer (FILE *fp, const char *filename = 0); 426 object_thawer (const char *path = 0);
427 object_thawer (const char *data, AV *perlav);
137 ~object_thawer (); 428 ~object_thawer ();
138 429
139 void get (data_type type, void *obj, attachable_base *ext, int oid);
140
141 template<class subclass>
142 void get (attachable<subclass> *obj, int oid) 430 void get (attachable *obj, int oid);
431
432 // parse next line
433 MTH void next ();
434 // skip the current key-value (usually fetch next line, for
435 // multiline-fields, skips till the corresponding end-kw
436 MTH void skip ();
437 MTH void skip_block (); // skips till and over KW_end
438
439 char *get_str () { return value; } // may be 0
440 void get_ml (keyword kend, shstr &sh);
441
442 void get_ornull (shstr &sh) const { sh = value; }
443 void get (shstr &sh) const { sh = value; } // might want to check for non-null here
444
445 bool get_bool () const { return *value_nn == '1'; }
446 sint32 get_sint32 () const;
447 sint64 get_sint64 () const { return strtoll (value_nn, 0, 10); }
448 double get_double () const { return strtod (value_nn, 0); }
449
450 void get (float &v) { v = get_double (); }
451 void get (double &v) { v = get_double (); }
452
453 void get (bool &i) { i = get_bool (); }
454 void get (sint8 &i) { i = get_sint32 (); }
455 void get (uint8 &i) { i = get_sint32 (); }
456 void get (sint16 &i) { i = get_sint32 (); }
457 void get (uint16 &i) { i = get_sint32 (); }
458 void get (sint32 &i) { i = get_sint32 (); }
459
460 void get (uint32 &i) { i = get_sint64 (); }
461 void get (sint64 &i) { i = get_sint64 (); }
462
463 MTH void parse_warn (const char *msg);
464 MTH bool parse_error (const char *type = 0, const char *name = 0, bool skip = true);
465
466 struct delayed_ref {
467 attachable *op;
468 object_ptr *ptr;
469 const char *ref;
470 };
471 std::vector<delayed_ref> delrefs;
472
473 void delayed_deref (attachable *op, object_ptr &ptr, const char *ref);
474 MTH void resolve_delayed_derefs (bool deref = true);
475};
476
477//TODO: remove
478char *fgets (char *s, int n, object_thawer &thawer);
479
480//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
481
482struct coroapi {
483 static struct CoroAPI *GCoroAPI;
484
485 static EV_ATOMIC_T cede_pending;
486
487 static int nready () { return CORO_NREADY; }
488 static int cede () { cede_pending = 0; return CORO_CEDE ; }
489
490 static void do_cede_to_tick ();
491
492 // actually cede's far more often
493 static bool cede_to_tick ()
143 { 494 {
144 if (av) 495 if (expect_true (!cede_pending))
145 get (subclass::get_dt (), (subclass *)obj, obj, oid); 496 return false;
497
498 do_cede_to_tick ();
499 return true;
500 }
501
502 static void wait_for_tick ();
503 static void wait_for_tick_begin ();
504};
505
506struct evapi
507{
508 static struct EVAPI *GEVAPI;
509};
510
511struct iow : ev_io, evapi, callback<void (iow &, int)>
512{
513 static void thunk (EV_P_ struct ev_io *w_, int revents)
514 {
515 iow &w = *static_cast<iow *>(w_);
516
517 w (w, revents);
518 }
519
520 template<class O, class M>
521 iow (O object, M method)
522 : callback<void (iow &, int)> (object, method)
523 {
524 ev_init ((ev_io *)this, thunk);
525 }
526
527 void prio (int prio)
528 {
529 ev_set_priority ((ev_io *)this, prio);
530 }
531
532 void set (int fd, int events)
533 {
534 ev_io_set ((ev_io *)this, fd, events);
535 }
536
537 int poll () const { return events; }
538
539 void poll (int events);
540
541 void start ()
542 {
543 ev_io_start (EV_DEFAULT, (ev_io *)this);
544 }
545
546 void stop ()
547 {
548 ev_io_stop (EV_DEFAULT, (ev_io *)this);
549 }
550
551 ~iow ()
552 {
553 stop ();
554 }
555};
556
557struct asyncw : ev_async, evapi, callback<void (ev_async &, int)>
558{
559 static void thunk (EV_P_ struct ev_async *w_, int revents)
560 {
561 asyncw &w = *static_cast<asyncw *>(w_);
562
563 w (w, revents);
564 }
565
566 template<class O, class M>
567 asyncw (O object, M method)
568 : callback<void (asyncw &, int)> (object, method)
569 {
570 ev_init ((ev_async *)this, thunk);
571 }
572
573 void start ()
574 {
575 ev_async_start (EV_DEFAULT, (ev_async *)this);
576 }
577
578 void stop ()
579 {
580 ev_async_stop (EV_DEFAULT, (ev_async *)this);
581 }
582
583 ~asyncw ()
584 {
585 stop ();
146 } 586 }
147}; 587};
148 588
149#endif 589#endif
150 590

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines