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

Comparing libev/ev.h (file contents):
Revision 1.3 by root, Tue Oct 30 23:10:33 2007 UTC vs.
Revision 1.43 by root, Fri Nov 9 17:10:57 2007 UTC

		1	/*
		2	* Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
		3	* All rights reserved.
		4	*
		5	* Redistribution and use in source and binary forms, with or without
		6	* modification, are permitted provided that the following conditions are
		7	* met:
		8	*
		9	* * Redistributions of source code must retain the above copyright
		10	* notice, this list of conditions and the following disclaimer.
		11	*
		12	* * Redistributions in binary form must reproduce the above
		13	* copyright notice, this list of conditions and the following
		14	* disclaimer in the documentation and/or other materials provided
		15	* with the distribution.
		16	*
		17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		18	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		19	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
		20	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
		21	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		22	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		23	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		27	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		28	*/
		29
1	#ifndef EV_H	30	#ifndef EV_H__
2	#define EV_H	31	#define EV_H__
		32
		33	#ifdef __cplusplus
		34	extern "C" {
		35	#endif
3		36
4	typedef double ev_tstamp;	37	typedef double ev_tstamp;
5		38
		39	/* these priorities are inclusive, higher priorities will be called earlier */
		40	#ifndef EV_MINPRI
		41	# define EV_MINPRI -2
		42	#endif
		43	#ifndef EV_MAXPRI
		44	# define EV_MAXPRI +2
		45	#endif
		46
		47	#ifndef EV_MULTIPLICITY
		48	# define EV_MULTIPLICITY 1
		49	#endif
		50
		51	/* support multiple event loops? */
		52	#if EV_MULTIPLICITY
		53	struct ev_loop;
		54	# define EV_P struct ev_loop *loop
		55	# define EV_P_ EV_P,
		56	# define EV_A loop
		57	# define EV_A_ EV_A,
		58	#else
		59	# define EV_P void
		60	# define EV_P_
		61	# define EV_A
		62	# define EV_A_
		63	#endif
		64
6	/* eventmask, revents, events... */	65	/* eventmask, revents, events... */
7	#define EV_UNDEF -1 /* guaranteed to be invalid */	66	#define EV_UNDEF -1 /* guaranteed to be invalid */
8	#define EV_NONE 0	67	#define EV_NONE 0x00
9	#define EV_READ 1	68	#define EV_READ 0x01
10	#define EV_WRITE 2	69	#define EV_WRITE 0x02
11	#define EV_TIMEOUT 4	70	#define EV_TIMEOUT 0x000100
		71	#define EV_PERIODIC 0x000200
12	#define EV_SIGNAL 8	72	#define EV_SIGNAL 0x000400
		73	#define EV_IDLE 0x000800
		74	#define EV_CHECK 0x001000
		75	#define EV_PREPARE 0x002000
		76	#define EV_CHILD 0x004000
		77	#define EV_ERROR 0x800000 /* sent when an error occurs */
		78
		79	/* can be used to add custom fields to all watchers */
		80	#ifndef EV_COMMON
		81	# define EV_COMMON void *data
		82	#endif
		83	#ifndef EV_PROTOTYPES
		84	# define EV_PROTOTYPES 1
		85	#endif
		86
		87	#define EV_VERSION_MAJOR 1
		88	#define EV_VERSION_MINOR 1
		89
		90	/*
		91	* struct member types:
		92	* private: you can look at them, but not change them, and they might not mean anything to you.
		93	* ro: can be read anytime, but only changed when the watcher isn't active
		94	* rw: can be read and modified anytime, even when the watcher is active
		95	*/
13		96
14	/* shared by all watchers */	97	/* shared by all watchers */
15	#define EV_WATCHER(type) \	98	#define EV_WATCHER(type) \
16	int active; /* private */ \	99	int active; /* private */ \
17	int pending; /* private */ \	100	int pending; /* private */ \
18	void data; / rw */ \	101	int priority; /* private */ \
19	void (cb)(struct type , int revents) /* rw */	102	EV_COMMON; /* rw */ \
		103	void (cb)(EV_P_ struct type , int revents) /* private / / gets invoked with an eventmask */
20		104
21	#define EV_WATCHER_LIST(type) \	105	#define EV_WATCHER_LIST(type) \
22	EV_WATCHER (type); \	106	EV_WATCHER (type); \
23	struct type next / private */	107	struct ev_watcher_list next / private */
24		108
		109	#define EV_WATCHER_TIME(type) \
		110	EV_WATCHER (type); \
		111	ev_tstamp at /* private */
		112
		113	/* base class, nothing to see here unless you subclass */
		114	struct ev_watcher {
		115	EV_WATCHER (ev_watcher);
		116	};
		117
		118	/* base class, nothing to see here unless you subclass */
		119	struct ev_watcher_list {
		120	EV_WATCHER_LIST (ev_watcher_list);
		121	};
		122
		123	/* base class, nothing to see here unless you subclass */
		124	struct ev_watcher_time {
		125	EV_WATCHER_TIME (ev_watcher_time);
		126	};
		127
		128	/* invoked after a specific time, repeatable (based on monotonic clock) */
		129	/* revent EV_TIMEOUT */
25	struct ev_timer	130	struct ev_timer
26	{	131	{
27	EV_WATCHER_LIST (ev_timer);	132	EV_WATCHER_TIME (ev_timer);
28		133
29	ev_tstamp at; /* private */
30	ev_tstamp repeat; /* rw */	134	ev_tstamp repeat; /* rw */
31	unsigned char is_abs; /* ro */
32	};	135	};
33		136
		137	/* invoked at some specific time, possibly repeating at regular intervals (based on UTC) */
		138	/* revent EV_PERIODIC */
		139	struct ev_periodic
		140	{
		141	EV_WATCHER_TIME (ev_periodic);
		142
		143	ev_tstamp interval; /* rw */
		144	ev_tstamp (reschedule_cb)(struct ev_periodic w, ev_tstamp now); /* rw */
		145	};
		146
		147	/* invoked when fd is either EV_READable or EV_WRITEable */
		148	/* revent EV_READ, EV_WRITE */
34	struct ev_io	149	struct ev_io
35	{	150	{
36	EV_WATCHER_LIST (ev_io);	151	EV_WATCHER_LIST (ev_io);
37		152
38	int fd; /* ro */	153	int fd; /* ro */
39	int events; /* ro */	154	int events; /* ro */
40	};	155	};
41		156
		157	/* invoked when the given signal has been received */
		158	/* revent EV_SIGNAL */
42	struct ev_signal	159	struct ev_signal
43	{	160	{
44	EV_WATCHER_LIST (ev_signal);	161	EV_WATCHER_LIST (ev_signal);
45		162
46	int signum; /* ro */	163	int signum; /* ro */
47	};	164	};
48		165
49	#define EVMETHOD_NONE 0	166	/* invoked when the nothing else needs to be done, keeps the process from blocking */
		167	/* revent EV_IDLE */
		168	struct ev_idle
		169	{
		170	EV_WATCHER (ev_idle);
		171	};
		172
		173	/* invoked for each run of the mainloop, just before the blocking call */
		174	/* you can still change events in any way you like */
		175	/* revent EV_PREPARE */
		176	struct ev_prepare
		177	{
		178	EV_WATCHER (ev_prepare);
		179	};
		180
		181	/* invoked for each run of the mainloop, just after the blocking call */
		182	/* revent EV_CHECK */
		183	struct ev_check
		184	{
		185	EV_WATCHER (ev_check);
		186	};
		187
		188	/* invoked when sigchld is received and waitpid indicates the givne pid */
		189	/* revent EV_CHILD */
		190	/* does not support priorities */
		191	struct ev_child
		192	{
		193	EV_WATCHER_LIST (ev_child);
		194
		195	int pid; /* ro */
		196	int rpid; /* rw, holds the received pid */
		197	int rstatus; /* rw, holds the exit status, use the macros from sys/wait.h */
		198	};
		199
		200	/* the presence of this union forces similar struct layout */
		201	union ev_any_watcher
		202	{
		203	struct ev_watcher w;
		204	struct ev_watcher_list wl;
		205	struct ev_io io;
		206	struct ev_timer timer;
		207	struct ev_periodic periodic;
		208	struct ev_signal signal;
		209	struct ev_idle idle;
		210	struct ev_child child;
		211	struct ev_prepare prepare;
		212	struct ev_check check;
		213	};
		214
		215	#define EVMETHOD_AUTO 0 /* consults environment */
50	#define EVMETHOD_SELECT 1	216	#define EVMETHOD_SELECT 1
51	#define EVMETHOD_EPOLL 2	217	#define EVMETHOD_POLL 2
52	int ev_init (int flags);	218	#define EVMETHOD_EPOLL 4
53	extern int ev_method;	219	#define EVMETHOD_KQUEUE 8
		220	#define EVMETHOD_DEVPOLL 16 /* NYI */
		221	#define EVMETHOD_PORT 32 /* NYI */
		222	#define EVMETHOD_WIN32 64 /* NYI */
		223	#define EVMETHOD_ANY ~0 /* any method, do not consult env */
54		224
55	void ev_prefork (void);	225	#if EV_PROTOTYPES
56	void ev_postfork_parent (void);	226	int ev_version_major (void);
57	void ev_postfork_child (void);	227	int ev_version_minor (void);
58		228
59	extern ev_tstamp ev_now; /* time w.r.t. timers and the eventloop, updated after each poll */
60	ev_tstamp ev_time (void);	229	ev_tstamp ev_time (void);
		230
		231	/* Sets the allocation function to use, works like realloc.
		232	* It is used to allocate and free memory.
		233	* If it returns zero when memory needs to be allocated, the library might abort
		234	* or take some potentially destructive action.
		235	* The default is your system realloc function.
		236	*/
		237	void ev_set_allocator (void (cb)(void *ptr, long size));
		238
		239	/* set the callback function to call on a
		240	* retryable syscall error
		241	* (such as failed select, poll, epoll_wait)
		242	*/
		243	void ev_set_syserr_cb (void (cb)(const char msg));
		244
		245	# if EV_MULTIPLICITY
		246	/* the default loop is the only one that handles signals and child watchers */
		247	/* you can call this as often as you like */
		248	struct ev_loop ev_default_loop (int methods); / returns default loop */
		249
		250	/* create and destroy alternative loops that don't handle signals */
		251	struct ev_loop *ev_loop_new (int methods);
		252	void ev_loop_destroy (EV_P);
		253	void ev_loop_fork (EV_P);
		254	# else
		255	int ev_default_loop (int methods); /* returns true when successful */
		256	# endif
		257
		258	void ev_default_destroy (void); /* destroy the default loop */
		259	/* this needs to be called after fork, to duplicate the default loop */
		260	/* if you create alternative loops you have to call ev_loop_fork on them */
		261	/* you can call it in either the parent or the child */
		262	/* you can actually call it at any time, anywhere :) */
		263	void ev_default_fork (void);
		264
		265	int ev_method (EV_P);
		266	#endif
61		267
62	#define EVLOOP_NONBLOCK 1 /* do not block/wait */	268	#define EVLOOP_NONBLOCK 1 /* do not block/wait */
63	#define EVLOOP_ONESHOT 2 /* block once only */	269	#define EVLOOP_ONESHOT 2 /* block once only */
		270	#define EVUNLOOP_ONCE 1 /* unloop once */
		271	#define EVUNLOOP_ALL 2 /* unloop all loops */
		272
		273	#if EV_PROTOTYPES
64	void ev_loop (int flags);	274	void ev_loop (EV_P_ int flags);
65	extern int ev_loop_done; /* set to 1 to break out of event loop */	275	void ev_unloop (EV_P_ int how); /* set to 1 to break out of event loop, set to 2 to break out of all event loops */
		276
		277	ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */
		278
		279	/*
		280	* ref/unref can be used to add or remove a refcount on the mainloop. every watcher
		281	* keeps one reference. if you have a long-runing watcher you never unregister that
		282	* should not keep ev_loop from running, unref() after starting, and ref() before stopping.
		283	*/
		284	void ev_ref (EV_P);
		285	void ev_unref (EV_P);
		286
		287	/* convinience function, wait for a single event, without registering an event watcher */
		288	/* if timeout is < 0, do wait indefinitely */
		289	void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (cb)(int revents, void arg), void *arg);
		290	#endif
66		291
67	/* these may evaluate ev multiple times, and the other arguments at most once */	292	/* these may evaluate ev multiple times, and the other arguments at most once */
68	#define evw_init(ev,cb_,data_) do { (ev)->active = 0; (ev)->cb = (cb_); (ev)->data = (void *)data_; } while (0)	293	/* either use ev_watcher_init + ev_TYPE_set, or the ev_TYPE_init macro, below, to first initialise a watcher */
		294	#define ev_watcher_init(ev,cb_) do { \
		295	((struct ev_watcher )(void )(ev))->active = \
		296	((struct ev_watcher )(void )(ev))->pending = \
		297	((struct ev_watcher )(void )(ev))->priority = 0; \
		298	(ev)->cb = (cb_); \
		299	} while (0)
69		300
70	#define evio_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_); } while (0)	301	#define ev_io_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_); } while (0)
71	#define evtimer_set_rel(ev,after_,repeat_) do { (ev)->at = (after_); (ev)->repeat = (repeat_); (ev)->is_abs = 0; } while (0)	302	#define ev_timer_set(ev,after_,repeat_) do { (ev)->at = (after_); (ev)->repeat = (repeat_); } while (0)
72	#define evtimer_set_abs(ev,at_,repeat_) do { (ev)->at = (at_); (ev)->repeat = (repeat_); (ev)->is_abs = 1; } while (0)	303	#define ev_periodic_set(ev,at_,ival_,res_) do { (ev)->at = (at_); (ev)->interval = (ival_); (ev)->reschedule_cb= (res_); } while (0)
73	#define evsignal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0)	304	#define ev_signal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0)
		305	#define ev_idle_set(ev) /* nop, yes, this is a serious in-joke */
		306	#define ev_prepare_set(ev) /* nop, yes, this is a serious in-joke */
		307	#define ev_check_set(ev) /* nop, yes, this is a serious in-joke */
		308	#define ev_child_set(ev,pid_) do { (ev)->pid = (pid_); } while (0)
74		309
		310	#define ev_io_init(ev,cb,fd,events) do { ev_watcher_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
		311	#define ev_timer_init(ev,cb,after,repeat) do { ev_watcher_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0)
		312	#define ev_periodic_init(ev,cb,at,ival,res) do { ev_watcher_init ((ev), (cb)); ev_periodic_set ((ev),(at),(ival),(res)); } while (0)
		313	#define ev_signal_init(ev,cb,signum) do { ev_watcher_init ((ev), (cb)); ev_signal_set ((ev), (signum)); } while (0)
		314	#define ev_idle_init(ev,cb) do { ev_watcher_init ((ev), (cb)); ev_idle_set ((ev)); } while (0)
		315	#define ev_prepare_init(ev,cb) do { ev_watcher_init ((ev), (cb)); ev_prepare_set ((ev)); } while (0)
		316	#define ev_check_init(ev,cb) do { ev_watcher_init ((ev), (cb)); ev_check_set ((ev)); } while (0)
		317	#define ev_child_init(ev,cb,pid) do { ev_watcher_init ((ev), (cb)); ev_child_set ((ev),(pid)); } while (0)
		318
		319	#define ev_is_pending(ev) (0 + ((struct ev_watcher )(void )(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
75	#define ev_is_active(ev) (0 + (ev)->active) /* true when the watcher has been started */	320	#define ev_is_active(ev) (0 + ((struct ev_watcher )(void )(ev))->active) /* ro, true when the watcher has been started */
76		321
		322	#define ev_priority(ev) ((struct ev_watcher )(void )(ev))->priority /* rw */
		323	#define ev_cb(ev) (ev)->cb /* rw */
		324	#define ev_set_priority(ev,pri) ev_priority (ev) = (pri)
		325	#define ev_set_cb(ev,cb_) ev_cb (ev) = (cb_)
		326
		327	/* stopping (enabling, adding) a watcher does nothing if it is already running */
		328	/* stopping (disabling, deleting) a watcher does nothing unless its already running */
		329	#if EV_PROTOTYPES
		330
		331	/* feeds an event into a watcher as if the event actually occured */
		332	/* accepts any ev_watcher type */
		333	void ev_feed_event (EV_P_ void *w, int revents);
		334	void ev_feed_fd_event (EV_P_ int fd, int revents);
		335	void ev_feed_signal_event (EV_P_ int signum);
		336
77	void evio_start (struct ev_io *w);	337	void ev_io_start (EV_P_ struct ev_io *w);
78	void evio_stop (struct ev_io *w);	338	void ev_io_stop (EV_P_ struct ev_io *w);
79		339
80	void evtimer_start (struct ev_timer *w);	340	void ev_timer_start (EV_P_ struct ev_timer *w);
81	void evtimer_stop (struct ev_timer *w);	341	void ev_timer_stop (EV_P_ struct ev_timer *w);
		342	/* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */
		343	void ev_timer_again (EV_P_ struct ev_timer *w);
82		344
		345	void ev_periodic_start (EV_P_ struct ev_periodic *w);
		346	void ev_periodic_stop (EV_P_ struct ev_periodic *w);
		347	void ev_periodic_again (EV_P_ struct ev_periodic *w);
		348
		349	void ev_idle_start (EV_P_ struct ev_idle *w);
		350	void ev_idle_stop (EV_P_ struct ev_idle *w);
		351
		352	void ev_prepare_start (EV_P_ struct ev_prepare *w);
		353	void ev_prepare_stop (EV_P_ struct ev_prepare *w);
		354
		355	void ev_check_start (EV_P_ struct ev_check *w);
		356	void ev_check_stop (EV_P_ struct ev_check *w);
		357
		358	/* only supported in the default loop */
83	void evsignal_start (struct ev_signal *w);	359	void ev_signal_start (EV_P_ struct ev_signal *w);
84	void evsignal_stop (struct ev_signal *w);	360	void ev_signal_stop (EV_P_ struct ev_signal *w);
85		361
		362	/* only supported in the default loop */
		363	void ev_child_start (EV_P_ struct ev_child *w);
		364	void ev_child_stop (EV_P_ struct ev_child *w);
86	#endif	365	#endif
87		366
		367	#ifdef __cplusplus
		368	}
		369	#endif
		370
		371	#endif
		372

Diff Legend

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

Comparing libev/ev.h (file contents): Revision 1.3 by root, Tue Oct 30 23:10:33 2007 UTC vs. Revision 1.43 by root, Fri Nov 9 17:10:57 2007 UTC

Diff Legend

Comparing libev/ev.h (file contents):
Revision 1.3 by root, Tue Oct 30 23:10:33 2007 UTC vs.
Revision 1.43 by root, Fri Nov 9 17:10:57 2007 UTC