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

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

Diff Legend

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

Comparing libev/ev++.h (file contents): Revision 1.44 by root, Wed Dec 3 15:23:44 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.44 by root, Wed Dec 3 15:23:44 2008 UTC vs.
Revision 1.69 by root, Sat Jun 3 08:53:03 2023 UTC