Set up the given loop for mutex locking from haskell-land -- if you want to touch the loop from other Haskell threads, you'll need to do this. The two FunPtr objects returned need to be explicitly freed with freeMutexCallback.

IMPORTANT: if you want multithreaded access to an EvLoopPtr, you'll have to acquire the MVar returned here (using withMVar) whenever you call any of the ev functions. Very bad C-land crash/bang/boom could otherwise result.

ALSO IMPORTANT: any changes you make to an EvLoopPtr from another thread while the event loop thread is blocked inside ev_loop() will NOT take effect until the the event loop thread unblocks. You'll need to set up an ev_async watcher in order to wake up the event loop thread.

freeMutexCallback :: FunPtr MutexCallback -> IO ()

Event flags

type CEventType = CInt

CEventType is a bitfield used to flag whether a file descriptor is readable, writable, or both. Valid values are ev_read and ev_write. TODO: deprecate and replace by a datatype

ev_undef :: CEventType

eventmask, revents, events...

ev_none :: CEventType

ev_read :: CEventType

ev_write :: CEventType

ev__iofdset :: CEventType

ev_io :: CEventType

ev_timeout :: CEventType

ev_timer :: CEventType

ev_periodic :: CEventType

ev_signal :: CEventType

ev_child :: CEventType

ev_stat :: CEventType

ev_idle :: CEventType

CEvFlagType is a bitfield used to pass flags into evDefaultLoop. Values (evflag_auto, evflag_noenv, etc.) are combined with bitwise or. TODO: replace with a newtype with a monoid instance

ev_prepare :: CEventType

ev_check :: CEventType

ev_embed :: CEventType

ev_fork :: CEventType

ev_async :: CEventType

ev_custom :: CEventType

ev_error :: CEventType

`ev_io`

See libev docs: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#code_ev_io_code_is_this_file_descrip

type EvIoPtr = Ptr EvIo

type IoCallback = EvLoopPtr -> EvIoPtr -> CEventType -> IO ()

An IoCallback is called when a file descriptor becomes readable or writable. It takes a pointer to an ev_loop structure, a pointer to an ev_io structure, and an event mask.

mkEvIo :: IO EvIoPtr

Makes a new ev_io struct using malloc. You are responsible for freeing it with freeEvIo.

freeEvIo :: EvIoPtr -> IO ()

free() an EvIoPtr

mkIoCallback :: IoCallback -> IO (FunPtr IoCallback)

Wrap up an IoCallback so it can be delivered into C-land. This resource is not garbage-collected, you are responsible for freeing it with freeIoCallback.

freeIoCallback :: FunPtr IoCallback -> IO ()

evIoInit :: EvIoPtr -> FunPtr IoCallback -> CInt -> CEventType -> IO ()

evIoStart :: EvLoopPtr -> EvIoPtr -> IO ()

evIoStop :: EvLoopPtr -> EvIoPtr -> IO ()

`ev_timer`

See libev docs: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#code_ev_timer_code_relative_and_opti

data EvTimer

Instances

Storable EvTimer

type EvTimerPtr = Ptr EvTimer

type TimerCallback = EvLoopPtr -> EvTimerPtr -> CEventType -> IO ()

A TimerCallback is called when a timer expires. It takes a pointer to an ev_loop structure, a pointer to an ev_timer structure, and an (unused?) event mask.

mkEvTimer :: IO EvTimerPtr

Makes a new ev_timer struct using malloc. You are responsible for freeing it with freeEvTimer.

freeEvTimer :: EvTimerPtr -> IO ()

free() an EvTimer

mkTimerCallback :: TimerCallback -> IO (FunPtr TimerCallback)

Wrap up a TimerCallback so it can be delivered into C-land. This resource is not garbage-collected, you are responsible for freeing it with freeTimerCallback.

freeTimerCallback :: FunPtr TimerCallback -> IO ()

evTimerInit :: EvTimerPtr -> FunPtr TimerCallback -> EvTimestamp -> EvTimestamp -> IO ()

evTimerStart :: EvLoopPtr -> EvTimerPtr -> IO ()

evTimerStop :: EvLoopPtr -> EvTimerPtr -> IO ()

evTimerAgain :: EvLoopPtr -> EvTimerPtr -> IO ()

evTimerRemaining :: EvLoopPtr -> EvTimerPtr -> IO EvTimestamp

evTimerSetRepeat :: EvTimerPtr -> Double -> IO ()

See libev docs: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#code_ev_async_code_how_to_wake_up_an

type EvAsyncPtr = Ptr EvAsync

type AsyncCallback = EvLoopPtr -> EvAsyncPtr -> CEventType -> IO ()

An AsyncCallback is called when you wakeup an event loop with ev_async_send

mkEvAsync :: IO EvAsyncPtr

Makes a new ev_async struct using malloc. You are responsible for freeing it with freeEvAsync.

freeEvAsync :: EvAsyncPtr -> IO ()

free() an EvAsync

evAsyncInit :: EvAsyncPtr -> FunPtr AsyncCallback -> IO ()

evAsyncSend :: EvLoopPtr -> EvAsyncPtr -> IO ()

evAsyncStart :: EvLoopPtr -> EvAsyncPtr -> IO ()

evAsyncStop :: EvLoopPtr -> EvAsyncPtr -> IO ()

mkAsyncCallback :: AsyncCallback -> IO (FunPtr AsyncCallback)

Wrap up an AsyncCallback so it can be delivered into C-land. This resource is not garbage-collected, you are responsible for freeing it with freeAsyncCallback.

freeAsyncCallback :: FunPtr AsyncCallback -> IO ()