{-# LANGUAGE RankNTypes                         #-}
{-# LANGUAGE GeneralizedNewtypeDeriving         #-}
{-# LANGUAGE MultiParamTypeClasses              #-}
{-# LANGUAGE TypeFamilies                       #-}
{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}

-- |
-- Module      : System.ZMQ4.Monadic
-- Copyright   : (c) 2013 Toralf Wittner
-- License     : MIT
-- Maintainer  : Toralf Wittner <tw@dtex.org>
-- Stability   : experimental
-- Portability : non-portable
--
-- This modules exposes a monadic interface of 'System.ZMQ4'. Actions run
-- inside a 'ZMQ' monad and 'Socket's are guaranteed not to leak outside
-- their corresponding 'runZMQ' scope. Running 'ZMQ' computations
-- asynchronously is directly supported through 'async'.
module System.ZMQ4.Monadic
  ( -- * Type Definitions
    ZMQ
  , Socket
  , Z.Flag              (..)
  , Z.Switch            (..)
  , Z.Timeout
  , Z.Event             (..)
  , Z.EventType         (..)
  , Z.EventMsg          (..)
  , Z.Poll              (..)
  , Z.KeyFormat         (..)
  , Z.SecurityMechanism (..)

  -- ** Socket type-classes
  , Z.SocketType
  , Z.Sender
  , Z.Receiver
  , Z.Subscriber
  , Z.SocketLike
  , Z.Conflatable
  , Z.SendProbe

  -- ** Socket Types
  , Z.Pair   (..)
  , Z.Pub    (..)
  , Z.Sub    (..)
  , Z.XPub   (..)
  , Z.XSub   (..)
  , Z.Req    (..)
  , Z.Rep    (..)
  , Z.Dealer (..)
  , Z.Router (..)
  , Z.Pull   (..)
  , Z.Push   (..)
  , Z.Stream (..)

  -- * General Operations
  , version
  , runZMQ
  , async
  , socket

  -- * ZMQ Options (Read)
  , ioThreads
  , maxSockets

  -- * ZMQ Options (Write)
  , setIoThreads
  , setMaxSockets

  -- * Socket operations
  , close
  , bind
  , unbind
  , connect
  , disconnect
  , send
  , send'
  , sendMulti
  , receive
  , receiveMulti
  , subscribe
  , unsubscribe
  , proxy
  , monitor
  , socketMonitor
  , Z.poll

  -- * Socket Options (Read)
  , affinity
  , backlog
  , conflate
  , curvePublicKey
  , curveSecretKey
  , curveServerKey
  , delayAttachOnConnect
  , events
  , fileDescriptor
  , identity
  , immediate
  , ipv4Only
  , ipv6
  , lastEndpoint
  , linger
  , maxMessageSize
  , mcastHops
  , mechanism
  , moreToReceive
  , plainServer
  , plainPassword
  , plainUserName
  , rate
  , receiveBuffer
  , receiveHighWM
  , receiveTimeout
  , reconnectInterval
  , reconnectIntervalMax
  , recoveryInterval
  , sendBuffer
  , sendHighWM
  , sendTimeout
  , tcpKeepAlive
  , tcpKeepAliveCount
  , tcpKeepAliveIdle
  , tcpKeepAliveInterval
  , zapDomain

  -- * Socket Options (Write)
  , setAffinity
  , setBacklog
  , setConflate
  , setCurveServer
  , setCurvePublicKey
  , setCurveSecretKey
  , setCurveServerKey
  , setDelayAttachOnConnect
  , setIdentity
  , setImmediate
  , setIpv4Only
  , setIpv6
  , setLinger
  , setMaxMessageSize
  , setMcastHops
  , setPlainServer
  , setPlainPassword
  , setPlainUserName
  , setProbeRouter
  , setRate
  , setReceiveBuffer
  , setReceiveHighWM
  , setReceiveTimeout
  , setReconnectInterval
  , setReconnectIntervalMax
  , setRecoveryInterval
  , setReqCorrelate
  , setReqRelaxed
  , setRouterMandatory
  , setSendBuffer
  , setSendHighWM
  , setSendTimeout
  , setTcpAcceptFilter
  , setTcpKeepAlive
  , setTcpKeepAliveCount
  , setTcpKeepAliveIdle
  , setTcpKeepAliveInterval
  , setXPubVerbose
  , setZapDomain

  -- * Error Handling
  , Z.ZMQError
  , Z.errno
  , Z.source
  , Z.message

  -- * Re-exports
  , Control.Monad.IO.Class.liftIO
  , Data.Restricted.restrict
  , Data.Restricted.toRestricted

  -- * Low-level Functions
  , waitRead
  , waitWrite
  , I.z85Encode
  , I.z85Decode
  , Z.curveKeyPair
  ) where

import Control.Applicative
import Control.Concurrent.Async (Async)
import Control.Monad
import Control.Monad.Base (MonadBase(..))
import Control.Monad.Catch
import Control.Monad.IO.Class
import Control.Monad.Trans.Control (MonadBaseControl(..))
import Control.Monad.Trans.Reader
import Data.Int
import Data.IORef
import Data.List.NonEmpty (NonEmpty)
import Data.Restricted
import Data.Word
import Data.ByteString (ByteString)
import System.Posix.Types (Fd)
import Prelude

import qualified Control.Concurrent.Async as A
import qualified Control.Exception        as E
import qualified Control.Monad.Catch      as C
import qualified Data.ByteString.Lazy     as Lazy
import qualified System.ZMQ4              as Z
import qualified System.ZMQ4.Internal     as I

data ZMQEnv = ZMQEnv
  { ZMQEnv -> IORef Word
_refcount :: !(IORef Word)
  , ZMQEnv -> Context
_context  :: !Z.Context
  , ZMQEnv -> IORef [SocketRepr]
_sockets  :: !(IORef [I.SocketRepr])
  }

-- | The ZMQ monad is modeled after 'Control.Monad.ST' and encapsulates
-- a 'System.ZMQ4.Context'. It uses the uninstantiated type variable 'z' to
-- distinguish different invoctions of 'runZMQ' and to prevent
-- unintented use of 'Socket's outside their scope. Cf. the paper
-- of John Launchbury and Simon Peyton Jones /Lazy Functional State Threads/.
newtype ZMQ z a = ZMQ { ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq :: ReaderT ZMQEnv IO a }
    deriving (MonadBase IO)

-- | The ZMQ socket, parameterised by 'SocketType' and belonging to
-- a particular 'ZMQ' thread.
newtype Socket z t = Socket { Socket z t -> Socket t
_unsocket :: Z.Socket t }

instance I.SocketLike (Socket z) where
    toSocket :: Socket z t -> Socket t
toSocket = Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

instance Monad (ZMQ z) where
    return :: a -> ZMQ z a
return = ReaderT ZMQEnv IO a -> ZMQ z a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ z a)
-> (a -> ReaderT ZMQEnv IO a) -> a -> ZMQ z a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReaderT ZMQEnv IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
    (ZMQ m :: ReaderT ZMQEnv IO a
m) >>= :: ZMQ z a -> (a -> ZMQ z b) -> ZMQ z b
>>= f :: a -> ZMQ z b
f = ReaderT ZMQEnv IO b -> ZMQ z b
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO b -> ZMQ z b) -> ReaderT ZMQEnv IO b -> ZMQ z b
forall a b. (a -> b) -> a -> b
$ ReaderT ZMQEnv IO a
m ReaderT ZMQEnv IO a
-> (a -> ReaderT ZMQEnv IO b) -> ReaderT ZMQEnv IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ZMQ z b -> ReaderT ZMQEnv IO b
forall z a. ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq (ZMQ z b -> ReaderT ZMQEnv IO b)
-> (a -> ZMQ z b) -> a -> ReaderT ZMQEnv IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ZMQ z b
f

instance MonadIO (ZMQ z) where
    liftIO :: IO a -> ZMQ z a
liftIO m :: IO a
m = ReaderT ZMQEnv IO a -> ZMQ z a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ z a) -> ReaderT ZMQEnv IO a -> ZMQ z a
forall a b. (a -> b) -> a -> b
$! IO a -> ReaderT ZMQEnv IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO a
m

instance MonadBaseControl IO (ZMQ z) where
    type StM (ZMQ z) a = a
    liftBaseWith :: (RunInBase (ZMQ z) IO -> IO a) -> ZMQ z a
liftBaseWith = \f :: RunInBase (ZMQ z) IO -> IO a
f -> ReaderT ZMQEnv IO a -> ZMQ z a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ z a) -> ReaderT ZMQEnv IO a -> ZMQ z a
forall a b. (a -> b) -> a -> b
$ (RunInBase (ReaderT ZMQEnv IO) IO -> IO a) -> ReaderT ZMQEnv IO a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith ((RunInBase (ReaderT ZMQEnv IO) IO -> IO a) -> ReaderT ZMQEnv IO a)
-> (RunInBase (ReaderT ZMQEnv IO) IO -> IO a)
-> ReaderT ZMQEnv IO a
forall a b. (a -> b) -> a -> b
$ \q :: RunInBase (ReaderT ZMQEnv IO) IO
q -> RunInBase (ZMQ z) IO -> IO a
f (ReaderT ZMQEnv IO a -> IO a
RunInBase (ReaderT ZMQEnv IO) IO
q (ReaderT ZMQEnv IO a -> IO a)
-> (ZMQ z a -> ReaderT ZMQEnv IO a) -> ZMQ z a -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZMQ z a -> ReaderT ZMQEnv IO a
forall z a. ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq)
    restoreM :: StM (ZMQ z) a -> ZMQ z a
restoreM = ReaderT ZMQEnv IO a -> ZMQ z a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ z a)
-> (a -> ReaderT ZMQEnv IO a) -> a -> ZMQ z a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReaderT ZMQEnv IO a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM

instance MonadThrow (ZMQ z) where
    throwM :: e -> ZMQ z a
throwM = ReaderT ZMQEnv IO a -> ZMQ z a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ z a)
-> (e -> ReaderT ZMQEnv IO a) -> e -> ZMQ z a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> ReaderT ZMQEnv IO a
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
C.throwM

instance MonadCatch (ZMQ z) where
    catch :: ZMQ z a -> (e -> ZMQ z a) -> ZMQ z a
catch (ZMQ m :: ReaderT ZMQEnv IO a
m) f :: e -> ZMQ z a
f = ReaderT ZMQEnv IO a -> ZMQ z a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ z a) -> ReaderT ZMQEnv IO a -> ZMQ z a
forall a b. (a -> b) -> a -> b
$ ReaderT ZMQEnv IO a
m ReaderT ZMQEnv IO a
-> (e -> ReaderT ZMQEnv IO a) -> ReaderT ZMQEnv IO a
forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
m a -> (e -> m a) -> m a
`C.catch` (ZMQ z a -> ReaderT ZMQEnv IO a
forall z a. ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq (ZMQ z a -> ReaderT ZMQEnv IO a)
-> (e -> ZMQ z a) -> e -> ReaderT ZMQEnv IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> ZMQ z a
f)

instance MonadMask (ZMQ z) where
    mask :: ((forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b) -> ZMQ z b
mask a :: (forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b
a = ReaderT ZMQEnv IO b -> ZMQ z b
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO b -> ZMQ z b)
-> ((ZMQEnv -> IO b) -> ReaderT ZMQEnv IO b)
-> (ZMQEnv -> IO b)
-> ZMQ z b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ZMQEnv -> IO b) -> ReaderT ZMQEnv IO b
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((ZMQEnv -> IO b) -> ZMQ z b) -> (ZMQEnv -> IO b) -> ZMQ z b
forall a b. (a -> b) -> a -> b
$ \env :: ZMQEnv
env ->
        ((forall a. IO a -> IO a) -> IO b) -> IO b
forall (m :: * -> *) b.
MonadMask m =>
((forall a. m a -> m a) -> m b) -> m b
C.mask (((forall a. IO a -> IO a) -> IO b) -> IO b)
-> ((forall a. IO a -> IO a) -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \restore :: forall a. IO a -> IO a
restore ->
            let f :: forall r a . ZMQ r a -> ZMQ r a
                f :: ZMQ r a -> ZMQ r a
f (ZMQ (ReaderT b :: ZMQEnv -> IO a
b)) = ReaderT ZMQEnv IO a -> ZMQ r a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ r a) -> ReaderT ZMQEnv IO a -> ZMQ r a
forall a b. (a -> b) -> a -> b
$ (ZMQEnv -> IO a) -> ReaderT ZMQEnv IO a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (IO a -> IO a
forall a. IO a -> IO a
restore (IO a -> IO a) -> (ZMQEnv -> IO a) -> ZMQEnv -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZMQEnv -> IO a
b)
            in ReaderT ZMQEnv IO b -> ZMQEnv -> IO b
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (ZMQ z b -> ReaderT ZMQEnv IO b
forall z a. ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq ((forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b
a ((forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b)
-> (forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b
forall a b. (a -> b) -> a -> b
$ forall a. ZMQ z a -> ZMQ z a
forall r a. ZMQ r a -> ZMQ r a
f)) ZMQEnv
env

    uninterruptibleMask :: ((forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b) -> ZMQ z b
uninterruptibleMask a :: (forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b
a = ReaderT ZMQEnv IO b -> ZMQ z b
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO b -> ZMQ z b)
-> ((ZMQEnv -> IO b) -> ReaderT ZMQEnv IO b)
-> (ZMQEnv -> IO b)
-> ZMQ z b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ZMQEnv -> IO b) -> ReaderT ZMQEnv IO b
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((ZMQEnv -> IO b) -> ZMQ z b) -> (ZMQEnv -> IO b) -> ZMQ z b
forall a b. (a -> b) -> a -> b
$ \env :: ZMQEnv
env ->
        ((forall a. IO a -> IO a) -> IO b) -> IO b
forall (m :: * -> *) b.
MonadMask m =>
((forall a. m a -> m a) -> m b) -> m b
C.uninterruptibleMask (((forall a. IO a -> IO a) -> IO b) -> IO b)
-> ((forall a. IO a -> IO a) -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \restore :: forall a. IO a -> IO a
restore ->
            let f :: forall r a . ZMQ r a -> ZMQ r a
                f :: ZMQ r a -> ZMQ r a
f (ZMQ (ReaderT b :: ZMQEnv -> IO a
b)) = ReaderT ZMQEnv IO a -> ZMQ r a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ r a) -> ReaderT ZMQEnv IO a -> ZMQ r a
forall a b. (a -> b) -> a -> b
$ (ZMQEnv -> IO a) -> ReaderT ZMQEnv IO a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (IO a -> IO a
forall a. IO a -> IO a
restore (IO a -> IO a) -> (ZMQEnv -> IO a) -> ZMQEnv -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZMQEnv -> IO a
b)
            in ReaderT ZMQEnv IO b -> ZMQEnv -> IO b
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (ZMQ z b -> ReaderT ZMQEnv IO b
forall z a. ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq ((forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b
a ((forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b)
-> (forall a. ZMQ z a -> ZMQ z a) -> ZMQ z b
forall a b. (a -> b) -> a -> b
$ forall a. ZMQ z a -> ZMQ z a
forall r a. ZMQ r a -> ZMQ r a
f)) ZMQEnv
env

instance Functor (ZMQ z) where
    fmap :: (a -> b) -> ZMQ z a -> ZMQ z b
fmap = (a -> b) -> ZMQ z a -> ZMQ z b
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM

instance Applicative (ZMQ z) where
    pure :: a -> ZMQ z a
pure  = a -> ZMQ z a
forall (m :: * -> *) a. Monad m => a -> m a
return
    <*> :: ZMQ z (a -> b) -> ZMQ z a -> ZMQ z b
(<*>) = ZMQ z (a -> b) -> ZMQ z a -> ZMQ z b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap

-- | Return the value computed by the given 'ZMQ' monad. Rank-2
-- polymorphism is used to prevent leaking of 'z'.
-- An invocation of 'runZMQ' will internally create a 'System.ZMQ4.Context'
-- and all actions are executed relative to this context. On finish the
-- context will be disposed, but see 'async'.
runZMQ :: MonadIO m => (forall z. ZMQ z a) -> m a
runZMQ :: (forall z. ZMQ z a) -> m a
runZMQ z :: forall z. ZMQ z a
z = IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ IO ZMQEnv -> (ZMQEnv -> IO ()) -> (ZMQEnv -> IO a) -> IO a
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
E.bracket IO ZMQEnv
make ZMQEnv -> IO ()
term (ReaderT ZMQEnv IO a -> ZMQEnv -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (ZMQ Any a -> ReaderT ZMQEnv IO a
forall z a. ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq ZMQ Any a
forall z. ZMQ z a
z))
  where
    make :: IO ZMQEnv
make = IORef Word -> Context -> IORef [SocketRepr] -> ZMQEnv
ZMQEnv (IORef Word -> Context -> IORef [SocketRepr] -> ZMQEnv)
-> IO (IORef Word) -> IO (Context -> IORef [SocketRepr] -> ZMQEnv)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word -> IO (IORef Word)
forall a. a -> IO (IORef a)
newIORef 1 IO (Context -> IORef [SocketRepr] -> ZMQEnv)
-> IO Context -> IO (IORef [SocketRepr] -> ZMQEnv)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IO Context
Z.context IO (IORef [SocketRepr] -> ZMQEnv)
-> IO (IORef [SocketRepr]) -> IO ZMQEnv
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [SocketRepr] -> IO (IORef [SocketRepr])
forall a. a -> IO (IORef a)
newIORef []

-- | Run the given 'ZMQ' computation asynchronously, i.e. this function
-- runs the computation in a new thread using 'Control.Concurrent.Async.async'.
-- /N.B./ reference counting is used to prolong the lifetime of the
-- 'System.ZMQ.Context' encapsulated in 'ZMQ' as necessary, e.g.:
--
-- @
-- runZMQ $ do
--     s <- socket Pair
--     async $ do
--         liftIO (threadDelay 10000000)
--         identity s >>= liftIO . print
-- @
--
-- Here, 'runZMQ' will finish before the code section in 'async', but due to
-- reference counting, the 'System.ZMQ4.Context' will only be disposed after
-- 'async' finishes as well.
async :: ZMQ z a -> ZMQ z (Async a)
async :: ZMQ z a -> ZMQ z (Async a)
async z :: ZMQ z a
z = ReaderT ZMQEnv IO (Async a) -> ZMQ z (Async a)
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO (Async a) -> ZMQ z (Async a))
-> ReaderT ZMQEnv IO (Async a) -> ZMQ z (Async a)
forall a b. (a -> b) -> a -> b
$ do
    ZMQEnv
e <- ReaderT ZMQEnv IO ZMQEnv
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask
    IO () -> ReaderT ZMQEnv IO ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT ZMQEnv IO ()) -> IO () -> ReaderT ZMQEnv IO ()
forall a b. (a -> b) -> a -> b
$ IORef Word -> (Word -> (Word, ())) -> IO ()
forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef (ZMQEnv -> IORef Word
_refcount ZMQEnv
e) ((Word -> (Word, ())) -> IO ()) -> (Word -> (Word, ())) -> IO ()
forall a b. (a -> b) -> a -> b
$ \n :: Word
n -> (Word -> Word
forall a. Enum a => a -> a
succ Word
n, ())
    IO (Async a) -> ReaderT ZMQEnv IO (Async a)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Async a) -> ReaderT ZMQEnv IO (Async a))
-> (IO a -> IO (Async a)) -> IO a -> ReaderT ZMQEnv IO (Async a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> IO (Async a)
forall a. IO a -> IO (Async a)
A.async (IO a -> ReaderT ZMQEnv IO (Async a))
-> IO a -> ReaderT ZMQEnv IO (Async a)
forall a b. (a -> b) -> a -> b
$ (ReaderT ZMQEnv IO a -> ZMQEnv -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (ZMQ z a -> ReaderT ZMQEnv IO a
forall z a. ZMQ z a -> ReaderT ZMQEnv IO a
_unzmq ZMQ z a
z) ZMQEnv
e) IO a -> IO () -> IO a
forall a b. IO a -> IO b -> IO a
`E.finally` ZMQEnv -> IO ()
term ZMQEnv
e

ioThreads :: ZMQ z Word
ioThreads :: ZMQ z Word
ioThreads = (Context -> IO Word) -> ZMQ z Word
forall a z. (Context -> IO a) -> ZMQ z a
onContext Context -> IO Word
Z.ioThreads

setIoThreads :: Word -> ZMQ z ()
setIoThreads :: Word -> ZMQ z ()
setIoThreads = (Context -> IO ()) -> ZMQ z ()
forall a z. (Context -> IO a) -> ZMQ z a
onContext ((Context -> IO ()) -> ZMQ z ())
-> (Word -> Context -> IO ()) -> Word -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Context -> IO ()
Z.setIoThreads

maxSockets :: ZMQ z Word
maxSockets :: ZMQ z Word
maxSockets = (Context -> IO Word) -> ZMQ z Word
forall a z. (Context -> IO a) -> ZMQ z a
onContext Context -> IO Word
Z.maxSockets

setMaxSockets :: Word -> ZMQ z ()
setMaxSockets :: Word -> ZMQ z ()
setMaxSockets = (Context -> IO ()) -> ZMQ z ()
forall a z. (Context -> IO a) -> ZMQ z a
onContext ((Context -> IO ()) -> ZMQ z ())
-> (Word -> Context -> IO ()) -> Word -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Context -> IO ()
Z.setMaxSockets

socket :: Z.SocketType t => t -> ZMQ z (Socket z t)
socket :: t -> ZMQ z (Socket z t)
socket t :: t
t = ReaderT ZMQEnv IO (Socket z t) -> ZMQ z (Socket z t)
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO (Socket z t) -> ZMQ z (Socket z t))
-> ReaderT ZMQEnv IO (Socket z t) -> ZMQ z (Socket z t)
forall a b. (a -> b) -> a -> b
$ do
    Context
c <- (ZMQEnv -> Context) -> ReaderT ZMQEnv IO Context
forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks ZMQEnv -> Context
_context
    IORef [SocketRepr]
s <- (ZMQEnv -> IORef [SocketRepr])
-> ReaderT ZMQEnv IO (IORef [SocketRepr])
forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks ZMQEnv -> IORef [SocketRepr]
_sockets
    SocketRepr
x <- IO SocketRepr -> ReaderT ZMQEnv IO SocketRepr
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SocketRepr -> ReaderT ZMQEnv IO SocketRepr)
-> IO SocketRepr -> ReaderT ZMQEnv IO SocketRepr
forall a b. (a -> b) -> a -> b
$ t -> Context -> IO SocketRepr
forall t. SocketType t => t -> Context -> IO SocketRepr
I.mkSocketRepr t
t Context
c
    IO () -> ReaderT ZMQEnv IO ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT ZMQEnv IO ()) -> IO () -> ReaderT ZMQEnv IO ()
forall a b. (a -> b) -> a -> b
$ IORef [SocketRepr] -> ([SocketRepr] -> ([SocketRepr], ())) -> IO ()
forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef IORef [SocketRepr]
s (([SocketRepr] -> ([SocketRepr], ())) -> IO ())
-> ([SocketRepr] -> ([SocketRepr], ())) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ss :: [SocketRepr]
ss -> (SocketRepr
xSocketRepr -> [SocketRepr] -> [SocketRepr]
forall a. a -> [a] -> [a]
:[SocketRepr]
ss, ())
    Socket z t -> ReaderT ZMQEnv IO (Socket z t)
forall (m :: * -> *) a. Monad m => a -> m a
return (Socket t -> Socket z t
forall z t. Socket t -> Socket z t
Socket (SocketRepr -> Socket t
forall a. SocketRepr -> Socket a
I.Socket SocketRepr
x))

version :: ZMQ z (Int, Int, Int)
version :: ZMQ z (Int, Int, Int)
version = IO (Int, Int, Int) -> ZMQ z (Int, Int, Int)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int, Int, Int) -> ZMQ z (Int, Int, Int))
-> IO (Int, Int, Int) -> ZMQ z (Int, Int, Int)
forall a b. (a -> b) -> a -> b
$! IO (Int, Int, Int)
Z.version

-- * Socket operations

close :: Socket z t -> ZMQ z ()
close :: Socket z t -> ZMQ z ()
close = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ()
forall a. Socket a -> IO ()
Z.close (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

bind :: Socket z t -> String -> ZMQ z ()
bind :: Socket z t -> String -> ZMQ z ()
bind s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ()) -> (String -> IO ()) -> String -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> String -> IO ()
forall a. Socket a -> String -> IO ()
Z.bind (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

unbind :: Socket z t -> String -> ZMQ z ()
unbind :: Socket z t -> String -> ZMQ z ()
unbind s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ()) -> (String -> IO ()) -> String -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> String -> IO ()
forall a. Socket a -> String -> IO ()
Z.unbind (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

connect :: Socket z t -> String -> ZMQ z ()
connect :: Socket z t -> String -> ZMQ z ()
connect s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ()) -> (String -> IO ()) -> String -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> String -> IO ()
forall a. Socket a -> String -> IO ()
Z.connect (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

disconnect :: Socket z t -> String -> ZMQ z ()
disconnect :: Socket z t -> String -> ZMQ z ()
disconnect s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ()) -> (String -> IO ()) -> String -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> String -> IO ()
forall a. Socket a -> String -> IO ()
Z.disconnect (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

send :: Z.Sender t => Socket z t -> [Z.Flag] -> ByteString -> ZMQ z ()
send :: Socket z t -> [Flag] -> ByteString -> ZMQ z ()
send s :: Socket z t
s f :: [Flag]
f = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (ByteString -> IO ()) -> ByteString -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> [Flag] -> ByteString -> IO ()
forall a. Sender a => Socket a -> [Flag] -> ByteString -> IO ()
Z.send (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s) [Flag]
f

send' :: Z.Sender t => Socket z t -> [Z.Flag] -> Lazy.ByteString -> ZMQ z ()
send' :: Socket z t -> [Flag] -> ByteString -> ZMQ z ()
send' s :: Socket z t
s f :: [Flag]
f = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (ByteString -> IO ()) -> ByteString -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> [Flag] -> ByteString -> IO ()
forall a. Sender a => Socket a -> [Flag] -> ByteString -> IO ()
Z.send' (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s) [Flag]
f

sendMulti :: Z.Sender t => Socket z t -> NonEmpty ByteString -> ZMQ z ()
sendMulti :: Socket z t -> NonEmpty ByteString -> ZMQ z ()
sendMulti s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (NonEmpty ByteString -> IO ())
-> NonEmpty ByteString
-> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> NonEmpty ByteString -> IO ()
forall a. Sender a => Socket a -> NonEmpty ByteString -> IO ()
Z.sendMulti (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

receive :: Z.Receiver t => Socket z t -> ZMQ z ByteString
receive :: Socket z t -> ZMQ z ByteString
receive = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ByteString
forall a. Receiver a => Socket a -> IO ByteString
Z.receive (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

receiveMulti :: Z.Receiver t => Socket z t -> ZMQ z [ByteString]
receiveMulti :: Socket z t -> ZMQ z [ByteString]
receiveMulti = IO [ByteString] -> ZMQ z [ByteString]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ByteString] -> ZMQ z [ByteString])
-> (Socket z t -> IO [ByteString])
-> Socket z t
-> ZMQ z [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO [ByteString]
forall a. Receiver a => Socket a -> IO [ByteString]
Z.receiveMulti (Socket t -> IO [ByteString])
-> (Socket z t -> Socket t) -> Socket z t -> IO [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

subscribe :: Z.Subscriber t => Socket z t -> ByteString -> ZMQ z ()
subscribe :: Socket z t -> ByteString -> ZMQ z ()
subscribe s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (ByteString -> IO ()) -> ByteString -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> ByteString -> IO ()
forall a. Subscriber a => Socket a -> ByteString -> IO ()
Z.subscribe (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

unsubscribe :: Z.Subscriber t => Socket z t -> ByteString -> ZMQ z ()
unsubscribe :: Socket z t -> ByteString -> ZMQ z ()
unsubscribe s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (ByteString -> IO ()) -> ByteString -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> ByteString -> IO ()
forall a. Subscriber a => Socket a -> ByteString -> IO ()
Z.unsubscribe (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

proxy :: Socket z a -> Socket z b -> Maybe (Socket z c) -> ZMQ z ()
proxy :: Socket z a -> Socket z b -> Maybe (Socket z c) -> ZMQ z ()
proxy a :: Socket z a
a b :: Socket z b
b c :: Maybe (Socket z c)
c = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ()) -> IO () -> ZMQ z ()
forall a b. (a -> b) -> a -> b
$ Socket a -> Socket b -> Maybe (Socket c) -> IO ()
forall a b c. Socket a -> Socket b -> Maybe (Socket c) -> IO ()
Z.proxy (Socket z a -> Socket a
forall z t. Socket z t -> Socket t
_unsocket Socket z a
a) (Socket z b -> Socket b
forall z t. Socket z t -> Socket t
_unsocket Socket z b
b) (Socket z c -> Socket c
forall z t. Socket z t -> Socket t
_unsocket (Socket z c -> Socket c) -> Maybe (Socket z c) -> Maybe (Socket c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Socket z c)
c)

monitor :: [Z.EventType] -> Socket z t -> ZMQ z (Bool -> IO (Maybe Z.EventMsg))
monitor :: [EventType] -> Socket z t -> ZMQ z (Bool -> IO (Maybe EventMsg))
monitor es :: [EventType]
es s :: Socket z t
s = (Context -> IO (Bool -> IO (Maybe EventMsg)))
-> ZMQ z (Bool -> IO (Maybe EventMsg))
forall a z. (Context -> IO a) -> ZMQ z a
onContext ((Context -> IO (Bool -> IO (Maybe EventMsg)))
 -> ZMQ z (Bool -> IO (Maybe EventMsg)))
-> (Context -> IO (Bool -> IO (Maybe EventMsg)))
-> ZMQ z (Bool -> IO (Maybe EventMsg))
forall a b. (a -> b) -> a -> b
$ \ctx :: Context
ctx -> [EventType]
-> Context -> Socket t -> IO (Bool -> IO (Maybe EventMsg))
forall a.
[EventType]
-> Context -> Socket a -> IO (Bool -> IO (Maybe EventMsg))
Z.monitor [EventType]
es Context
ctx (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

socketMonitor :: [Z.EventType] -> String -> Socket z t -> ZMQ z ()
socketMonitor :: [EventType] -> String -> Socket z t -> ZMQ z ()
socketMonitor es :: [EventType]
es addr :: String
addr s :: Socket z t
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ()) -> IO () -> ZMQ z ()
forall a b. (a -> b) -> a -> b
$ [EventType] -> String -> Socket t -> IO ()
forall a. [EventType] -> String -> Socket a -> IO ()
Z.socketMonitor [EventType]
es String
addr (Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket Socket z t
s)

-- * Socket Options (Read)

affinity :: Socket z t -> ZMQ z Word64
affinity :: Socket z t -> ZMQ z Word64
affinity = IO Word64 -> ZMQ z Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> ZMQ z Word64)
-> (Socket z t -> IO Word64) -> Socket z t -> ZMQ z Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Word64
forall a. Socket a -> IO Word64
Z.affinity (Socket t -> IO Word64)
-> (Socket z t -> Socket t) -> Socket z t -> IO Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

backlog :: Socket z t -> ZMQ z Int
backlog :: Socket z t -> ZMQ z Int
backlog = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.backlog (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

conflate :: Z.Conflatable t => Socket z t -> ZMQ z Bool
conflate :: Socket z t -> ZMQ z Bool
conflate = IO Bool -> ZMQ z Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> ZMQ z Bool)
-> (Socket z t -> IO Bool) -> Socket z t -> ZMQ z Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Bool
forall a. Conflatable a => Socket a -> IO Bool
Z.conflate (Socket t -> IO Bool)
-> (Socket z t -> Socket t) -> Socket z t -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

curvePublicKey :: Z.KeyFormat f -> Socket z t -> ZMQ z ByteString
curvePublicKey :: KeyFormat f -> Socket z t -> ZMQ z ByteString
curvePublicKey f :: KeyFormat f
f = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyFormat f -> Socket t -> IO ByteString
forall f a. KeyFormat f -> Socket a -> IO ByteString
Z.curvePublicKey KeyFormat f
f (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

curveSecretKey :: Z.KeyFormat f -> Socket z t -> ZMQ z ByteString
curveSecretKey :: KeyFormat f -> Socket z t -> ZMQ z ByteString
curveSecretKey f :: KeyFormat f
f = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyFormat f -> Socket t -> IO ByteString
forall f a. KeyFormat f -> Socket a -> IO ByteString
Z.curveSecretKey KeyFormat f
f (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

curveServerKey :: Z.KeyFormat f -> Socket z t -> ZMQ z ByteString
curveServerKey :: KeyFormat f -> Socket z t -> ZMQ z ByteString
curveServerKey f :: KeyFormat f
f = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyFormat f -> Socket t -> IO ByteString
forall f a. KeyFormat f -> Socket a -> IO ByteString
Z.curveServerKey KeyFormat f
f (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

delayAttachOnConnect :: Socket z t -> ZMQ z Bool
delayAttachOnConnect :: Socket z t -> ZMQ z Bool
delayAttachOnConnect = IO Bool -> ZMQ z Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> ZMQ z Bool)
-> (Socket z t -> IO Bool) -> Socket z t -> ZMQ z Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Bool
forall a. Socket a -> IO Bool
Z.delayAttachOnConnect (Socket t -> IO Bool)
-> (Socket z t -> Socket t) -> Socket z t -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket
{-# DEPRECATED delayAttachOnConnect "Use immediate" #-}

events :: Socket z t -> ZMQ z [Z.Event]
events :: Socket z t -> ZMQ z [Event]
events = IO [Event] -> ZMQ z [Event]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Event] -> ZMQ z [Event])
-> (Socket z t -> IO [Event]) -> Socket z t -> ZMQ z [Event]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO [Event]
forall a. Socket a -> IO [Event]
Z.events (Socket t -> IO [Event])
-> (Socket z t -> Socket t) -> Socket z t -> IO [Event]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

fileDescriptor :: Socket z t -> ZMQ z Fd
fileDescriptor :: Socket z t -> ZMQ z Fd
fileDescriptor = IO Fd -> ZMQ z Fd
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Fd -> ZMQ z Fd)
-> (Socket z t -> IO Fd) -> Socket z t -> ZMQ z Fd
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Fd
forall a. Socket a -> IO Fd
Z.fileDescriptor (Socket t -> IO Fd)
-> (Socket z t -> Socket t) -> Socket z t -> IO Fd
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

identity :: Socket z t -> ZMQ z ByteString
identity :: Socket z t -> ZMQ z ByteString
identity = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ByteString
forall a. Socket a -> IO ByteString
Z.identity (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

immediate :: Socket z t -> ZMQ z Bool
immediate :: Socket z t -> ZMQ z Bool
immediate = IO Bool -> ZMQ z Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> ZMQ z Bool)
-> (Socket z t -> IO Bool) -> Socket z t -> ZMQ z Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Bool
forall a. Socket a -> IO Bool
Z.immediate (Socket t -> IO Bool)
-> (Socket z t -> Socket t) -> Socket z t -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

ipv4Only :: Socket z t -> ZMQ z Bool
ipv4Only :: Socket z t -> ZMQ z Bool
ipv4Only = IO Bool -> ZMQ z Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> ZMQ z Bool)
-> (Socket z t -> IO Bool) -> Socket z t -> ZMQ z Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Bool
forall a. Socket a -> IO Bool
Z.ipv4Only (Socket t -> IO Bool)
-> (Socket z t -> Socket t) -> Socket z t -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket
{-# DEPRECATED ipv4Only "Use ipv6" #-}

ipv6 :: Socket z t -> ZMQ z Bool
ipv6 :: Socket z t -> ZMQ z Bool
ipv6 = IO Bool -> ZMQ z Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> ZMQ z Bool)
-> (Socket z t -> IO Bool) -> Socket z t -> ZMQ z Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Bool
forall a. Socket a -> IO Bool
Z.ipv6 (Socket t -> IO Bool)
-> (Socket z t -> Socket t) -> Socket z t -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

lastEndpoint :: Socket z t -> ZMQ z String
lastEndpoint :: Socket z t -> ZMQ z String
lastEndpoint = IO String -> ZMQ z String
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> ZMQ z String)
-> (Socket z t -> IO String) -> Socket z t -> ZMQ z String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO String
forall a. Socket a -> IO String
Z.lastEndpoint (Socket t -> IO String)
-> (Socket z t -> Socket t) -> Socket z t -> IO String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

linger :: Socket z t -> ZMQ z Int
linger :: Socket z t -> ZMQ z Int
linger = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.linger (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

maxMessageSize :: Socket z t -> ZMQ z Int64
maxMessageSize :: Socket z t -> ZMQ z Int64
maxMessageSize = IO Int64 -> ZMQ z Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> ZMQ z Int64)
-> (Socket z t -> IO Int64) -> Socket z t -> ZMQ z Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int64
forall a. Socket a -> IO Int64
Z.maxMessageSize (Socket t -> IO Int64)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

mcastHops :: Socket z t -> ZMQ z Int
mcastHops :: Socket z t -> ZMQ z Int
mcastHops = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.mcastHops (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

mechanism :: Socket z t -> ZMQ z Z.SecurityMechanism
mechanism :: Socket z t -> ZMQ z SecurityMechanism
mechanism = IO SecurityMechanism -> ZMQ z SecurityMechanism
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SecurityMechanism -> ZMQ z SecurityMechanism)
-> (Socket z t -> IO SecurityMechanism)
-> Socket z t
-> ZMQ z SecurityMechanism
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO SecurityMechanism
forall a. Socket a -> IO SecurityMechanism
Z.mechanism (Socket t -> IO SecurityMechanism)
-> (Socket z t -> Socket t) -> Socket z t -> IO SecurityMechanism
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

moreToReceive :: Socket z t -> ZMQ z Bool
moreToReceive :: Socket z t -> ZMQ z Bool
moreToReceive = IO Bool -> ZMQ z Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> ZMQ z Bool)
-> (Socket z t -> IO Bool) -> Socket z t -> ZMQ z Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Bool
forall a. Socket a -> IO Bool
Z.moreToReceive (Socket t -> IO Bool)
-> (Socket z t -> Socket t) -> Socket z t -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

plainServer :: Socket z t -> ZMQ z Bool
plainServer :: Socket z t -> ZMQ z Bool
plainServer = IO Bool -> ZMQ z Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> ZMQ z Bool)
-> (Socket z t -> IO Bool) -> Socket z t -> ZMQ z Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Bool
forall a. Socket a -> IO Bool
Z.plainServer (Socket t -> IO Bool)
-> (Socket z t -> Socket t) -> Socket z t -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

plainPassword :: Socket z t -> ZMQ z ByteString
plainPassword :: Socket z t -> ZMQ z ByteString
plainPassword = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ByteString
forall a. Socket a -> IO ByteString
Z.plainPassword (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

plainUserName :: Socket z t -> ZMQ z ByteString
plainUserName :: Socket z t -> ZMQ z ByteString
plainUserName = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ByteString
forall a. Socket a -> IO ByteString
Z.plainUserName (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

rate :: Socket z t -> ZMQ z Int
rate :: Socket z t -> ZMQ z Int
rate = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.rate (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

receiveBuffer :: Socket z t -> ZMQ z Int
receiveBuffer :: Socket z t -> ZMQ z Int
receiveBuffer = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.receiveBuffer (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

receiveHighWM :: Socket z t -> ZMQ z Int
receiveHighWM :: Socket z t -> ZMQ z Int
receiveHighWM = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.receiveHighWM (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

receiveTimeout :: Socket z t -> ZMQ z Int
receiveTimeout :: Socket z t -> ZMQ z Int
receiveTimeout = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.receiveTimeout (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

reconnectInterval :: Socket z t -> ZMQ z Int
reconnectInterval :: Socket z t -> ZMQ z Int
reconnectInterval = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.reconnectInterval (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

reconnectIntervalMax :: Socket z t -> ZMQ z Int
reconnectIntervalMax :: Socket z t -> ZMQ z Int
reconnectIntervalMax = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.reconnectIntervalMax (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

recoveryInterval :: Socket z t -> ZMQ z Int
recoveryInterval :: Socket z t -> ZMQ z Int
recoveryInterval = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.recoveryInterval (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

sendBuffer :: Socket z t -> ZMQ z Int
sendBuffer :: Socket z t -> ZMQ z Int
sendBuffer = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.sendBuffer (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

sendHighWM :: Socket z t -> ZMQ z Int
sendHighWM :: Socket z t -> ZMQ z Int
sendHighWM = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.sendHighWM (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

sendTimeout :: Socket z t -> ZMQ z Int
sendTimeout :: Socket z t -> ZMQ z Int
sendTimeout = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.sendTimeout (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

tcpKeepAlive :: Socket z t -> ZMQ z Z.Switch
tcpKeepAlive :: Socket z t -> ZMQ z Switch
tcpKeepAlive = IO Switch -> ZMQ z Switch
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Switch -> ZMQ z Switch)
-> (Socket z t -> IO Switch) -> Socket z t -> ZMQ z Switch
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Switch
forall a. Socket a -> IO Switch
Z.tcpKeepAlive (Socket t -> IO Switch)
-> (Socket z t -> Socket t) -> Socket z t -> IO Switch
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

tcpKeepAliveCount :: Socket z t -> ZMQ z Int
tcpKeepAliveCount :: Socket z t -> ZMQ z Int
tcpKeepAliveCount = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.tcpKeepAliveCount (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

tcpKeepAliveIdle :: Socket z t -> ZMQ z Int
tcpKeepAliveIdle :: Socket z t -> ZMQ z Int
tcpKeepAliveIdle = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.tcpKeepAliveIdle (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

tcpKeepAliveInterval :: Socket z t -> ZMQ z Int
tcpKeepAliveInterval :: Socket z t -> ZMQ z Int
tcpKeepAliveInterval = IO Int -> ZMQ z Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> ZMQ z Int)
-> (Socket z t -> IO Int) -> Socket z t -> ZMQ z Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO Int
forall a. Socket a -> IO Int
Z.tcpKeepAliveInterval (Socket t -> IO Int)
-> (Socket z t -> Socket t) -> Socket z t -> IO Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

zapDomain :: Socket z t -> ZMQ z ByteString
zapDomain :: Socket z t -> ZMQ z ByteString
zapDomain = IO ByteString -> ZMQ z ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> ZMQ z ByteString)
-> (Socket z t -> IO ByteString) -> Socket z t -> ZMQ z ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ByteString
forall a. Socket a -> IO ByteString
Z.zapDomain (Socket t -> IO ByteString)
-> (Socket z t -> Socket t) -> Socket z t -> IO ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

-- * Socket Options (Write)

setAffinity :: Word64 -> Socket z t -> ZMQ z ()
setAffinity :: Word64 -> Socket z t -> ZMQ z ()
setAffinity a :: Word64
a = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Socket t -> IO ()
forall a. Word64 -> Socket a -> IO ()
Z.setAffinity Word64
a (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setBacklog :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setBacklog :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setBacklog b :: Restricted (N0, Int32) i
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setBacklog Restricted (N0, Int32) i
b (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setConflate :: Z.Conflatable t => Bool -> Socket z t -> ZMQ z ()
setConflate :: Bool -> Socket z t -> ZMQ z ()
setConflate i :: Bool
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. Conflatable a => Bool -> Socket a -> IO ()
Z.setConflate Bool
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setCurvePublicKey :: Z.KeyFormat f -> Restricted f ByteString -> Socket z t -> ZMQ z ()
setCurvePublicKey :: KeyFormat f -> Restricted f ByteString -> Socket z t -> ZMQ z ()
setCurvePublicKey f :: KeyFormat f
f k :: Restricted f ByteString
k = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyFormat f -> Restricted f ByteString -> Socket t -> IO ()
forall f a.
KeyFormat f -> Restricted f ByteString -> Socket a -> IO ()
Z.setCurvePublicKey KeyFormat f
f Restricted f ByteString
k (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setCurveSecretKey :: Z.KeyFormat f -> Restricted f ByteString -> Socket z t -> ZMQ z ()
setCurveSecretKey :: KeyFormat f -> Restricted f ByteString -> Socket z t -> ZMQ z ()
setCurveSecretKey f :: KeyFormat f
f k :: Restricted f ByteString
k = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyFormat f -> Restricted f ByteString -> Socket t -> IO ()
forall f a.
KeyFormat f -> Restricted f ByteString -> Socket a -> IO ()
Z.setCurveSecretKey KeyFormat f
f Restricted f ByteString
k (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setCurveServer :: Bool -> Socket z t -> ZMQ z ()
setCurveServer :: Bool -> Socket z t -> ZMQ z ()
setCurveServer b :: Bool
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. Bool -> Socket a -> IO ()
Z.setCurveServer Bool
b (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setCurveServerKey :: Z.KeyFormat f -> Restricted f ByteString -> Socket z t -> ZMQ z ()
setCurveServerKey :: KeyFormat f -> Restricted f ByteString -> Socket z t -> ZMQ z ()
setCurveServerKey f :: KeyFormat f
f k :: Restricted f ByteString
k = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyFormat f -> Restricted f ByteString -> Socket t -> IO ()
forall f a.
KeyFormat f -> Restricted f ByteString -> Socket a -> IO ()
Z.setCurveServerKey KeyFormat f
f Restricted f ByteString
k (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setDelayAttachOnConnect :: Bool -> Socket z t -> ZMQ z ()
setDelayAttachOnConnect :: Bool -> Socket z t -> ZMQ z ()
setDelayAttachOnConnect d :: Bool
d = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. Bool -> Socket a -> IO ()
Z.setDelayAttachOnConnect Bool
d (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket
{-# DEPRECATED setDelayAttachOnConnect "Use setImmediate" #-}

setIdentity :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setIdentity :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setIdentity i :: Restricted (N1, N254) ByteString
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N1, N254) ByteString -> Socket t -> IO ()
forall a. Restricted (N1, N254) ByteString -> Socket a -> IO ()
Z.setIdentity Restricted (N1, N254) ByteString
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setImmediate :: Bool -> Socket z t -> ZMQ z ()
setImmediate :: Bool -> Socket z t -> ZMQ z ()
setImmediate i :: Bool
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. Bool -> Socket a -> IO ()
Z.setImmediate Bool
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setIpv4Only :: Bool -> Socket z t -> ZMQ z ()
setIpv4Only :: Bool -> Socket z t -> ZMQ z ()
setIpv4Only i :: Bool
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. Bool -> Socket a -> IO ()
Z.setIpv4Only Bool
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket
{-# DEPRECATED setIpv4Only "Use setIpv6" #-}

setIpv6 :: Bool -> Socket z t -> ZMQ z ()
setIpv6 :: Bool -> Socket z t -> ZMQ z ()
setIpv6 i :: Bool
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. Bool -> Socket a -> IO ()
Z.setIpv6 Bool
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setLinger :: Integral i => Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setLinger :: Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setLinger l :: Restricted (Nneg1, Int32) i
l = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (Nneg1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (Nneg1, Int32) i -> Socket a -> IO ()
Z.setLinger Restricted (Nneg1, Int32) i
l (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setMaxMessageSize :: Integral i => Restricted (Nneg1, Int64) i -> Socket z t -> ZMQ z ()
setMaxMessageSize :: Restricted (Nneg1, Int64) i -> Socket z t -> ZMQ z ()
setMaxMessageSize s :: Restricted (Nneg1, Int64) i
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (Nneg1, Int64) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (Nneg1, Int64) i -> Socket a -> IO ()
Z.setMaxMessageSize Restricted (Nneg1, Int64) i
s (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setMcastHops :: Integral i => Restricted (N1, Int32) i -> Socket z t -> ZMQ z ()
setMcastHops :: Restricted (N1, Int32) i -> Socket z t -> ZMQ z ()
setMcastHops k :: Restricted (N1, Int32) i
k = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N1, Int32) i -> Socket a -> IO ()
Z.setMcastHops Restricted (N1, Int32) i
k (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setPlainServer :: Bool -> Socket z t -> ZMQ z ()
setPlainServer :: Bool -> Socket z t -> ZMQ z ()
setPlainServer b :: Bool
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. Bool -> Socket a -> IO ()
Z.setPlainServer Bool
b (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setPlainPassword :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setPlainPassword :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setPlainPassword s :: Restricted (N1, N254) ByteString
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N1, N254) ByteString -> Socket t -> IO ()
forall a. Restricted (N1, N254) ByteString -> Socket a -> IO ()
Z.setPlainPassword Restricted (N1, N254) ByteString
s (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setPlainUserName :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setPlainUserName :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setPlainUserName s :: Restricted (N1, N254) ByteString
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N1, N254) ByteString -> Socket t -> IO ()
forall a. Restricted (N1, N254) ByteString -> Socket a -> IO ()
Z.setPlainUserName Restricted (N1, N254) ByteString
s (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setProbeRouter :: Z.SendProbe t => Bool -> Socket z t -> ZMQ z ()
setProbeRouter :: Bool -> Socket z t -> ZMQ z ()
setProbeRouter b :: Bool
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket t -> IO ()
forall a. SendProbe a => Bool -> Socket a -> IO ()
Z.setProbeRouter Bool
b (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setRate :: Integral i => Restricted (N1, Int32) i -> Socket z t -> ZMQ z ()
setRate :: Restricted (N1, Int32) i -> Socket z t -> ZMQ z ()
setRate r :: Restricted (N1, Int32) i
r = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N1, Int32) i -> Socket a -> IO ()
Z.setRate Restricted (N1, Int32) i
r (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setReceiveBuffer :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReceiveBuffer :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReceiveBuffer k :: Restricted (N0, Int32) i
k = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setReceiveBuffer Restricted (N0, Int32) i
k (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setReceiveHighWM :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReceiveHighWM :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReceiveHighWM k :: Restricted (N0, Int32) i
k = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setReceiveHighWM Restricted (N0, Int32) i
k (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setReceiveTimeout :: Integral i => Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setReceiveTimeout :: Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setReceiveTimeout t :: Restricted (Nneg1, Int32) i
t = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (Nneg1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (Nneg1, Int32) i -> Socket a -> IO ()
Z.setReceiveTimeout Restricted (Nneg1, Int32) i
t (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setReconnectInterval :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReconnectInterval :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReconnectInterval i :: Restricted (N0, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setReconnectInterval Restricted (N0, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setReconnectIntervalMax :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReconnectIntervalMax :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setReconnectIntervalMax i :: Restricted (N0, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setReconnectIntervalMax Restricted (N0, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setRecoveryInterval :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setRecoveryInterval :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setRecoveryInterval i :: Restricted (N0, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setRecoveryInterval Restricted (N0, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setReqCorrelate :: Bool -> Socket z Z.Req -> ZMQ z ()
setReqCorrelate :: Bool -> Socket z Req -> ZMQ z ()
setReqCorrelate b :: Bool
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z Req -> IO ()) -> Socket z Req -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket Req -> IO ()
Z.setReqCorrelate Bool
b (Socket Req -> IO ())
-> (Socket z Req -> Socket Req) -> Socket z Req -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z Req -> Socket Req
forall z t. Socket z t -> Socket t
_unsocket

setReqRelaxed :: Bool -> Socket z Z.Req -> ZMQ z ()
setReqRelaxed :: Bool -> Socket z Req -> ZMQ z ()
setReqRelaxed b :: Bool
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z Req -> IO ()) -> Socket z Req -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket Req -> IO ()
Z.setReqRelaxed Bool
b (Socket Req -> IO ())
-> (Socket z Req -> Socket Req) -> Socket z Req -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z Req -> Socket Req
forall z t. Socket z t -> Socket t
_unsocket

setRouterMandatory :: Bool -> Socket z Z.Router -> ZMQ z ()
setRouterMandatory :: Bool -> Socket z Router -> ZMQ z ()
setRouterMandatory b :: Bool
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z Router -> IO ()) -> Socket z Router -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket Router -> IO ()
Z.setRouterMandatory Bool
b (Socket Router -> IO ())
-> (Socket z Router -> Socket Router) -> Socket z Router -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z Router -> Socket Router
forall z t. Socket z t -> Socket t
_unsocket

setSendBuffer :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setSendBuffer :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setSendBuffer i :: Restricted (N0, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setSendBuffer Restricted (N0, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setSendHighWM :: Integral i => Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setSendHighWM :: Restricted (N0, Int32) i -> Socket z t -> ZMQ z ()
setSendHighWM i :: Restricted (N0, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N0, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (N0, Int32) i -> Socket a -> IO ()
Z.setSendHighWM Restricted (N0, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setSendTimeout :: Integral i => Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setSendTimeout :: Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setSendTimeout i :: Restricted (Nneg1, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (Nneg1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (Nneg1, Int32) i -> Socket a -> IO ()
Z.setSendTimeout Restricted (Nneg1, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setTcpAcceptFilter :: Maybe ByteString -> Socket z t -> ZMQ z ()
setTcpAcceptFilter :: Maybe ByteString -> Socket z t -> ZMQ z ()
setTcpAcceptFilter s :: Maybe ByteString
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe ByteString -> Socket t -> IO ()
forall a. Maybe ByteString -> Socket a -> IO ()
Z.setTcpAcceptFilter Maybe ByteString
s (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setTcpKeepAlive :: Z.Switch -> Socket z t -> ZMQ z ()
setTcpKeepAlive :: Switch -> Socket z t -> ZMQ z ()
setTcpKeepAlive s :: Switch
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Switch -> Socket t -> IO ()
forall a. Switch -> Socket a -> IO ()
Z.setTcpKeepAlive Switch
s (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setTcpKeepAliveCount :: Integral i => Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setTcpKeepAliveCount :: Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setTcpKeepAliveCount c :: Restricted (Nneg1, Int32) i
c = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (Nneg1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (Nneg1, Int32) i -> Socket a -> IO ()
Z.setTcpKeepAliveCount Restricted (Nneg1, Int32) i
c (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setTcpKeepAliveIdle :: Integral i => Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setTcpKeepAliveIdle :: Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setTcpKeepAliveIdle i :: Restricted (Nneg1, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (Nneg1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (Nneg1, Int32) i -> Socket a -> IO ()
Z.setTcpKeepAliveIdle Restricted (Nneg1, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setTcpKeepAliveInterval :: Integral i => Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setTcpKeepAliveInterval :: Restricted (Nneg1, Int32) i -> Socket z t -> ZMQ z ()
setTcpKeepAliveInterval i :: Restricted (Nneg1, Int32) i
i = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (Nneg1, Int32) i -> Socket t -> IO ()
forall i a.
Integral i =>
Restricted (Nneg1, Int32) i -> Socket a -> IO ()
Z.setTcpKeepAliveInterval Restricted (Nneg1, Int32) i
i (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

setXPubVerbose :: Bool -> Socket z Z.XPub -> ZMQ z ()
setXPubVerbose :: Bool -> Socket z XPub -> ZMQ z ()
setXPubVerbose b :: Bool
b = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z XPub -> IO ()) -> Socket z XPub -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Socket XPub -> IO ()
Z.setXPubVerbose Bool
b (Socket XPub -> IO ())
-> (Socket z XPub -> Socket XPub) -> Socket z XPub -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z XPub -> Socket XPub
forall z t. Socket z t -> Socket t
_unsocket

setZapDomain :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setZapDomain :: Restricted (N1, N254) ByteString -> Socket z t -> ZMQ z ()
setZapDomain s :: Restricted (N1, N254) ByteString
s = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Restricted (N1, N254) ByteString -> Socket t -> IO ()
forall a. Restricted (N1, N254) ByteString -> Socket a -> IO ()
Z.setZapDomain Restricted (N1, N254) ByteString
s (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

-- * Low Level Functions

waitRead :: Socket z t -> ZMQ z ()
waitRead :: Socket z t -> ZMQ z ()
waitRead = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ()
forall a. Socket a -> IO ()
Z.waitRead (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

waitWrite :: Socket z t -> ZMQ z ()
waitWrite :: Socket z t -> ZMQ z ()
waitWrite = IO () -> ZMQ z ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ZMQ z ())
-> (Socket z t -> IO ()) -> Socket z t -> ZMQ z ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket t -> IO ()
forall a. Socket a -> IO ()
Z.waitWrite (Socket t -> IO ())
-> (Socket z t -> Socket t) -> Socket z t -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Socket z t -> Socket t
forall z t. Socket z t -> Socket t
_unsocket

-- * Internal

onContext :: (Z.Context -> IO a) -> ZMQ z a
onContext :: (Context -> IO a) -> ZMQ z a
onContext f :: Context -> IO a
f = ReaderT ZMQEnv IO a -> ZMQ z a
forall z a. ReaderT ZMQEnv IO a -> ZMQ z a
ZMQ (ReaderT ZMQEnv IO a -> ZMQ z a) -> ReaderT ZMQEnv IO a -> ZMQ z a
forall a b. (a -> b) -> a -> b
$! (ZMQEnv -> Context) -> ReaderT ZMQEnv IO Context
forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks ZMQEnv -> Context
_context ReaderT ZMQEnv IO Context
-> (Context -> ReaderT ZMQEnv IO a) -> ReaderT ZMQEnv IO a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= IO a -> ReaderT ZMQEnv IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> ReaderT ZMQEnv IO a)
-> (Context -> IO a) -> Context -> ReaderT ZMQEnv IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Context -> IO a
f

term :: ZMQEnv -> IO ()
term :: ZMQEnv -> IO ()
term env :: ZMQEnv
env = do
    Word
n <- IORef Word -> (Word -> (Word, Word)) -> IO Word
forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef (ZMQEnv -> IORef Word
_refcount ZMQEnv
env) ((Word -> (Word, Word)) -> IO Word)
-> (Word -> (Word, Word)) -> IO Word
forall a b. (a -> b) -> a -> b
$ \n :: Word
n -> (Word -> Word
forall a. Enum a => a -> a
pred Word
n, Word
n)
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Word
n Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== 1) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
        IORef [SocketRepr] -> IO [SocketRepr]
forall a. IORef a -> IO a
readIORef (ZMQEnv -> IORef [SocketRepr]
_sockets ZMQEnv
env) IO [SocketRepr] -> ([SocketRepr] -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (SocketRepr -> IO ()) -> [SocketRepr] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ SocketRepr -> IO ()
close'
        Context -> IO ()
Z.term (ZMQEnv -> Context
_context ZMQEnv
env)
  where
    close' :: SocketRepr -> IO ()
close' s :: SocketRepr
s = SocketRepr -> IO ()
I.closeSock SocketRepr
s IO () -> (SomeException -> IO ()) -> IO ()
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
`E.catch` (\e :: SomeException
e -> SomeException -> IO ()
forall a. Show a => a -> IO ()
print (SomeException
e :: E.SomeException))