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

Comparing libev/ev++.h (file contents):
Revision 1.39 by root, Tue Apr 15 04:34:07 2008 UTC vs.
Revision 1.56 by root, Thu Oct 28 04:55:19 2010 UTC

…		…
1	/*	1	/*
2	* libev simple C++ wrapper classes	2	* libev simple C++ wrapper classes
3	*	3	*
4	* Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>	4	* Copyright (c) 2007,2008,2010 Marc Alexander Lehmann <libev@schmorp.de>
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without modifica-	7	* Redistribution and use in source and binary forms, with or without modifica-
8	* tion, are permitted provided that the following conditions are met:	8	* tion, are permitted provided that the following conditions are met:
9	*	9	*
61	enum {	61	enum {
62	UNDEF = EV_UNDEF,	62	UNDEF = EV_UNDEF,
63	NONE = EV_NONE,	63	NONE = EV_NONE,
64	READ = EV_READ,	64	READ = EV_READ,
65	WRITE = EV_WRITE,	65	WRITE = EV_WRITE,
		66	#if EV_COMPAT3
66	TIMEOUT = EV_TIMEOUT,	67	TIMEOUT = EV_TIMEOUT,
		68	#endif
		69	TIMER = EV_TIMER,
67	PERIODIC = EV_PERIODIC,	70	PERIODIC = EV_PERIODIC,
68	SIGNAL = EV_SIGNAL,	71	SIGNAL = EV_SIGNAL,
69	CHILD = EV_CHILD,	72	CHILD = EV_CHILD,
70	STAT = EV_STAT,	73	STAT = EV_STAT,
71	IDLE = EV_IDLE,	74	IDLE = EV_IDLE,
72	CHECK = EV_CHECK,	75	CHECK = EV_CHECK,
73	PREPARE = EV_PREPARE,	76	PREPARE = EV_PREPARE,
74	FORK = EV_FORK,	77	FORK = EV_FORK,
75	ASYNC = EV_ASYNC,	78	ASYNC = EV_ASYNC,
76	EMBED = EV_EMBED,	79	EMBED = EV_EMBED,
		80	# undef ERROR // some systems stupidly #define ERROR
77	ERROR = EV_ERROR,	81	ERROR = EV_ERROR
78	};	82	};
79		83
80	enum	84	enum
81	{	85	{
82	AUTO = EVFLAG_AUTO,	86	AUTO = EVFLAG_AUTO,
83	NOENV = EVFLAG_NOENV,	87	NOENV = EVFLAG_NOENV,
84	FORKCHECK = EVFLAG_FORKCHECK,	88	FORKCHECK = EVFLAG_FORKCHECK,
		89
85	SELECT = EVBACKEND_SELECT,	90	SELECT = EVBACKEND_SELECT,
86	POLL = EVBACKEND_POLL,	91	POLL = EVBACKEND_POLL,
87	EPOLL = EVBACKEND_EPOLL,	92	EPOLL = EVBACKEND_EPOLL,
88	KQUEUE = EVBACKEND_KQUEUE,	93	KQUEUE = EVBACKEND_KQUEUE,
89	DEVPOLL = EVBACKEND_DEVPOLL,	94	DEVPOLL = EVBACKEND_DEVPOLL,
90	PORT = EVBACKEND_PORT	95	PORT = EVBACKEND_PORT
91	};	96	};
92		97
93	enum	98	enum
94	{	99	{
		100	#if EV_COMPAT3
95	NONBLOCK = EVLOOP_NONBLOCK,	101	NONBLOCK = EVLOOP_NONBLOCK,
96	ONESHOT = EVLOOP_ONESHOT	102	ONESHOT = EVLOOP_ONESHOT,
		103	#endif
		104	NOWAIT = EVRUN_NOWAIT,
		105	ONCE = EVRUN_ONCE
97	};	106	};
98		107
99	enum how_t	108	enum how_t
100	{	109	{
101	ONE = EVUNLOOP_ONE,	110	ONE = EVBREAK_ONE,
102	ALL = EVUNLOOP_ALL	111	ALL = EVBREAK_ALL
103	};	112	};
104		113
105	struct bad_loop	114	struct bad_loop
106	#if EV_USE_STDEXCEPT	115	#if EV_USE_STDEXCEPT
107	: std::runtime_error	116	: std::runtime_error
…		…
157	return false;	166	return false;
158	#endif	167	#endif
159	}	168	}
160		169
161	#if EV_MULTIPLICITY	170	#if EV_MULTIPLICITY
162	bool operator == (struct ev_loop *other) const throw ()	171	bool operator == (const EV_P) const throw ()
163	{	172	{
164	return this->EV_AX == other;	173	return this->EV_AX == EV_A;
165	}
166
167	bool operator != (struct ev_loop *other) const throw ()
168	{	174	}
169	return ! (*this == other);	175
		176	bool operator != (const EV_P) const throw ()
170	}	177	{
171
172	bool operator == (const struct ev_loop *other) const throw ()
173	{
174	return this->EV_AX == other;
175	}
176
177	bool operator != (const struct ev_loop *other) const throw ()
178	{
179	return (*this == other);	178	return (*this == EV_A);
180	}	179	}
181		180
182	operator struct ev_loop * () const throw ()	181	operator struct ev_loop * () const throw ()
183	{	182	{
184	return EV_AX;	183	return EV_AX;
…		…
193	{	192	{
194	return EV_AX == ev_default_loop (0);	193	return EV_AX == ev_default_loop (0);
195	}	194	}
196	#endif	195	#endif
197		196
		197	#if EV_COMPAT3
198	void loop (int flags = 0)	198	void loop (int flags = 0)
199	{	199	{
200	ev_loop (EV_AX_ flags);	200	ev_run (EV_AX_ flags);
201	}	201	}
202		202
203	void unloop (how_t how = ONE) throw ()	203	void unloop (how_t how = ONE) throw ()
204	{	204	{
205	ev_unloop (EV_AX_ how);	205	ev_break (EV_AX_ how);
		206	}
		207	#endif
		208
		209	void run (int flags = 0)
		210	{
		211	ev_run (EV_AX_ flags);
		212	}
		213
		214	void break_loop (how_t how = ONE) throw ()
		215	{
		216	ev_break (EV_AX_ how);
206	}	217	}
207		218
208	void post_fork () throw ()	219	void post_fork () throw ()
209	{	220	{
210	#if EV_MULTIPLICITY
211	ev_loop_fork (EV_AX);	221	ev_loop_fork (EV_AX);
212	#else
213	ev_default_fork ();
214	#endif
215	}
216
217	unsigned int count () const throw ()
218	{
219	return ev_loop_count (EV_AX);
220	}	222	}
221		223
222	unsigned int backend () const throw ()	224	unsigned int backend () const throw ()
223	{	225	{
224	return ev_backend (EV_AX);	226	return ev_backend (EV_AX);
…		…
237	void unref () throw ()	239	void unref () throw ()
238	{	240	{
239	ev_unref (EV_AX);	241	ev_unref (EV_AX);
240	}	242	}
241		243
		244	#if EV_FEATURE_API
		245	unsigned int iteration () const throw ()
		246	{
		247	return ev_iteration (EV_AX);
		248	}
		249
		250	unsigned int depth () const throw ()
		251	{
		252	return ev_depth (EV_AX);
		253	}
		254
242	void set_io_collect_interval (tstamp interval) throw ()	255	void set_io_collect_interval (tstamp interval) throw ()
243	{	256	{
244	ev_set_io_collect_interval (EV_AX_ interval);	257	ev_set_io_collect_interval (EV_AX_ interval);
245	}	258	}
246		259
247	void set_timeout_collect_interval (tstamp interval) throw ()	260	void set_timeout_collect_interval (tstamp interval) throw ()
248	{	261	{
249	ev_set_timeout_collect_interval (EV_AX_ interval);	262	ev_set_timeout_collect_interval (EV_AX_ interval);
250	}	263	}
		264	#endif
251		265
252	// function callback	266	// function callback
253	void once (int fd, int events, tstamp timeout, void (cb)(int, void ), void* arg = 0) throw ()	267	void once (int fd, int events, tstamp timeout, void (cb)(int, void ), void *arg = 0) throw ()
254	{	268	{
255	ev_once (EV_AX_ fd, events, timeout, cb, arg);	269	ev_once (EV_AX_ fd, events, timeout, cb, arg);
256	}	270	}
257		271
258	// method callback	272	// method callback
…		…
260	void once (int fd, int events, tstamp timeout, K *object) throw ()	274	void once (int fd, int events, tstamp timeout, K *object) throw ()
261	{	275	{
262	once (fd, events, timeout, method_thunk<K, method>, object);	276	once (fd, events, timeout, method_thunk<K, method>, object);
263	}	277	}
264		278
		279	// default method == operator ()
		280	template<class K>
		281	void once (int fd, int events, tstamp timeout, K *object) throw ()
		282	{
		283	once (fd, events, timeout, method_thunk<K, &K::operator ()>, object);
		284	}
		285
265	template<class K, void (K::*method)(int)>	286	template<class K, void (K::*method)(int)>
266	static void method_thunk (int revents, void* arg)	287	static void method_thunk (int revents, void *arg)
267	{
268	K obj = static_cast<K >(arg);
269	(obj->*method) (revents);
270	}	288	{
		289	static_cast<K >(arg)->method
		290	(revents);
		291	}
271		292
272	// const method callback	293	// no-argument method callback
273	template<class K, void (K::*method)(int) const>
274	void once (int fd, int events, tstamp timeout, const K *object) throw ()
275	{
276	once (fd, events, timeout, const_method_thunk<K, method>, object);
277	}
278
279	template<class K, void (K::*method)(int) const>
280	static void const_method_thunk (int revents, void* arg)
281	{
282	K obj = static_cast<K >(arg);
283	(obj->*method) (revents);
284	}
285
286	// simple method callback
287	template<class K, void (K::*method)()>	294	template<class K, void (K::*method)()>
288	void once (int fd, int events, tstamp timeout, K *object) throw ()	295	void once (int fd, int events, tstamp timeout, K *object) throw ()
289	{	296	{
290	once (fd, events, timeout, method_noargs_thunk<K, method>, object);	297	once (fd, events, timeout, method_noargs_thunk<K, method>, object);
291	}	298	}
292		299
293	template<class K, void (K::*method)()>	300	template<class K, void (K::*method)()>
294	static void method_noargs_thunk (int revents, void* arg)	301	static void method_noargs_thunk (int revents, void *arg)
295	{	302	{
296	K obj = static_cast<K >(arg);	303	static_cast<K >(arg)->method
297	(obj->*method) ();	304	();
298	}	305	}
299		306
300	// simpler function callback	307	// simpler function callback
301	template<void (*cb)(int)>	308	template<void (*cb)(int)>
302	void once (int fd, int events, tstamp timeout) throw ()	309	void once (int fd, int events, tstamp timeout) throw ()
303	{	310	{
304	once (fd, events, timeout, simpler_func_thunk<cb>);	311	once (fd, events, timeout, simpler_func_thunk<cb>);
305	}	312	}
306		313
307	template<void (*cb)(int)>	314	template<void (*cb)(int)>
308	static void simpler_func_thunk (int revents, void* arg)	315	static void simpler_func_thunk (int revents, void *arg)
309	{	316	{
		317	(*cb)
310	(*cb) (revents);	318	(revents);
311	}	319	}
312		320
313	// simplest function callback	321	// simplest function callback
314	template<void (*cb)()>	322	template<void (*cb)()>
315	void once (int fd, int events, tstamp timeout) throw ()	323	void once (int fd, int events, tstamp timeout) throw ()
316	{	324	{
317	once (fd, events, timeout, simplest_func_thunk<cb>);	325	once (fd, events, timeout, simplest_func_thunk<cb>);
318	}	326	}
319		327
320	template<void (*cb)()>	328	template<void (*cb)()>
321	static void simplest_func_thunk (int revents, void* arg)	329	static void simplest_func_thunk (int revents, void *arg)
322	{	330	{
323	(*cb) ();	331	(*cb)
		332	();
324	}	333	}
325		334
326	void feed_fd_event (int fd, int revents) throw ()	335	void feed_fd_event (int fd, int revents) throw ()
327	{	336	{
328	ev_feed_fd_event (EV_AX_ fd, revents);	337	ev_feed_fd_event (EV_AX_ fd, revents);
…		…
378	#else	387	#else
379	!ev_default_loop (flags)	388	!ev_default_loop (flags)
380	#endif	389	#endif
381	)	390	)
382	throw bad_loop ();	391	throw bad_loop ();
383	}
384
385	~default_loop () throw ()
386	{
387	ev_default_destroy ();
388	}	392	}
389		393
390	private:	394	private:
391	default_loop (const default_loop &);	395	default_loop (const default_loop &);
392	default_loop &operator = (const default_loop &);	396	default_loop &operator = (const default_loop &);
…		…
418	struct base : ev_watcher	422	struct base : ev_watcher
419	{	423	{
420	#if EV_MULTIPLICITY	424	#if EV_MULTIPLICITY
421	EV_PX;	425	EV_PX;
422		426
		427	// loop set
423	void set (EV_PX) throw ()	428	void set (EV_P) throw ()
424	{	429	{
425	this->EV_A = EV_A;	430	this->EV_A = EV_A;
426	}	431	}
427	#endif	432	#endif
428		433
…		…
432	#endif	437	#endif
433	{	438	{
434	ev_init (this, 0);	439	ev_init (this, 0);
435	}	440	}
436		441
437	void set_ (void data, void (cb)(EV_P_ ev_watcher *w, int revents)) throw ()	442	void set_ (const void data, void (cb)(EV_P_ ev_watcher *w, int revents)) throw ()
438	{	443	{
439	this->data = data;	444	this->data = (void *)data;
440	ev_set_cb (static_cast<ev_watcher *>(this), cb);	445	ev_set_cb (static_cast<ev_watcher *>(this), cb);
		446	}
		447
		448	// function callback
		449	template<void (*function)(watcher &w, int)>
		450	void set (void *data = 0) throw ()
		451	{
		452	set_ (data, function_thunk<function>);
		453	}
		454
		455	template<void (*function)(watcher &w, int)>
		456	static void function_thunk (EV_P_ ev_watcher *w, int revents)
		457	{
		458	function
		459	(static_cast<watcher >(w), revents);
441	}	460	}
442		461
443	// method callback	462	// method callback
444	template<class K, void (K::*method)(watcher &w, int)>	463	template<class K, void (K::*method)(watcher &w, int)>
445	void set (K *object) throw ()	464	void set (K *object) throw ()
446	{	465	{
447	set_ (object, method_thunk<K, method>);	466	set_ (object, method_thunk<K, method>);
448	}	467	}
449		468
		469	// default method == operator ()
		470	template<class K>
		471	void set (K *object) throw ()
		472	{
		473	set_ (object, method_thunk<K, &K::operator ()>);
		474	}
		475
450	template<class K, void (K::*method)(watcher &w, int)>	476	template<class K, void (K::*method)(watcher &w, int)>
451	static void method_thunk (EV_P_ ev_watcher *w, int revents)	477	static void method_thunk (EV_P_ ev_watcher *w, int revents)
452	{	478	{
453	K obj = static_cast<K >(w->data);	479	(static_cast<K >(w->data)->method)
454	(obj->method) (static_cast<watcher *>(w), revents);
455	}
456
457	// const method callback
458	template<class K, void (K::*method)(watcher &w, int) const>
459	void set (const K *object) throw ()
460	{
461	set_ (object, const_method_thunk<K, method>);
462	}
463
464	template<class K, void (K::*method)(watcher &w, int) const>
465	static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
466	{
467	K obj = static_cast<K >(w->data);
468	(static_cast<K >(w->data)->method) (static_cast<watcher >(w), revents);
469	}
470
471	// function callback
472	template<void (*function)(watcher &w, int)>
473	void set (void *data = 0) throw ()
474	{
475	set_ (data, function_thunk<function>);
476	}
477
478	template<void (*function)(watcher &w, int)>
479	static void function_thunk (EV_P_ ev_watcher *w, int revents)
480	{
481	function (static_cast<watcher >(w), revents);	480	(static_cast<watcher >(w), revents);
482	}	481	}
483		482
484	// simple callback	483	// no-argument callback
485	template<class K, void (K::*method)()>	484	template<class K, void (K::*method)()>
486	void set (K *object) throw ()	485	void set (K *object) throw ()
487	{	486	{
488	set_ (object, method_noargs_thunk<K, method>);	487	set_ (object, method_noargs_thunk<K, method>);
489	}	488	}
490		489
491	template<class K, void (K::*method)()>	490	template<class K, void (K::*method)()>
492	static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)	491	static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
493	{	492	{
494	K obj = static_cast<K >(w->data);	493	(static_cast<K >(w->data)->method)
495	(obj->*method) ();	494	();
496	}	495	}
497		496
498	void operator ()(int events = EV_UNDEF)	497	void operator ()(int events = EV_UNDEF)
499	{	498	{
		499	return
500	return ev_cb (static_cast<ev_watcher *>(this))	500	ev_cb (static_cast<ev_watcher *>(this))
501	(static_cast<ev_watcher *>(this), events);	501	(static_cast<ev_watcher *>(this), events);
502	}	502	}
503		503
504	bool is_active () const throw ()	504	bool is_active () const throw ()
505	{	505	{
506	return ev_is_active (static_cast<const ev_watcher *>(this));	506	return ev_is_active (static_cast<const ev_watcher *>(this));
…		…
652		652
653	void again () throw ()	653	void again () throw ()
654	{	654	{
655	ev_timer_again (EV_A_ static_cast<ev_timer *>(this));	655	ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
656	}	656	}
		657
		658	ev_tstamp remaining ()
		659	{
		660	return ev_timer_remaining (EV_A_ static_cast<ev_timer *>(this));
		661	}
657	EV_END_WATCHER (timer, timer)	662	EV_END_WATCHER (timer, timer)
658		663
659	#if EV_PERIODIC_ENABLE	664	#if EV_PERIODIC_ENABLE
660	EV_BEGIN_WATCHER (periodic, periodic)	665	EV_BEGIN_WATCHER (periodic, periodic)
661	void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()	666	void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()
…		…
677	ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));	682	ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
678	}	683	}
679	EV_END_WATCHER (periodic, periodic)	684	EV_END_WATCHER (periodic, periodic)
680	#endif	685	#endif
681		686
		687	#if EV_SIGNAL_ENABLE
682	EV_BEGIN_WATCHER (sig, signal)	688	EV_BEGIN_WATCHER (sig, signal)
683	void set (int signum) throw ()	689	void set (int signum) throw ()
684	{	690	{
685	int active = is_active ();	691	int active = is_active ();
686	if (active) stop ();	692	if (active) stop ();
…		…
692	{	698	{
693	set (signum);	699	set (signum);
694	start ();	700	start ();
695	}	701	}
696	EV_END_WATCHER (sig, signal)	702	EV_END_WATCHER (sig, signal)
		703	#endif
697		704
		705	#if EV_CHILD_ENABLE
698	EV_BEGIN_WATCHER (child, child)	706	EV_BEGIN_WATCHER (child, child)
699	void set (int pid, int trace = 0) throw ()	707	void set (int pid, int trace = 0) throw ()
700	{	708	{
701	int active = is_active ();	709	int active = is_active ();
702	if (active) stop ();	710	if (active) stop ();
…		…
708	{	716	{
709	set (pid, trace);	717	set (pid, trace);
710	start ();	718	start ();
711	}	719	}
712	EV_END_WATCHER (child, child)	720	EV_END_WATCHER (child, child)
		721	#endif
713		722
714	#if EV_STAT_ENABLE	723	#if EV_STAT_ENABLE
715	EV_BEGIN_WATCHER (stat, stat)	724	EV_BEGIN_WATCHER (stat, stat)
716	void set (const char *path, ev_tstamp interval = 0.) throw ()	725	void set (const char *path, ev_tstamp interval = 0.) throw ()
717	{	726	{
…		…
733	ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));	742	ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
734	}	743	}
735	EV_END_WATCHER (stat, stat)	744	EV_END_WATCHER (stat, stat)
736	#endif	745	#endif
737		746
		747	#if EV_IDLE_ENABLE
738	EV_BEGIN_WATCHER (idle, idle)	748	EV_BEGIN_WATCHER (idle, idle)
739	void set () throw () { }	749	void set () throw () { }
740	EV_END_WATCHER (idle, idle)	750	EV_END_WATCHER (idle, idle)
		751	#endif
741		752
		753	#if EV_PREPARE_ENABLE
742	EV_BEGIN_WATCHER (prepare, prepare)	754	EV_BEGIN_WATCHER (prepare, prepare)
743	void set () throw () { }	755	void set () throw () { }
744	EV_END_WATCHER (prepare, prepare)	756	EV_END_WATCHER (prepare, prepare)
		757	#endif
745		758
		759	#if EV_CHECK_ENABLE
746	EV_BEGIN_WATCHER (check, check)	760	EV_BEGIN_WATCHER (check, check)
747	void set () throw () { }	761	void set () throw () { }
748	EV_END_WATCHER (check, check)	762	EV_END_WATCHER (check, check)
		763	#endif
749		764
750	#if EV_EMBED_ENABLE	765	#if EV_EMBED_ENABLE
751	EV_BEGIN_WATCHER (embed, embed)	766	EV_BEGIN_WATCHER (embed, embed)
752	void set (struct ev_loop *embedded_loop) throw ()	767	void set (struct ev_loop *embedded_loop) throw ()
753	{	768	{
…		…
776	EV_END_WATCHER (fork, fork)	791	EV_END_WATCHER (fork, fork)
777	#endif	792	#endif
778		793
779	#if EV_ASYNC_ENABLE	794	#if EV_ASYNC_ENABLE
780	EV_BEGIN_WATCHER (async, async)	795	EV_BEGIN_WATCHER (async, async)
781	void set () throw () { }
782
783	void send () throw ()	796	void send () throw ()
784	{	797	{
785	ev_async_send (EV_A_ static_cast<ev_async *>(this));	798	ev_async_send (EV_A_ static_cast<ev_async *>(this));
786	}	799	}
787		800

Diff Legend

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

Comparing libev/ev++.h (file contents): Revision 1.39 by root, Tue Apr 15 04:34:07 2008 UTC vs. Revision 1.56 by root, Thu Oct 28 04:55:19 2010 UTC

Diff Legend

Comparing libev/ev++.h (file contents):
Revision 1.39 by root, Tue Apr 15 04:34:07 2008 UTC vs.
Revision 1.56 by root, Thu Oct 28 04:55:19 2010 UTC