/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
   It is considered beerware. Prost. Skol. Cheers or whatever.

   $id$ */

#ifndef OT_EVENT_H__
#define OT_EVENT_H__

#include <stdint.h>

/* Which descriptors have become readable or writable, asked of whichever
   mechanism the kernel offers. The generation a descriptor was registered
   with is handed back with every event, so a caller can tell an event for
   the connection it is holding from one for a connection that has since been
   closed and had its number reused. */

enum { EVENT_IN = 1, EVENT_OUT = 2 };

typedef struct {
  int      fd;
  uint32_t generation;
  int      what;
} ot_event;

int  event_init(void);
void event_deinit(void);

int  event_add(int fd, int what, uint32_t generation);
int  event_modify(int fd, int what, uint32_t generation);
int  event_del(int fd);

/* Stop watching a descriptor and close it. Where the kernel drops a closed
   descriptor from its set by itself, this is one system call where doing the
   two separately would be two. */
int  event_close(int fd);

/* Waits at most timeout_ms, or indefinitely when that is negative, and fills
   out with up to max ready descriptors. Returns how many, or -1. */
int  event_wait(ot_event *out, int max, int timeout_ms);

/* Whether the registered set may be changed from another thread while this
   one is waiting on it. True where the kernel keeps the set, false where
   this module keeps it in memory of its own. */
int  event_can_share(void);

/* Which mechanism was compiled in, for the version string */
const char *event_mechanism(void);

#endif