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

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

Diff Legend

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

Comparing libev/ev++.h (file contents): Revision 1.25 by llucax, Fri Jan 18 18:13:40 2008 UTC vs. Revision 1.45 by root, Fri Jul 10 00:36:21 2009 UTC

Diff Legend

Comparing libev/ev++.h (file contents):
Revision 1.25 by llucax, Fri Jan 18 18:13:40 2008 UTC vs.
Revision 1.45 by root, Fri Jul 10 00:36:21 2009 UTC