libev/ev.h

#ifndef EV_H
#define EV_H

typedef double ev_tstamp;

/* eventmask, revents, events... */
#define EV_UNDEF   -1 /* guaranteed to be invalid */
#define EV_NONE    0
#define EV_READ    1
#define EV_WRITE   2
#define EV_TIMEOUT 4
#define EV_SIGNAL  8

/* shared by all watchers */
#define EV_WATCHER(type)                        \
  int active; /* private */                     \
  int pending; /* private */                    \
  void *data; /* rw */                          \
  void (*cb)(struct type *, int revents) /* rw */

#define EV_WATCHER_LIST(type)                   \
  EV_WATCHER (type);                            \
  struct type *next /* private */

struct ev_timer
{
  EV_WATCHER_LIST (ev_timer);

  ev_tstamp at;     /* private */
  ev_tstamp repeat; /* rw */
  unsigned char is_abs; /* ro */
};

struct ev_io
{
  EV_WATCHER_LIST (ev_io);

  int fd;     /* ro */
  int events; /* ro */
};

struct ev_signal
{
  EV_WATCHER_LIST (ev_signal);

  int signum; /* ro */
};

#define EVMETHOD_NONE   0
#define EVMETHOD_SELECT 1
#define EVMETHOD_EPOLL  2
int ev_init (int flags);
extern int ev_method;

void ev_prefork (void);
void ev_postfork_parent (void);
void ev_postfork_child (void);

extern ev_tstamp ev_now; /* time w.r.t. timers and the eventloop, updated after each poll */
ev_tstamp ev_time (void);

#define EVLOOP_NONBLOCK 1 /* do not block/wait */
#define EVLOOP_ONESHOT  2 /* block *once* only */
void ev_loop (int flags);
extern int ev_loop_done; /* set to 1 to break out of event loop */

#define EVHOOK_PREPOLL  0 /* called before updating fds, timers and blocking */
#define EVHOOK_POSTPOLL 1 /* called after blocking */
#define EVHOOK_NUM      2 /* just the # of hooks */
typedef void (*ev_hook)(void);
void ev_hook_register (int type, ev_hook hook);
void ev_hook_unregister (int type, ev_hook hook);

/* these may evaluate ev multiple times, and the other arguments at most once */
#define evw_init(ev,cb_,data_)             do { (ev)->active = 0; (ev)->cb = (cb_); (ev)->data = (void *)data_; } while (0)

#define evio_set(ev,fd_,events_)           do { (ev)->fd = (fd_); (ev)->events = (events_); } while (0)
#define evtimer_set_rel(ev,after_,repeat_) do { (ev)->at = (after_); (ev)->repeat = (repeat_); (ev)->is_abs = 0; } while (0)
#define evtimer_set_abs(ev,at_,repeat_)    do { (ev)->at = (at_); (ev)->repeat = (repeat_); (ev)->is_abs = 1; } while (0)
#define evsignal_set(ev,signum_)           do { (ev)->signum = (signum_); } while (0)

#define ev_is_active(ev) (0 + (ev)->active) /* true when the watcher has been started */

void evio_start (struct ev_io *w);
void evio_stop  (struct ev_io *w);

void evtimer_start (struct ev_timer *w);
void evtimer_stop  (struct ev_timer *w);

void evsignal_start (struct ev_signal *w);
void evsignal_stop  (struct ev_signal *w);

#endif

Revision:	1.4
Committed:	Wed Oct 31 00:32:33 2007 UTC (16 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+7 -0 lines
Log Message:	implement primitive hook management
#	User	Rev	Content
1	root	1.1	#ifndef EV_H
2			#define EV_H
3
4			typedef double ev_tstamp;
5
6			/* eventmask, revents, events... */
7			#define EV_UNDEF -1 /* guaranteed to be invalid */
8			#define EV_NONE 0
9			#define EV_READ 1
10			#define EV_WRITE 2
11			#define EV_TIMEOUT 4
12			#define EV_SIGNAL 8
13
14			/* shared by all watchers */
15			#define EV_WATCHER(type) \
16			int active; /* private */ \
17			int pending; /* private */ \
18			void data; / rw */ \
19			void (cb)(struct type , int revents) /* rw */
20
21			#define EV_WATCHER_LIST(type) \
22			EV_WATCHER (type); \
23			struct type next / private */
24
25			struct ev_timer
26			{
27			EV_WATCHER_LIST (ev_timer);
28
29	root	1.3	ev_tstamp at; /* private */
30	root	1.1	ev_tstamp repeat; /* rw */
31	root	1.3	unsigned char is_abs; /* ro */
32	root	1.1	};
33
34			struct ev_io
35			{
36			EV_WATCHER_LIST (ev_io);
37
38			int fd; /* ro */
39			int events; /* ro */
40			};
41
42			struct ev_signal
43			{
44			EV_WATCHER_LIST (ev_signal);
45
46			int signum; /* ro */
47			};
48
49			#define EVMETHOD_NONE 0
50			#define EVMETHOD_SELECT 1
51			#define EVMETHOD_EPOLL 2
52			int ev_init (int flags);
53			extern int ev_method;
54
55			void ev_prefork (void);
56			void ev_postfork_parent (void);
57			void ev_postfork_child (void);
58
59			extern ev_tstamp ev_now; /* time w.r.t. timers and the eventloop, updated after each poll */
60			ev_tstamp ev_time (void);
61
62			#define EVLOOP_NONBLOCK 1 /* do not block/wait */
63			#define EVLOOP_ONESHOT 2 /* block once only */
64	root	1.3	void ev_loop (int flags);
65	root	1.1	extern int ev_loop_done; /* set to 1 to break out of event loop */
66
67	root	1.4	#define EVHOOK_PREPOLL 0 /* called before updating fds, timers and blocking */
68			#define EVHOOK_POSTPOLL 1 /* called after blocking */
69			#define EVHOOK_NUM 2 /* just the # of hooks */
70			typedef void (*ev_hook)(void);
71			void ev_hook_register (int type, ev_hook hook);
72			void ev_hook_unregister (int type, ev_hook hook);
73
74	root	1.2	/* these may evaluate ev multiple times, and the other arguments at most once */
75	root	1.1	#define evw_init(ev,cb_,data_) do { (ev)->active = 0; (ev)->cb = (cb_); (ev)->data = (void *)data_; } while (0)
76	root	1.3
77	root	1.1	#define evio_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_); } while (0)
78			#define evtimer_set_rel(ev,after_,repeat_) do { (ev)->at = (after_); (ev)->repeat = (repeat_); (ev)->is_abs = 0; } while (0)
79			#define evtimer_set_abs(ev,at_,repeat_) do { (ev)->at = (at_); (ev)->repeat = (repeat_); (ev)->is_abs = 1; } while (0)
80			#define evsignal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0)
81
82	root	1.2	#define ev_is_active(ev) (0 + (ev)->active) /* true when the watcher has been started */
83	root	1.1
84			void evio_start (struct ev_io *w);
85			void evio_stop (struct ev_io *w);
86
87			void evtimer_start (struct ev_timer *w);
88			void evtimer_stop (struct ev_timer *w);
89
90			void evsignal_start (struct ev_signal *w);
91			void evsignal_stop (struct ev_signal *w);
92
93			#endif
94