NAME

       tickit_watch_io - invoke a callback when IO is possible

SYNOPSIS

       #include <tickit.h>

       typedef enum TickitIOCondition;

       typedef struct {
         int fd;
         TickitIOCondition cond;
       } TickitIOWatchInfo;

       typedef int TickitCallbackFn(Tickit *t, TickitEventflags flags,
           void *info, void *user);

       void *tickit_watch_io(Tickit *t, int fd, TickitIOCondition cond,
           TickitBindFlags flags, TickitCallbackFn *fn, void *user);

       Link with -ltickit.

DESCRIPTION

       tickit_watch_io()  registers  a callback function to be invoked by the toplevel event loop
       when IO operations are possible on a given file descriptor. A registered callback will  be
       invoked by a running call to tickit_run(3). The callback function will be invoked whenever
       the file descriptor is readable, writable, or in a hang-up  condition,  depending  on  the
       requested  condition types. The info pointer will point to a structure containing the file
       descriptor and a bitmask of the IO operations currently possible.

       The cond argument to tickit_watch_io() should  be  a  bitmask  of  at  least  one  of  the
       following values:

       TICKIT_IO_IN
              The file descriptor is ready to perform an input operation, such as reading bytes.

       TICKIT_IO_OUT
              The file descriptor is ready to perform an output operation, such as writing bytes.

       TICKIT_IO_HUP
              The  file  descriptor  is  in  a  hang-up  condition.  Typically  this means that a
              connection such as a socket or pipe has been closed by the peer.

       When the callback function is invoked, the info struct will contain the file descriptor in
       the  fd  field,  and  the  current IO conditions in the cond field. This may be one of the
       values given above, and in addition may also be one of the following:

       TICKIT_IO_ERR
              The file descriptor is in an error condition.

       TICKIT_IO_INVAL
              The file descriptor itself is invalid and does not represent an open file.

       If registered with the TICKIT_BIND_FIRST flag, the callback will be inserted at the  start
       of the queue, coming before others. If not, it is appended at the end.

       If  cancelled  by  tickit_watch_cancel(3)  the  callback function is invoked with just the
       TICKIT_EV_UNBIND flag if it had been registered with TICKIT_BIND_UNBIND.

RETURN VALUE

       tickit_watch_io() returns an opaque identifier pointer.

SEE ALSO

       tickit_new_stdio(3),   tickit_watch_timer_after_msec(3),   tickit_watch_timer_at_epoch(3),
       tickit_watch_later(3),           tickit_watch_signal(3),          tickit_watch_process(3),
       tickit_watch_cancel(3), tickit(7)

                                                                               TICKIT_WATCH_IO(3)