[ViewVC] Diff of: cvs/libev/ev++.h

Comparing libev/ev++.h (file contents):
Revision 1.7 by root, Sat Nov 24 09:48:37 2007 UTC vs.
Revision 1.14 by root, Tue Dec 4 17:08:05 2007 UTC

…		…
3		3
4	#include "ev.h"	4	#include "ev.h"
5		5
6	namespace ev {	6	namespace ev {
7		7
8	template<class watcher>	8	template<class ev_watcher, class watcher>
9	class callback	9	struct base : ev_watcher
10	{	10	{
11	struct object { };	11	#if EV_MULTIPLICITY
		12	EV_P;
12		13
13	void *obj;	14	void set (EV_P)
14	void (object::*meth)(watcher &, int);
15
16	/* a proxy is a kind of recipe on how to call a specific class method */
17	struct proxy_base {
18	virtual void call (void obj, void (object::meth)(watcher &, int), watcher &w, int) const = 0;
19	};
20	template<class O1, class O2>
21	struct proxy : proxy_base {
22	virtual void call (void obj, void (object::meth)(watcher &, int), watcher &w, int e) const
23	{	15	{
24	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<void (O2::*)(watcher &, int)>(meth)))	16	this->EV_A = EV_A;
25	(w, e);
26	}	17	}
		18	#endif
		19
		20	base ()
		21	{
		22	ev_init (this, 0);
27	};	23	}
28		24
29	proxy_base *prxy;	25	void set_ (void object, void (cb)(ev_watcher *w, int revents))
30
31	public:
32	template<class O1, class O2>
33	explicit callback (O1 object, void (O2::method)(watcher &, int))
34	{
35	static proxy<O1,O2> p;
36	obj = reinterpret_cast<void *>(object);
37	meth = reinterpret_cast<void (object::*)(watcher &, int)>(method);
38	prxy = &p;
39	}	26	{
40		27	this->data = object;
41	void call (watcher *w, int e) const	28	ev_set_cb (static_cast<ev_watcher *>(this), cb);
42	{	29	}
43	return prxy->call (obj, meth, *w, e);	30
		31	template<class K, void (K::*method)(watcher &w, int)>
		32	void set (K *object)
		33	{
		34	set_ (object, method_thunk<K, method>);
		35	}
		36
		37	template<class K, void (K::*method)(watcher &w, int)>
		38	static void method_thunk (ev_watcher *w, int revents)
		39	{
		40	watcher self = static_cast<watcher >(w);
		41	K obj = static_cast<K >(self->data);
		42	(obj->method) (self, revents);
		43	}
		44
		45	template<class K, void (K::*method)(watcher &w, int) const>
		46	void set (const K *object)
		47	{
		48	set_ (object, const_method_thunk<K, method>);
		49	}
		50
		51	template<class K, void (K::*method)(watcher &w, int) const>
		52	static void const_method_thunk (ev_watcher *w, int revents)
		53	{
		54	watcher self = static_cast<watcher >(w);
		55	K obj = static_cast<K >(self->data);
		56	(obj->method) (self, revents);
		57	}
		58
		59	template<void (*function)(watcher &w, int)>
		60	void set ()
		61	{
		62	set_ (0, function_thunk<function>);
		63	}
		64
		65	template<void (*function)(watcher &w, int)>
		66	static void function_thunk (ev_watcher *w, int revents)
		67	{
		68	watcher self = static_cast<watcher >(w);
		69	function (*self, revents);
		70	}
		71
		72	void operator ()(int events = EV_UNDEF)
		73	{
		74	return ev_cb (static_cast<ev_watcher *>(this))
		75	(static_cast<ev_watcher *>(this), events);
		76	}
		77
		78	bool is_active () const
		79	{
		80	return ev_is_active (static_cast<const ev_watcher *>(this));
		81	}
		82
		83	bool is_pending () const
		84	{
		85	return ev_is_pending (static_cast<const ev_watcher *>(this));
44	}	86	}
45	};	87	};
46		88
47	enum {	89	enum {
48	UNDEF = EV_UNDEF,	90	UNDEF = EV_UNDEF,
…		…
50	READ = EV_READ,	92	READ = EV_READ,
51	WRITE = EV_WRITE,	93	WRITE = EV_WRITE,
52	TIMEOUT = EV_TIMEOUT,	94	TIMEOUT = EV_TIMEOUT,
53	PERIODIC = EV_PERIODIC,	95	PERIODIC = EV_PERIODIC,
54	SIGNAL = EV_SIGNAL,	96	SIGNAL = EV_SIGNAL,
		97	CHILD = EV_CHILD,
		98	STAT = EV_STAT,
55	IDLE = EV_IDLE,	99	IDLE = EV_IDLE,
56	CHECK = EV_CHECK,	100	CHECK = EV_CHECK,
57	PREPARE = EV_PREPARE,	101	PREPARE = EV_PREPARE,
58	CHILD = EV_CHILD,	102	FORK = EV_FORK,
		103	EMBED = EV_EMBED,
59	ERROR = EV_ERROR,	104	ERROR = EV_ERROR,
60	};	105	};
61		106
62	typedef ev_tstamp tstamp;	107	typedef ev_tstamp tstamp;
63		108
…		…
65	{	110	{
66	return ev_now (EV_A);	111	return ev_now (EV_A);
67	}	112	}
68		113
69	#if EV_MULTIPLICITY	114	#if EV_MULTIPLICITY
70
71	#define EV_CONSTRUCT(cppstem) \
72	EV_P; \	115	#define EV_CONSTRUCT \
73	\
74	void set (EV_P) \	116	(EV_P = EV_DEFAULT) \
75	{ \	117	{ \
76	this->EV_A = EV_A; \
77	} \
78	\	118	set (EV_A); \
79	template<class O1, class O2> \	119	}
80	explicit cppstem (O1 object, void (O2::method)(cppstem &, int), EV_P = ev_default_loop (0)) \
81	: callback<cppstem> (object, method), EV_A (EV_A)
82
83	#else	120	#else
84		121	#define EV_CONSTRUCT \
85	#define EV_CONSTRUCT(cppstem) \	122	() \
86	template<class O1, class O2> \	123	{ \
87	explicit cppstem (O1 object, void (O2::method)(cppstem &, int)) \	124	}
88	: callback<cppstem> (object, method)
89
90	#endif	125	#endif
91		126
92	/* using a template here would require quite a bit more lines,	127	/* using a template here would require quite a bit more lines,
93	* so a macro solution was chosen */	128	* so a macro solution was chosen */
94	#define EV_BEGIN_WATCHER(cppstem,cstem) \	129	#define EV_BEGIN_WATCHER(cppstem,cstem) \
95	\	130	\
96	struct cppstem : ev_ ## cstem, callback<cppstem> \	131	struct cppstem : base<ev_ ## cstem, cppstem> \
97	{ \	132	{ \
98	EV_CONSTRUCT (cppstem) \
99	{ \
100	ev_init (static_cast<ev_ ## cstem *>(this), thunk); \
101	} \
102	\
103	bool is_active () const \
104	{ \
105	return ev_is_active (static_cast<const ev_ ## cstem *>(this)); \
106	} \
107	\
108	bool is_pending () const \
109	{ \
110	return ev_is_pending (static_cast<const ev_ ## cstem *>(this)); \
111	} \
112	\
113	void start () \	133	void start () \
114	{ \	134	{ \
115	ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this)); \	135	ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this)); \
116	} \	136	} \
117	\	137	\
118	void stop () \	138	void stop () \
119	{ \	139	{ \
120	ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this)); \	140	ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this)); \
121	} \	141	} \
122	\	142	\
123	void operator ()(int events = EV_UNDEF) \
124	{ \	143	cppstem EV_CONSTRUCT \
125	return call (this, events); \
126	} \
127	\	144	\
128	~cppstem () \	145	~cppstem () \
129	{ \	146	{ \
130	stop (); \	147	stop (); \
131	} \	148	} \
132	\	149	\
		150	using base<ev_ ## cstem, cppstem>::set; \
		151	\
133	private: \	152	private: \
134	\	153	\
135	cppstem (const cppstem &o) \	154	cppstem (const cppstem &o) \
136	: callback<cppstem> (this, (void (cppstem::*)(cppstem &, int))0) \
137	{ /* disabled */ } \	155	{ /* disabled */ } \
138	\	156	\
139	void operator =(const cppstem &o) { /* disabled */ } \	157	void operator =(const cppstem &o) { /* disabled */ } \
140	\
141	static void thunk (EV_P_ struct ev_ ## cstem *w, int revents) \
142	{ \
143	(static_cast<cppstem >(w))(revents); \
144	} \
145	\	158	\
146	public:	159	public:
147		160
148	#define EV_END_WATCHER(cppstem,cstem) \	161	#define EV_END_WATCHER(cppstem,cstem) \
149	};	162	};
…		…
191	{	204	{
192	ev_timer_again (EV_A_ static_cast<ev_timer *>(this));	205	ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
193	}	206	}
194	EV_END_WATCHER (timer, timer)	207	EV_END_WATCHER (timer, timer)
195		208
196	#if EV_PERIODICS	209	#if EV_PERIODIC_ENABLE
197	EV_BEGIN_WATCHER (periodic, periodic)	210	EV_BEGIN_WATCHER (periodic, periodic)
198	void set (ev_tstamp at, ev_tstamp interval = 0.)	211	void set (ev_tstamp at, ev_tstamp interval = 0.)
199	{	212	{
200	int active = is_active ();	213	int active = is_active ();
201	if (active) stop ();	214	if (active) stop ();
…		…
212	void again ()	225	void again ()
213	{	226	{
214	ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));	227	ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
215	}	228	}
216	EV_END_WATCHER (periodic, periodic)	229	EV_END_WATCHER (periodic, periodic)
		230	#endif
		231
		232	EV_BEGIN_WATCHER (sig, signal)
		233	void set (int signum)
		234	{
		235	int active = is_active ();
		236	if (active) stop ();
		237	ev_signal_set (static_cast<ev_signal *>(this), signum);
		238	if (active) start ();
		239	}
		240
		241	void start (int signum)
		242	{
		243	set (signum);
		244	start ();
		245	}
		246	EV_END_WATCHER (sig, signal)
		247
		248	EV_BEGIN_WATCHER (child, child)
		249	void set (int pid)
		250	{
		251	int active = is_active ();
		252	if (active) stop ();
		253	ev_child_set (static_cast<ev_child *>(this), pid);
		254	if (active) start ();
		255	}
		256
		257	void start (int pid)
		258	{
		259	set (pid);
		260	start ();
		261	}
		262	EV_END_WATCHER (child, child)
		263
		264	#if EV_STAT_ENABLE
		265	EV_BEGIN_WATCHER (stat, stat)
		266	void set (const char *path, ev_tstamp interval = 0.)
		267	{
		268	int active = is_active ();
		269	if (active) stop ();
		270	ev_stat_set (static_cast<ev_stat *>(this), path, interval);
		271	if (active) start ();
		272	}
		273
		274	void start (const char *path, ev_tstamp interval = 0.)
		275	{
		276	stop ();
		277	set (path, interval);
		278	start ();
		279	}
		280
		281	void update ()
		282	{
		283	ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
		284	}
		285	EV_END_WATCHER (stat, stat)
217	#endif	286	#endif
218		287
219	EV_BEGIN_WATCHER (idle, idle)	288	EV_BEGIN_WATCHER (idle, idle)
220	void set () { }	289	void set () { }
221	EV_END_WATCHER (idle, idle)	290	EV_END_WATCHER (idle, idle)
…		…
226		295
227	EV_BEGIN_WATCHER (check, check)	296	EV_BEGIN_WATCHER (check, check)
228	void set () { }	297	void set () { }
229	EV_END_WATCHER (check, check)	298	EV_END_WATCHER (check, check)
230		299
231	EV_BEGIN_WATCHER (sig, signal)	300	#if EV_EMBED_ENABLE
232	void set (int signum)
233	{
234	int active = is_active ();
235	if (active) stop ();
236	ev_signal_set (static_cast<ev_signal *>(this), signum);
237	if (active) start ();
238	}
239
240	void start (int signum)
241	{
242	set (signum);
243	start ();
244	}
245	EV_END_WATCHER (sig, signal)
246
247	EV_BEGIN_WATCHER (child, child)
248	void set (int pid)
249	{
250	int active = is_active ();
251	if (active) stop ();
252	ev_child_set (static_cast<ev_child *>(this), pid);
253	if (active) start ();
254	}
255
256	void start (int pid)
257	{
258	set (pid);
259	start ();
260	}
261	EV_END_WATCHER (child, child)
262
263	#if EV_MULTIPLICITY
264
265	EV_BEGIN_WATCHER (embed, embed)	301	EV_BEGIN_WATCHER (embed, embed)
266	void set (struct ev_loop *loop)
267	{
268	int active = is_active ();
269	if (active) stop ();
270	ev_embed_set (static_cast<ev_embed *>(this), loop);
271	if (active) start ();
272	}
273
274	void start (struct ev_loop *embedded_loop)	302	void start (struct ev_loop *embedded_loop)
275	{	303	{
276	set (embedded_loop);	304	stop ();
		305	ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
277	start ();	306	start ();
278	}	307	}
279		308
280	void sweep ()	309	void sweep ()
281	{	310	{
282	ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));	311	ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
283	}	312	}
284	EV_END_WATCHER (embed, embed)	313	EV_END_WATCHER (embed, embed)
		314	#endif
285		315
		316	#if EV_FORK_ENABLE
		317	EV_BEGIN_WATCHER (fork, fork)
		318	void set () { }
		319	EV_END_WATCHER (fork, fork)
286	#endif	320	#endif
287		321
288	#undef EV_CONSTRUCT	322	#undef EV_CONSTRUCT
289	#undef EV_BEGIN_WATCHER	323	#undef EV_BEGIN_WATCHER
290	#undef EV_END_WATCHER	324	#undef EV_END_WATCHER

Diff Legend

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

Comparing libev/ev++.h (file contents): Revision 1.7 by root, Sat Nov 24 09:48:37 2007 UTC vs. Revision 1.14 by root, Tue Dec 4 17:08:05 2007 UTC

Diff Legend

Comparing libev/ev++.h (file contents):
Revision 1.7 by root, Sat Nov 24 09:48:37 2007 UTC vs.
Revision 1.14 by root, Tue Dec 4 17:08:05 2007 UTC