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

Comparing libev/ev++.h (file contents):
Revision 1.29 by llucax, Fri Jan 18 18:15:01 2008 UTC vs.
Revision 1.54 by root, Fri Oct 22 05:57:55 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	*
44	# include EV_H	44	# include EV_H
45	#else	45	#else
46	# include "ev.h"	46	# include "ev.h"
47	#endif	47	#endif
48		48
		49	#ifndef EV_USE_STDEXCEPT
		50	# define EV_USE_STDEXCEPT 1
		51	#endif
		52
		53	#if EV_USE_STDEXCEPT
		54	# include <stdexcept>
		55	#endif
		56
49	namespace ev {	57	namespace ev {
50		58
51	typedef ev_tstamp tstamp;	59	typedef ev_tstamp tstamp;
52		60
53	enum {	61	enum
		62	{
54	UNDEF = EV_UNDEF,	63	UNDEF = EV_UNDEF,
55	NONE = EV_NONE,	64	NONE = EV_NONE,
56	READ = EV_READ,	65	READ = EV_READ,
57	WRITE = EV_WRITE,	66	WRITE = EV_WRITE,
		67	#if EV_COMPAT3
58	TIMEOUT = EV_TIMEOUT,	68	TIMEOUT = EV_TIMEOUT,
		69	#endif
		70	TIMER = EV_TIMER,
59	PERIODIC = EV_PERIODIC,	71	PERIODIC = EV_PERIODIC,
60	SIGNAL = EV_SIGNAL,	72	SIGNAL = EV_SIGNAL,
61	CHILD = EV_CHILD,	73	CHILD = EV_CHILD,
62	STAT = EV_STAT,	74	STAT = EV_STAT,
63	IDLE = EV_IDLE,	75	IDLE = EV_IDLE,
64	CHECK = EV_CHECK,	76	CHECK = EV_CHECK,
65	PREPARE = EV_PREPARE,	77	PREPARE = EV_PREPARE,
66	FORK = EV_FORK,	78	FORK = EV_FORK,
		79	ASYNC = EV_ASYNC,
67	EMBED = EV_EMBED,	80	EMBED = EV_EMBED,
		81	# undef ERROR // some systems stupidly #define ERROR
68	ERROR = EV_ERROR,	82	ERROR = EV_ERROR
69	};	83	};
70		84
71	enum	85	enum
72	{	86	{
73	AUTO = EVFLAG_AUTO,	87	AUTO = EVFLAG_AUTO,
74	NOENV = EVFLAG_NOENV,	88	NOENV = EVFLAG_NOENV,
75	FORKCHECK = EVFLAG_FORKCHECK,	89	FORKCHECK = EVFLAG_FORKCHECK,
		90
76	SELECT = EVBACKEND_SELECT,	91	SELECT = EVBACKEND_SELECT,
77	POLL = EVBACKEND_POLL,	92	POLL = EVBACKEND_POLL,
78	EPOLL = EVBACKEND_EPOLL,	93	EPOLL = EVBACKEND_EPOLL,
79	KQUEUE = EVBACKEND_KQUEUE,	94	KQUEUE = EVBACKEND_KQUEUE,
80	DEVPOLL = EVBACKEND_DEVPOLL,	95	DEVPOLL = EVBACKEND_DEVPOLL,
81	PORT = EVBACKEND_PORT	96	PORT = EVBACKEND_PORT
82	};	97	};
83		98
84	enum	99	enum
85	{	100	{
		101	#if EV_COMPAT3
86	NONBLOCK = EVLOOP_NONBLOCK,	102	NONBLOCK = EVLOOP_NONBLOCK,
87	ONESHOT = EVLOOP_ONESHOT	103	ONESHOT = EVLOOP_ONESHOT,
		104	#endif
		105	NOWAIT = EVRUN_NOWAIT,
		106	ONCE = EVRUN_ONCE
88	};	107	};
89		108
90	enum how_t	109	enum how_t
91	{	110	{
92	ONE = EVUNLOOP_ONE,	111	ONE = EVBREAK_ONE,
93	ALL = EVUNLOOP_ALL	112	ALL = EVBREAK_ALL
		113	};
		114
		115	struct bad_loop
		116	#if EV_USE_STDEXCEPT
		117	: std::runtime_error
		118	#endif
		119	{
		120	#if EV_USE_STDEXCEPT
		121	bad_loop ()
		122	: std::runtime_error ("libev event loop cannot be initialized, bad value of LIBEV_FLAGS?")
		123	{
		124	}
		125	#endif
94	};	126	};
95		127
96	#ifdef EV_AX	128	#ifdef EV_AX
97	# undef EV_AX	129	# undef EV_AX
98	#endif	130	#endif
…		…
109	# define EV_AX_	141	# define EV_AX_
110	#endif	142	#endif
111		143
112	struct loop_ref	144	struct loop_ref
113	{	145	{
114
115	loop_ref (EV_P)	146	loop_ref (EV_P) throw ()
116	#if EV_MULTIPLICITY	147	#if EV_MULTIPLICITY
117	: EV_AX (EV_A)	148	: EV_AX (EV_A)
118	#endif	149	#endif
119	{
120	}	150	{
		151	}
121		152
122	bool operator== (const loop_ref &other) const	153	bool operator == (const loop_ref &other) const throw ()
123	{	154	{
124	#if EV_MULTIPLICITY	155	#if EV_MULTIPLICITY
125	return this->EV_AX == other.EV_AX;	156	return EV_AX == other.EV_AX;
126	#else	157	#else
127	return true;	158	return true;
128	#endif	159	#endif
129	}	160	}
130		161
131	bool operator!= (const loop_ref &other) const	162	bool operator != (const loop_ref &other) const throw ()
132	{	163	{
133	#if EV_MULTIPLICITY	164	#if EV_MULTIPLICITY
134	return ! (*this == other);	165	return ! (*this == other);
135	#else	166	#else
136	return false;	167	return false;
137	#endif	168	#endif
138	}	169	}
139		170
140	#if EV_MULTIPLICITY	171	#if EV_MULTIPLICITY
141	bool operator== (struct ev_loop *other) const	172	bool operator == (const EV_P) const throw ()
142	{	173	{
143	return this->EV_AX == other;	174	return this->EV_AX == EV_A;
144	}
145
146	bool operator!= (struct ev_loop *other) const
147	{	175	}
148	return ! (*this == other);	176
		177	bool operator != (const EV_P) const throw ()
149	}	178	{
150
151	bool operator== (const struct ev_loop *other) const
152	{
153	return this->EV_AX == other;
154	}
155
156	bool operator!= (const struct ev_loop *other) const
157	{
158	return (*this == other);	179	return (*this == EV_A);
159	}	180	}
160		181
161	operator struct ev_loop * () const	182	operator struct ev_loop * () const throw ()
162	{	183	{
163	return EV_AX;	184	return EV_AX;
164	}	185	}
165		186
166	operator const struct ev_loop * () const	187	operator const struct ev_loop * () const throw ()
167	{	188	{
168	return EV_AX;	189	return EV_AX;
169	}	190	}
170		191
171	bool is_default () const	192	bool is_default () const throw ()
172	{	193	{
173	return EV_AX == ev_default_loop (0);	194	return EV_AX == ev_default_loop (0);
174	}	195	}
175	#endif	196	#endif
176		197
		198	#if EV_COMPAT3
177	void loop (int flags = 0)	199	void loop (int flags = 0)
178	{	200	{
179	ev_loop (EV_AX_ flags);	201	ev_run (EV_AX_ flags);
180	}	202	}
181		203
182	void unloop (how_t how = ONE)	204	void unloop (how_t how = ONE) throw ()
183	{	205	{
184	ev_unloop (EV_AX_ how);	206	ev_break (EV_AX_ how);
		207	}
		208	#endif
		209
		210	void run (int flags = 0)
185	}	211	{
		212	ev_run (EV_AX_ flags);
		213	}
186		214
		215	void break_loop (how_t how = ONE) throw ()
		216	{
		217	ev_break (EV_AX_ how);
		218	}
		219
187	void post_fork ()	220	void post_fork () throw ()
188	{	221	{
189	#if EV_MULTIPLICITY	222	#if EV_MULTIPLICITY
190	ev_loop_fork (EV_AX);	223	ev_loop_fork (EV_AX);
191	#else	224	#else
192	ev_default_fork ();	225	ev_default_fork ();
193	#endif	226	#endif
194	}	227	}
195		228
196	unsigned int count () const
197	{
198	return ev_loop_count (EV_AX);
199	}
200
201	unsigned int backend () const	229	unsigned int backend () const throw ()
202	{	230	{
203	return ev_backend (EV_AX);	231	return ev_backend (EV_AX);
204	}	232	}
205		233
206	tstamp now () const	234	tstamp now () const throw ()
207	{	235	{
208	return ev_now (EV_AX);	236	return ev_now (EV_AX);
209	}	237	}
210		238
211	void ref ()	239	void ref () throw ()
212	{	240	{
213	ev_ref (EV_AX);	241	ev_ref (EV_AX);
214	}	242	}
215		243
216	void unref ()	244	void unref () throw ()
217	{	245	{
218	ev_unref (EV_AX);	246	ev_unref (EV_AX);
219	}	247	}
220		248
		249	#if EV_FEATURE_API
		250	unsigned int iteration () const throw ()
		251	{
		252	return ev_iteration (EV_AX);
		253	}
		254
		255	unsigned int depth () const throw ()
		256	{
		257	return ev_depth (EV_AX);
		258	}
		259
221	void set_io_collect_interval (tstamp interval)	260	void set_io_collect_interval (tstamp interval) throw ()
222	{	261	{
223	ev_set_io_collect_interval (EV_AX_ interval);	262	ev_set_io_collect_interval (EV_AX_ interval);
224	}	263	}
225		264
226	void set_timeout_collect_interval (tstamp interval)	265	void set_timeout_collect_interval (tstamp interval) throw ()
227	{	266	{
228	ev_set_timeout_collect_interval (EV_AX_ interval);	267	ev_set_timeout_collect_interval (EV_AX_ interval);
229	}	268	}
		269	#endif
230		270
231	// function callback	271	// function callback
232	void once (int fd, int events, tstamp timeout, void (cb)(int, void ), void* arg = 0)	272	void once (int fd, int events, tstamp timeout, void (cb)(int, void ), void *arg = 0) throw ()
233	{	273	{
234	ev_once (EV_AX_ fd, events, timeout, cb, arg);	274	ev_once (EV_AX_ fd, events, timeout, cb, arg);
235	}	275	}
236		276
237	// method callback	277	// method callback
238	template<class K, void (K::*method)(int)>	278	template<class K, void (K::*method)(int)>
239	void once (int fd, int events, tstamp timeout, K *object)	279	void once (int fd, int events, tstamp timeout, K *object) throw ()
240	{	280	{
241	once (fd, events, timeout, method_thunk<K, method>, object);	281	once (fd, events, timeout, method_thunk<K, method>, object);
242	}	282	}
243		283
		284	// default method == operator ()
		285	template<class K>
		286	void once (int fd, int events, tstamp timeout, K *object) throw ()
		287	{
		288	once (fd, events, timeout, method_thunk<K, &K::operator ()>, object);
		289	}
		290
244	template<class K, void (K::*method)(int)>	291	template<class K, void (K::*method)(int)>
245	static void method_thunk (int revents, void* arg)	292	static void method_thunk (int revents, void *arg)
246	{
247	K obj = static_cast<K >(arg);
248	(obj->*method) (revents);
249	}	293	{
		294	static_cast<K >(arg)->method
		295	(revents);
		296	}
250		297
251	// const method callback	298	// no-argument method callback
252	template<class K, void (K::*method)(int) const>
253	void once (int fd, int events, tstamp timeout, const K *object)
254	{
255	once (fd, events, timeout, const_method_thunk<K, method>, object);
256	}
257
258	template<class K, void (K::*method)(int) const>
259	static void const_method_thunk (int revents, void* arg)
260	{
261	K obj = static_cast<K >(arg);
262	(obj->*method) (revents);
263	}
264
265	// simple method callback
266	template<class K, void (K::*method)()>	299	template<class K, void (K::*method)()>
267	void once (int fd, int events, tstamp timeout, K *object)	300	void once (int fd, int events, tstamp timeout, K *object) throw ()
268	{	301	{
269	once (fd, events, timeout, method_noargs_thunk<K, method>, object);	302	once (fd, events, timeout, method_noargs_thunk<K, method>, object);
270	}	303	}
271		304
272	template<class K, void (K::*method)()>	305	template<class K, void (K::*method)()>
273	static void method_noargs_thunk (int revents, void* arg)	306	static void method_noargs_thunk (int revents, void *arg)
274	{	307	{
275	K obj = static_cast<K >(arg);	308	static_cast<K >(arg)->method
276	(obj->*method) ();	309	();
277	}	310	}
278		311
279	// simpler function callback	312	// simpler function callback
280	template<void (*cb)(int)>	313	template<void (*cb)(int)>
281	void once (int fd, int events, tstamp timeout)	314	void once (int fd, int events, tstamp timeout) throw ()
282	{	315	{
283	once (fd, events, timeout, simpler_func_thunk<cb>);	316	once (fd, events, timeout, simpler_func_thunk<cb>);
284	}	317	}
285		318
286	template<void (*cb)(int)>	319	template<void (*cb)(int)>
287	static void simpler_func_thunk (int revents, void* arg)	320	static void simpler_func_thunk (int revents, void *arg)
288	{	321	{
		322	(*cb)
289	(*cb) (revents);	323	(revents);
290	}	324	}
291		325
292	// simplest function callback	326	// simplest function callback
293	template<void (*cb)()>	327	template<void (*cb)()>
294	void once (int fd, int events, tstamp timeout)	328	void once (int fd, int events, tstamp timeout) throw ()
295	{	329	{
296	once (fd, events, timeout, simplest_func_thunk<cb>);	330	once (fd, events, timeout, simplest_func_thunk<cb>);
297	}	331	}
298		332
299	template<void (*cb)()>	333	template<void (*cb)()>
300	static void simplest_func_thunk (int revents, void* arg)	334	static void simplest_func_thunk (int revents, void *arg)
301	{	335	{
302	(*cb) ();	336	(*cb)
		337	();
303	}	338	}
304		339
305	void feed_fd_event (int fd, int revents)	340	void feed_fd_event (int fd, int revents) throw ()
306	{	341	{
307	ev_feed_fd_event (EV_AX_ fd, revents);	342	ev_feed_fd_event (EV_AX_ fd, revents);
308	}	343	}
309		344
310	void feed_signal_event (int signum)	345	void feed_signal_event (int signum) throw ()
311	{	346	{
312	ev_feed_signal_event (EV_AX_ signum);	347	ev_feed_signal_event (EV_AX_ signum);
313	}	348	}
314		349
315	#if EV_MULTIPLICITY	350	#if EV_MULTIPLICITY
…		…
317	#endif	352	#endif
318		353
319	};	354	};
320		355
321	#if EV_MULTIPLICITY	356	#if EV_MULTIPLICITY
322	struct dynamic_loop: loop_ref	357	struct dynamic_loop : loop_ref
323	{	358	{
324		359
325	dynamic_loop (unsigned int flags = AUTO)	360	dynamic_loop (unsigned int flags = AUTO) throw (bad_loop)
326	: loop_ref (ev_loop_new (flags))	361	: loop_ref (ev_loop_new (flags))
327	{
328	}	362	{
		363	if (!EV_AX)
		364	throw bad_loop ();
		365	}
329		366
330	~dynamic_loop ()	367	~dynamic_loop () throw ()
331	{	368	{
332	ev_loop_destroy (EV_AX);	369	ev_loop_destroy (EV_AX);
333	EV_AX = 0;	370	EV_AX = 0;
334	}	371	}
335		372
…		…
340	dynamic_loop & operator= (const dynamic_loop &);	377	dynamic_loop & operator= (const dynamic_loop &);
341		378
342	};	379	};
343	#endif	380	#endif
344		381
345	struct default_loop: loop_ref	382	struct default_loop : loop_ref
346	{	383	{
347
348	default_loop (unsigned int flags = AUTO)	384	default_loop (unsigned int flags = AUTO) throw (bad_loop)
349	#if EV_MULTIPLICITY	385	#if EV_MULTIPLICITY
350	: loop_ref (ev_default_loop (flags))	386	: loop_ref (ev_default_loop (flags))
351	{	387	#endif
352	}	388	{
		389	if (
		390	#if EV_MULTIPLICITY
		391	!EV_AX
353	#else	392	#else
354	{
355	ev_default_loop (flags);	393	!ev_default_loop (flags)
356	}
357	#endif	394	#endif
		395	)
		396	throw bad_loop ();
		397	}
358		398
359	~default_loop ()	399	~default_loop () throw ()
360	{	400	{
361	ev_default_destroy ();	401	ev_default_destroy ();
362	#if EV_MULTIPLICITY
363	EV_AX = 0;
364	#endif
365	}	402	}
366		403
367	private:	404	private:
368
369	default_loop (const default_loop &);	405	default_loop (const default_loop &);
370
371	default_loop & operator= (const default_loop &);	406	default_loop &operator = (const default_loop &);
372
373	};	407	};
374		408
375	inline loop_ref get_default_loop ()	409	inline loop_ref get_default_loop () throw ()
376	{	410	{
377	#if EV_MULTIPLICITY	411	#if EV_MULTIPLICITY
378	return ev_default_loop (0);	412	return ev_default_loop (0);
379	#else	413	#else
380	return loop_ref ();	414	return loop_ref ();
…		…
398	struct base : ev_watcher	432	struct base : ev_watcher
399	{	433	{
400	#if EV_MULTIPLICITY	434	#if EV_MULTIPLICITY
401	EV_PX;	435	EV_PX;
402		436
		437	// loop set
403	void set (EV_PX)	438	void set (EV_P) throw ()
404	{	439	{
405	this->EV_A = EV_A;	440	this->EV_A = EV_A;
406	}	441	}
407	#endif	442	#endif
408		443
409	base (EV_PX)	444	base (EV_PX) throw ()
410	#if EV_MULTIPLICITY	445	#if EV_MULTIPLICITY
411	: EV_A (EV_A)	446	: EV_A (EV_A)
412	#endif	447	#endif
413	{	448	{
414	ev_init (this, 0);	449	ev_init (this, 0);
415	}	450	}
416		451
417	void set_ (void data, void (cb)(EV_P_ ev_watcher *w, int revents))	452	void set_ (const void data, void (cb)(EV_P_ ev_watcher *w, int revents)) throw ()
418	{	453	{
419	this->data = data;	454	this->data = (void *)data;
420	ev_set_cb (static_cast<ev_watcher *>(this), cb);	455	ev_set_cb (static_cast<ev_watcher *>(this), cb);
		456	}
		457
		458	// function callback
		459	template<void (*function)(watcher &w, int)>
		460	void set (void *data = 0) throw ()
		461	{
		462	set_ (data, function_thunk<function>);
		463	}
		464
		465	template<void (*function)(watcher &w, int)>
		466	static void function_thunk (EV_P_ ev_watcher *w, int revents)
		467	{
		468	function
		469	(static_cast<watcher >(w), revents);
421	}	470	}
422		471
423	// method callback	472	// method callback
424	template<class K, void (K::*method)(watcher &w, int)>	473	template<class K, void (K::*method)(watcher &w, int)>
425	void set (K *object)	474	void set (K *object) throw ()
426	{	475	{
427	set_ (object, method_thunk<K, method>);	476	set_ (object, method_thunk<K, method>);
		477	}
		478
		479	// default method == operator ()
		480	template<class K>
		481	void set (K *object) throw ()
		482	{
		483	set_ (object, method_thunk<K, &K::operator ()>);
428	}	484	}
429		485
430	template<class K, void (K::*method)(watcher &w, int)>	486	template<class K, void (K::*method)(watcher &w, int)>
431	static void method_thunk (EV_P_ ev_watcher *w, int revents)	487	static void method_thunk (EV_P_ ev_watcher *w, int revents)
432	{	488	{
433	K obj = static_cast<K >(w->data);	489	(static_cast<K >(w->data)->method)
434	(obj->method) (static_cast<watcher *>(w), revents);
435	}
436
437	// const method callback
438	template<class K, void (K::*method)(watcher &w, int) const>
439	void set (const K *object)
440	{
441	set_ (object, const_method_thunk<K, method>);
442	}
443
444	template<class K, void (K::*method)(watcher &w, int) const>
445	static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
446	{
447	K obj = static_cast<K >(w->data);
448	(static_cast<K >(w->data)->method) (static_cast<watcher >(w), revents);
449	}
450
451	// function callback
452	template<void (*function)(watcher &w, int)>
453	void set (void *data = 0)
454	{
455	set_ (data, function_thunk<function>);
456	}
457
458	template<void (*function)(watcher &w, int)>
459	static void function_thunk (EV_P_ ev_watcher *w, int revents)
460	{
461	function (static_cast<watcher >(w), revents);	490	(static_cast<watcher >(w), revents);
462	}	491	}
463		492
464	// simple callback	493	// no-argument callback
465	template<class K, void (K::*method)()>	494	template<class K, void (K::*method)()>
466	void set (K *object)	495	void set (K *object) throw ()
467	{	496	{
468	set_ (object, method_noargs_thunk<K, method>);	497	set_ (object, method_noargs_thunk<K, method>);
469	}	498	}
470		499
471	template<class K, void (K::*method)()>	500	template<class K, void (K::*method)()>
472	static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)	501	static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
473	{	502	{
474	K obj = static_cast<K >(w->data);	503	(static_cast<K >(w->data)->method)
475	(obj->*method) ();	504	();
476	}	505	}
477		506
478	void operator ()(int events = EV_UNDEF)	507	void operator ()(int events = EV_UNDEF)
479	{	508	{
		509	return
480	return ev_cb (static_cast<ev_watcher *>(this))	510	ev_cb (static_cast<ev_watcher *>(this))
481	(static_cast<ev_watcher *>(this), events);	511	(static_cast<ev_watcher *>(this), events);
482	}	512	}
483		513
484	bool is_active () const	514	bool is_active () const throw ()
485	{	515	{
486	return ev_is_active (static_cast<const ev_watcher *>(this));	516	return ev_is_active (static_cast<const ev_watcher *>(this));
487	}	517	}
488		518
489	bool is_pending () const	519	bool is_pending () const throw ()
490	{	520	{
491	return ev_is_pending (static_cast<const ev_watcher *>(this));	521	return ev_is_pending (static_cast<const ev_watcher *>(this));
492	}	522	}
493		523
494	void feed_event (int revents)	524	void feed_event (int revents) throw ()
495	{	525	{
496	ev_feed_event (EV_A_ static_cast<const ev_watcher *>(this), revents);	526	ev_feed_event (EV_A_ static_cast<const ev_watcher *>(this), revents);
497	}	527	}
498	};	528	};
499		529
500	inline tstamp now ()	530	inline tstamp now () throw ()
501	{	531	{
502	return ev_time ();	532	return ev_time ();
503	}	533	}
504		534
505	inline void delay (tstamp interval)	535	inline void delay (tstamp interval) throw ()
506	{	536	{
507	ev_sleep (interval);	537	ev_sleep (interval);
508	}	538	}
509		539
510	inline int version_major ()	540	inline int version_major () throw ()
511	{	541	{
512	return ev_version_major ();	542	return ev_version_major ();
513	}	543	}
514		544
515	inline int version_minor ()	545	inline int version_minor () throw ()
516	{	546	{
517	return ev_version_minor ();	547	return ev_version_minor ();
518	}	548	}
519		549
520	inline unsigned int supported_backends ()	550	inline unsigned int supported_backends () throw ()
521	{	551	{
522	return ev_supported_backends ();	552	return ev_supported_backends ();
523	}	553	}
524		554
525	inline unsigned int recommended_backends ()	555	inline unsigned int recommended_backends () throw ()
526	{	556	{
527	return ev_recommended_backends ();	557	return ev_recommended_backends ();
528	}	558	}
529		559
530	inline unsigned int embeddable_backends ()	560	inline unsigned int embeddable_backends () throw ()
531	{	561	{
532	return ev_embeddable_backends ();	562	return ev_embeddable_backends ();
533	}	563	}
534		564
535	inline void set_allocator (void (cb)(void *ptr, long size))	565	inline void set_allocator (void (cb)(void *ptr, long size)) throw ()
536	{	566	{
537	ev_set_allocator (cb);	567	ev_set_allocator (cb);
538	}	568	}
539		569
540	inline void set_syserr_cb (void (cb)(const char msg))	570	inline void set_syserr_cb (void (cb)(const char msg)) throw ()
541	{	571	{
542	ev_set_syserr_cb (cb);	572	ev_set_syserr_cb (cb);
543	}	573	}
544		574
545	#if EV_MULTIPLICITY	575	#if EV_MULTIPLICITY
546	#define EV_CONSTRUCT(cppstem,cstem) \	576	#define EV_CONSTRUCT(cppstem,cstem) \
547	(EV_PX = get_default_loop ()) \	577	(EV_PX = get_default_loop ()) throw () \
548	: base<ev_ ## cstem, cppstem> (EV_A) \	578	: base<ev_ ## cstem, cppstem> (EV_A) \
549	{ \	579	{ \
550	}	580	}
551	#else	581	#else
552	#define EV_CONSTRUCT(cppstem,cstem) \	582	#define EV_CONSTRUCT(cppstem,cstem) \
553	() \	583	() throw () \
554	{ \	584	{ \
555	}	585	}
556	#endif	586	#endif
557		587
558	/* using a template here would require quite a bit more lines,	588	/* using a template here would require quite a bit more lines,
559	* so a macro solution was chosen */	589	* so a macro solution was chosen */
560	#define EV_BEGIN_WATCHER(cppstem,cstem) \	590	#define EV_BEGIN_WATCHER(cppstem,cstem) \
561	\	591	\
562	struct cppstem : base<ev_ ## cstem, cppstem> \	592	struct cppstem : base<ev_ ## cstem, cppstem> \
563	{ \	593	{ \
564	void start () \	594	void start () throw () \
565	{ \	595	{ \
566	ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this)); \	596	ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this)); \
567	} \	597	} \
568	\	598	\
569	void stop () \	599	void stop () throw () \
570	{ \	600	{ \
571	ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this)); \	601	ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this)); \
572	} \	602	} \
573	\	603	\
574	cppstem EV_CONSTRUCT(cppstem,cstem) \	604	cppstem EV_CONSTRUCT(cppstem,cstem) \
575	\	605	\
576	~cppstem () \	606	~cppstem () throw () \
577	{ \	607	{ \
578	stop (); \	608	stop (); \
579	} \	609	} \
580	\	610	\
581	using base<ev_ ## cstem, cppstem>::set; \	611	using base<ev_ ## cstem, cppstem>::set; \
582	\	612	\
583	private: \	613	private: \
584	\	614	\
585	cppstem (const cppstem &o); \	615	cppstem (const cppstem &o); \
586	\	616	\
587	cppstem & operator =(const cppstem &o); \	617	cppstem &operator =(const cppstem &o); \
588	\	618	\
589	public:	619	public:
590		620
591	#define EV_END_WATCHER(cppstem,cstem) \	621	#define EV_END_WATCHER(cppstem,cstem) \
592	};	622	};
593		623
594	EV_BEGIN_WATCHER (io, io)	624	EV_BEGIN_WATCHER (io, io)
595	void set (int fd, int events)	625	void set (int fd, int events) throw ()
596	{	626	{
597	int active = is_active ();	627	int active = is_active ();
598	if (active) stop ();	628	if (active) stop ();
599	ev_io_set (static_cast<ev_io *>(this), fd, events);	629	ev_io_set (static_cast<ev_io *>(this), fd, events);
600	if (active) start ();	630	if (active) start ();
601	}	631	}
602		632
603	void set (int events)	633	void set (int events) throw ()
604	{	634	{
605	int active = is_active ();	635	int active = is_active ();
606	if (active) stop ();	636	if (active) stop ();
607	ev_io_set (static_cast<ev_io *>(this), fd, events);	637	ev_io_set (static_cast<ev_io *>(this), fd, events);
608	if (active) start ();	638	if (active) start ();
609	}	639	}
610		640
611	void start (int fd, int events)	641	void start (int fd, int events) throw ()
612	{	642	{
613	set (fd, events);	643	set (fd, events);
614	start ();	644	start ();
615	}	645	}
616	EV_END_WATCHER (io, io)	646	EV_END_WATCHER (io, io)
617		647
618	EV_BEGIN_WATCHER (timer, timer)	648	EV_BEGIN_WATCHER (timer, timer)
619	void set (ev_tstamp after, ev_tstamp repeat = 0.)	649	void set (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
620	{	650	{
621	int active = is_active ();	651	int active = is_active ();
622	if (active) stop ();	652	if (active) stop ();
623	ev_timer_set (static_cast<ev_timer *>(this), after, repeat);	653	ev_timer_set (static_cast<ev_timer *>(this), after, repeat);
624	if (active) start ();	654	if (active) start ();
625	}	655	}
626		656
627	void start (ev_tstamp after, ev_tstamp repeat = 0.)	657	void start (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
628	{	658	{
629	set (after, repeat);	659	set (after, repeat);
630	start ();	660	start ();
631	}	661	}
632		662
633	void again ()	663	void again () throw ()
634	{	664	{
635	ev_timer_again (EV_A_ static_cast<ev_timer *>(this));	665	ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
		666	}
		667
		668	ev_tstamp remaining ()
		669	{
		670	return ev_timer_remaining (EV_A_ static_cast<ev_timer *>(this));
636	}	671	}
637	EV_END_WATCHER (timer, timer)	672	EV_END_WATCHER (timer, timer)
638		673
639	#if EV_PERIODIC_ENABLE	674	#if EV_PERIODIC_ENABLE
640	EV_BEGIN_WATCHER (periodic, periodic)	675	EV_BEGIN_WATCHER (periodic, periodic)
641	void set (ev_tstamp at, ev_tstamp interval = 0.)	676	void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()
642	{	677	{
643	int active = is_active ();	678	int active = is_active ();
644	if (active) stop ();	679	if (active) stop ();
645	ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);	680	ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);
646	if (active) start ();	681	if (active) start ();
647	}	682	}
648		683
649	void start (ev_tstamp at, ev_tstamp interval = 0.)	684	void start (ev_tstamp at, ev_tstamp interval = 0.) throw ()
650	{	685	{
651	set (at, interval);	686	set (at, interval);
652	start ();	687	start ();
653	}	688	}
654		689
655	void again ()	690	void again () throw ()
656	{	691	{
657	ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));	692	ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
658	}	693	}
659	EV_END_WATCHER (periodic, periodic)	694	EV_END_WATCHER (periodic, periodic)
660	#endif	695	#endif
661		696
		697	#if EV_SIGNAL_ENABLE
662	EV_BEGIN_WATCHER (sig, signal)	698	EV_BEGIN_WATCHER (sig, signal)
663	void set (int signum)	699	void set (int signum) throw ()
664	{	700	{
665	int active = is_active ();	701	int active = is_active ();
666	if (active) stop ();	702	if (active) stop ();
667	ev_signal_set (static_cast<ev_signal *>(this), signum);	703	ev_signal_set (static_cast<ev_signal *>(this), signum);
668	if (active) start ();	704	if (active) start ();
669	}	705	}
670		706
671	void start (int signum)	707	void start (int signum) throw ()
672	{	708	{
673	set (signum);	709	set (signum);
674	start ();	710	start ();
675	}	711	}
676	EV_END_WATCHER (sig, signal)	712	EV_END_WATCHER (sig, signal)
		713	#endif
677		714
		715	#if EV_CHILD_ENABLE
678	EV_BEGIN_WATCHER (child, child)	716	EV_BEGIN_WATCHER (child, child)
679	void set (int pid)	717	void set (int pid, int trace = 0) throw ()
680	{	718	{
681	int active = is_active ();	719	int active = is_active ();
682	if (active) stop ();	720	if (active) stop ();
683	ev_child_set (static_cast<ev_child *>(this), pid);	721	ev_child_set (static_cast<ev_child *>(this), pid, trace);
684	if (active) start ();	722	if (active) start ();
685	}	723	}
686		724
687	void start (int pid)	725	void start (int pid, int trace = 0) throw ()
688	{	726	{
689	set (pid);	727	set (pid, trace);
690	start ();	728	start ();
691	}	729	}
692	EV_END_WATCHER (child, child)	730	EV_END_WATCHER (child, child)
		731	#endif
693		732
694	#if EV_STAT_ENABLE	733	#if EV_STAT_ENABLE
695	EV_BEGIN_WATCHER (stat, stat)	734	EV_BEGIN_WATCHER (stat, stat)
696	void set (const char *path, ev_tstamp interval = 0.)	735	void set (const char *path, ev_tstamp interval = 0.) throw ()
697	{	736	{
698	int active = is_active ();	737	int active = is_active ();
699	if (active) stop ();	738	if (active) stop ();
700	ev_stat_set (static_cast<ev_stat *>(this), path, interval);	739	ev_stat_set (static_cast<ev_stat *>(this), path, interval);
701	if (active) start ();	740	if (active) start ();
702	}	741	}
703		742
704	void start (const char *path, ev_tstamp interval = 0.)	743	void start (const char *path, ev_tstamp interval = 0.) throw ()
705	{	744	{
706	stop ();	745	stop ();
707	set (path, interval);	746	set (path, interval);
708	start ();	747	start ();
709	}	748	}
710		749
711	void update ()	750	void update () throw ()
712	{	751	{
713	ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));	752	ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
714	}	753	}
715	EV_END_WATCHER (stat, stat)	754	EV_END_WATCHER (stat, stat)
716	#endif	755	#endif
717		756
		757	#if EV_IDLE_ENABLE
718	EV_BEGIN_WATCHER (idle, idle)	758	EV_BEGIN_WATCHER (idle, idle)
719	void set () { }	759	void set () throw () { }
720	EV_END_WATCHER (idle, idle)	760	EV_END_WATCHER (idle, idle)
		761	#endif
721		762
		763	#if EV_PREPARE_ENABLE
722	EV_BEGIN_WATCHER (prepare, prepare)	764	EV_BEGIN_WATCHER (prepare, prepare)
723	void set () { }	765	void set () throw () { }
724	EV_END_WATCHER (prepare, prepare)	766	EV_END_WATCHER (prepare, prepare)
		767	#endif
725		768
		769	#if EV_CHECK_ENABLE
726	EV_BEGIN_WATCHER (check, check)	770	EV_BEGIN_WATCHER (check, check)
727	void set () { }	771	void set () throw () { }
728	EV_END_WATCHER (check, check)	772	EV_END_WATCHER (check, check)
		773	#endif
729		774
730	#if EV_EMBED_ENABLE	775	#if EV_EMBED_ENABLE
731	EV_BEGIN_WATCHER (embed, embed)	776	EV_BEGIN_WATCHER (embed, embed)
732	void start (struct ev_loop *embedded_loop)	777	void set (struct ev_loop *embedded_loop) throw ()
733	{	778	{
734	stop ();	779	int active = is_active ();
		780	if (active) stop ();
735	ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);	781	ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
		782	if (active) start ();
		783	}
		784
		785	void start (struct ev_loop *embedded_loop) throw ()
		786	{
		787	set (embedded_loop);
736	start ();	788	start ();
737	}	789	}
738		790
739	void sweep ()	791	void sweep ()
740	{	792	{
…		…
743	EV_END_WATCHER (embed, embed)	795	EV_END_WATCHER (embed, embed)
744	#endif	796	#endif
745		797
746	#if EV_FORK_ENABLE	798	#if EV_FORK_ENABLE
747	EV_BEGIN_WATCHER (fork, fork)	799	EV_BEGIN_WATCHER (fork, fork)
748	void set () { }	800	void set () throw () { }
749	EV_END_WATCHER (fork, fork)	801	EV_END_WATCHER (fork, fork)
		802	#endif
		803
		804	#if EV_ASYNC_ENABLE
		805	EV_BEGIN_WATCHER (async, async)
		806	void send () throw ()
		807	{
		808	ev_async_send (EV_A_ static_cast<ev_async *>(this));
		809	}
		810
		811	bool async_pending () throw ()
		812	{
		813	return ev_async_pending (static_cast<ev_async *>(this));
		814	}
		815	EV_END_WATCHER (async, async)
750	#endif	816	#endif
751		817
752	#undef EV_PX	818	#undef EV_PX
753	#undef EV_PX_	819	#undef EV_PX_
754	#undef EV_CONSTRUCT	820	#undef EV_CONSTRUCT
755	#undef EV_BEGIN_WATCHER	821	#undef EV_BEGIN_WATCHER
756	#undef EV_END_WATCHER	822	#undef EV_END_WATCHER
757
758	}	823	}
759		824
760	#endif	825	#endif
761		826

Diff Legend

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

Comparing libev/ev++.h (file contents): Revision 1.29 by llucax, Fri Jan 18 18:15:01 2008 UTC vs. Revision 1.54 by root, Fri Oct 22 05:57:55 2010 UTC

Diff Legend

Comparing libev/ev++.h (file contents):
Revision 1.29 by llucax, Fri Jan 18 18:15:01 2008 UTC vs.
Revision 1.54 by root, Fri Oct 22 05:57:55 2010 UTC