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

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

Diff Legend

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

Comparing libev/ev++.h (file contents): Revision 1.34 by llucax, Tue Jan 22 17:56:54 2008 UTC vs. Revision 1.69 by root, Sat Jun 3 08:53:03 2023 UTC

Diff Legend

Comparing libev/ev++.h (file contents):
Revision 1.34 by llucax, Tue Jan 22 17:56:54 2008 UTC vs.
Revision 1.69 by root, Sat Jun 3 08:53:03 2023 UTC