-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | FFI interface to libev
--
-- FFI interface to libev
@package hlibev
@version 0.2.5
-- | Network.Libev is a low-level binding to the libev library
-- (http://libev.schmorp.de/). The libev documentation is
-- available here:
-- http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod.
module Network.Libev
type EvLoopPtr = Ptr EvLoop
evDefaultLoop :: CInt -> IO EvLoopPtr
evLoopNew :: CUInt -> IO EvLoopPtr
evLoop :: EvLoopPtr -> CInt -> IO ()
evUnloop :: EvLoopPtr -> CInt -> IO ()
evLoopDestroy :: EvLoopPtr -> IO ()
-- | Returns the default set of CEvFlagType flags
evRecommendedBackends :: IO CEvFlagType
evflag_auto :: CEvFlagType
evflag_noenv :: CEvFlagType
evbackend_select :: CEvFlagType
evbackend_poll :: CEvFlagType
evbackend_epoll :: CEvFlagType
evbackend_kqueue :: CEvFlagType
evbackend_devpoll :: CEvFlagType
evbackend_port :: CEvFlagType
-- | MutexCallback is called by ev_set_loop_release_cb
type MutexCallback = EvLoopPtr -> IO ()
-- | 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.
setupLockingForLoop :: EvLoopPtr -> IO (FunPtr MutexCallback, FunPtr MutexCallback, MVar ())
freeMutexCallback :: FunPtr MutexCallback -> IO ()
-- | 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
type CEventType = CInt
-- | 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
type CEvFlagType = CInt
ev_read :: CEventType
ev_write :: CEventType
type EvIoPtr = Ptr EvIo
-- | 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.
type IoCallback = EvLoopPtr -> EvIoPtr -> CEventType -> IO ()
-- | Makes a new ev_io struct using malloc. You are
-- responsible for freeing it with freeEvIo.
mkEvIo :: IO (EvIoPtr)
-- | free() an EvIoPtr
freeEvIo :: EvIoPtr -> IO ()
-- | 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.
mkIoCallback :: IoCallback -> IO (FunPtr IoCallback)
freeIoCallback :: FunPtr IoCallback -> IO ()
evIoInit :: EvIoPtr -> FunPtr IoCallback -> CInt -> CEventType -> IO ()
evIoStart :: EvLoopPtr -> EvIoPtr -> IO ()
evIoStop :: EvLoopPtr -> EvIoPtr -> IO ()
data EvTimer
type EvTimerPtr = Ptr EvTimer
-- | A TimerCallback is called when a timer expires. It takes a
-- pointer to an ev_loop structure, a pointer to an
-- ev_io structure, and an (unused?) event mask.
type TimerCallback = EvLoopPtr -> EvTimerPtr -> CEventType -> IO ()
-- | Makes a new ev_timer struct using malloc. You are
-- responsible for freeing it with freeEvTimer.
mkEvTimer :: IO (EvTimerPtr)
-- | free() an EvTimer
freeEvTimer :: EvTimerPtr -> IO ()
-- | 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.
mkTimerCallback :: TimerCallback -> IO (FunPtr TimerCallback)
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)
type EvAsyncPtr = Ptr EvAsync
-- | An AsyncCallback is called when you wakeup an event loop with
-- ev_async_send
type AsyncCallback = EvLoopPtr -> EvAsyncPtr -> CEventType -> IO ()
-- | Makes a new ev_async struct using malloc. You are
-- responsible for freeing it with freeEvAsync.
mkEvAsync :: IO (EvAsyncPtr)
-- | free() an EvAsync
freeEvAsync :: EvAsyncPtr -> IO ()
evAsyncInit :: EvAsyncPtr -> FunPtr AsyncCallback -> IO ()
evAsyncSend :: EvLoopPtr -> EvAsyncPtr -> IO ()
evAsyncStart :: EvLoopPtr -> EvAsyncPtr -> IO ()
evAsyncStop :: EvLoopPtr -> EvAsyncPtr -> IO ()
-- | 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.
mkAsyncCallback :: AsyncCallback -> IO (FunPtr AsyncCallback)
freeAsyncCallback :: FunPtr AsyncCallback -> IO ()
-- | Libev timestamp values are C doubles containing the (floating) number
-- of seconds since Jan 1, 1970.
type EvTimestamp = CDouble
-- | Fetch a the cached copy of the current time from a loop.
evNow :: EvLoopPtr -> IO EvTimestamp
-- | Fetches the current time from the operating system. Usually
-- evNow is preferred since it avoids a context switch by
-- returning a cached value.
evTime :: IO EvTimestamp
-- | Calls accept() and sets the socket non-blocking.
c_accept :: CInt -> IO (CInt)
c_close :: CInt -> IO (CInt)
c_read :: CInt -> CString -> CSize -> IO (CSize)
c_write :: CInt -> CString -> CSize -> IO (CSize)
c_setnonblocking :: CInt -> IO ()
instance Storable EvAsync
instance Storable EvTimer
instance Storable EvIo
instance Storable EvWatcher