{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A 'GI.Gio.Objects.SocketListener.SocketListener' is an object that keeps track of a set
of server sockets and helps you accept sockets from any of the
socket, either sync or async.

Add addresses and ports to listen on using 'GI.Gio.Objects.SocketListener.socketListenerAddAddress'
and 'GI.Gio.Objects.SocketListener.socketListenerAddInetPort'. These will be listened on until
'GI.Gio.Objects.SocketListener.socketListenerClose' is called. Dropping your final reference to the
'GI.Gio.Objects.SocketListener.SocketListener' will not cause 'GI.Gio.Objects.SocketListener.socketListenerClose' to be called
implicitly, as some references to the 'GI.Gio.Objects.SocketListener.SocketListener' may be held
internally.

If you want to implement a network server, also look at 'GI.Gio.Objects.SocketService.SocketService'
and 'GI.Gio.Objects.ThreadedSocketService.ThreadedSocketService' which are subclasses of 'GI.Gio.Objects.SocketListener.SocketListener'
that make this even easier.

/Since: 2.22/
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Gio.Objects.SocketListener
    ( 

-- * Exported types
    SocketListener(..)                      ,
    IsSocketListener                        ,
    toSocketListener                        ,
    noSocketListener                        ,


 -- * Methods
-- ** accept #method:accept#

#if ENABLE_OVERLOADING
    SocketListenerAcceptMethodInfo          ,
#endif
    socketListenerAccept                    ,


-- ** acceptAsync #method:acceptAsync#

#if ENABLE_OVERLOADING
    SocketListenerAcceptAsyncMethodInfo     ,
#endif
    socketListenerAcceptAsync               ,


-- ** acceptFinish #method:acceptFinish#

#if ENABLE_OVERLOADING
    SocketListenerAcceptFinishMethodInfo    ,
#endif
    socketListenerAcceptFinish              ,


-- ** acceptSocket #method:acceptSocket#

#if ENABLE_OVERLOADING
    SocketListenerAcceptSocketMethodInfo    ,
#endif
    socketListenerAcceptSocket              ,


-- ** acceptSocketAsync #method:acceptSocketAsync#

#if ENABLE_OVERLOADING
    SocketListenerAcceptSocketAsyncMethodInfo,
#endif
    socketListenerAcceptSocketAsync         ,


-- ** acceptSocketFinish #method:acceptSocketFinish#

#if ENABLE_OVERLOADING
    SocketListenerAcceptSocketFinishMethodInfo,
#endif
    socketListenerAcceptSocketFinish        ,


-- ** addAddress #method:addAddress#

#if ENABLE_OVERLOADING
    SocketListenerAddAddressMethodInfo      ,
#endif
    socketListenerAddAddress                ,


-- ** addAnyInetPort #method:addAnyInetPort#

#if ENABLE_OVERLOADING
    SocketListenerAddAnyInetPortMethodInfo  ,
#endif
    socketListenerAddAnyInetPort            ,


-- ** addInetPort #method:addInetPort#

#if ENABLE_OVERLOADING
    SocketListenerAddInetPortMethodInfo     ,
#endif
    socketListenerAddInetPort               ,


-- ** addSocket #method:addSocket#

#if ENABLE_OVERLOADING
    SocketListenerAddSocketMethodInfo       ,
#endif
    socketListenerAddSocket                 ,


-- ** close #method:close#

#if ENABLE_OVERLOADING
    SocketListenerCloseMethodInfo           ,
#endif
    socketListenerClose                     ,


-- ** new #method:new#

    socketListenerNew                       ,


-- ** setBacklog #method:setBacklog#

#if ENABLE_OVERLOADING
    SocketListenerSetBacklogMethodInfo      ,
#endif
    socketListenerSetBacklog                ,




 -- * Properties
-- ** listenBacklog #attr:listenBacklog#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    SocketListenerListenBacklogPropertyInfo ,
#endif
    constructSocketListenerListenBacklog    ,
    getSocketListenerListenBacklog          ,
    setSocketListenerListenBacklog          ,
#if ENABLE_OVERLOADING
    socketListenerListenBacklog             ,
#endif




 -- * Signals
-- ** event #signal:event#

    C_SocketListenerEventCallback           ,
    SocketListenerEventCallback             ,
#if ENABLE_OVERLOADING
    SocketListenerEventSignalInfo           ,
#endif
    afterSocketListenerEvent                ,
    genClosure_SocketListenerEvent          ,
    mk_SocketListenerEventCallback          ,
    noSocketListenerEventCallback           ,
    onSocketListenerEvent                   ,
    wrap_SocketListenerEventCallback        ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.Socket as Gio.Socket
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress
import {-# SOURCE #-} qualified GI.Gio.Objects.SocketConnection as Gio.SocketConnection

-- | Memory-managed wrapper type.
newtype SocketListener = SocketListener (ManagedPtr SocketListener)
foreign import ccall "g_socket_listener_get_type"
    c_g_socket_listener_get_type :: IO GType

instance GObject SocketListener where
    gobjectType :: SocketListener -> IO GType
gobjectType _ = IO GType
c_g_socket_listener_get_type
    

-- | Type class for types which can be safely cast to `SocketListener`, for instance with `toSocketListener`.
class GObject o => IsSocketListener o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError SocketListener a) =>
    IsSocketListener a
#endif
instance IsSocketListener SocketListener
instance GObject.Object.IsObject SocketListener

-- | Cast to `SocketListener`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toSocketListener :: (MonadIO m, IsSocketListener o) => o -> m SocketListener
toSocketListener :: o -> m SocketListener
toSocketListener = IO SocketListener -> m SocketListener
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SocketListener -> m SocketListener)
-> (o -> IO SocketListener) -> o -> m SocketListener
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SocketListener -> SocketListener)
-> o -> IO SocketListener
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr SocketListener -> SocketListener
SocketListener

-- | A convenience alias for `Nothing` :: `Maybe` `SocketListener`.
noSocketListener :: Maybe SocketListener
noSocketListener :: Maybe SocketListener
noSocketListener = Maybe SocketListener
forall a. Maybe a
Nothing

#if ENABLE_OVERLOADING
type family ResolveSocketListenerMethod (t :: Symbol) (o :: *) :: * where
    ResolveSocketListenerMethod "accept" o = SocketListenerAcceptMethodInfo
    ResolveSocketListenerMethod "acceptAsync" o = SocketListenerAcceptAsyncMethodInfo
    ResolveSocketListenerMethod "acceptFinish" o = SocketListenerAcceptFinishMethodInfo
    ResolveSocketListenerMethod "acceptSocket" o = SocketListenerAcceptSocketMethodInfo
    ResolveSocketListenerMethod "acceptSocketAsync" o = SocketListenerAcceptSocketAsyncMethodInfo
    ResolveSocketListenerMethod "acceptSocketFinish" o = SocketListenerAcceptSocketFinishMethodInfo
    ResolveSocketListenerMethod "addAddress" o = SocketListenerAddAddressMethodInfo
    ResolveSocketListenerMethod "addAnyInetPort" o = SocketListenerAddAnyInetPortMethodInfo
    ResolveSocketListenerMethod "addInetPort" o = SocketListenerAddInetPortMethodInfo
    ResolveSocketListenerMethod "addSocket" o = SocketListenerAddSocketMethodInfo
    ResolveSocketListenerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSocketListenerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSocketListenerMethod "close" o = SocketListenerCloseMethodInfo
    ResolveSocketListenerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSocketListenerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSocketListenerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSocketListenerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSocketListenerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSocketListenerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSocketListenerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSocketListenerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSocketListenerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSocketListenerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSocketListenerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSocketListenerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSocketListenerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSocketListenerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSocketListenerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSocketListenerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSocketListenerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSocketListenerMethod "setBacklog" o = SocketListenerSetBacklogMethodInfo
    ResolveSocketListenerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSocketListenerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSocketListenerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSocketListenerMethod t SocketListener, O.MethodInfo info SocketListener p) => O.IsLabelProxy t (SocketListener -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveSocketListenerMethod t SocketListener, O.MethodInfo info SocketListener p) => O.IsLabel t (SocketListener -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal SocketListener::event
{- |
Emitted when /@listener@/\'s activity on /@socket@/ changes state.
Note that when /@listener@/ is used to listen on both IPv4 and
IPv6, a separate set of signals will be emitted for each, and
the order they happen in is undefined.

/Since: 2.46/
-}
type SocketListenerEventCallback =
    Gio.Enums.SocketListenerEvent
    {- ^ /@event@/: the event that is occurring -}
    -> Gio.Socket.Socket
    {- ^ /@socket@/: the 'GI.Gio.Objects.Socket.Socket' the event is occurring on -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SocketListenerEventCallback`@.
noSocketListenerEventCallback :: Maybe SocketListenerEventCallback
noSocketListenerEventCallback :: Maybe SocketListenerEventCallback
noSocketListenerEventCallback = Maybe SocketListenerEventCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_SocketListenerEventCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr Gio.Socket.Socket ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_SocketListenerEventCallback`.
foreign import ccall "wrapper"
    mk_SocketListenerEventCallback :: C_SocketListenerEventCallback -> IO (FunPtr C_SocketListenerEventCallback)

-- | Wrap the callback into a `Closure`.
genClosure_SocketListenerEvent :: SocketListenerEventCallback -> IO Closure
genClosure_SocketListenerEvent :: SocketListenerEventCallback -> IO Closure
genClosure_SocketListenerEvent cb :: SocketListenerEventCallback
cb = do
    let cb' :: C_SocketListenerEventCallback
cb' = SocketListenerEventCallback -> C_SocketListenerEventCallback
wrap_SocketListenerEventCallback SocketListenerEventCallback
cb
    C_SocketListenerEventCallback
-> IO (FunPtr C_SocketListenerEventCallback)
mk_SocketListenerEventCallback C_SocketListenerEventCallback
cb' IO (FunPtr C_SocketListenerEventCallback)
-> (FunPtr C_SocketListenerEventCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SocketListenerEventCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `SocketListenerEventCallback` into a `C_SocketListenerEventCallback`.
wrap_SocketListenerEventCallback ::
    SocketListenerEventCallback ->
    C_SocketListenerEventCallback
wrap_SocketListenerEventCallback :: SocketListenerEventCallback -> C_SocketListenerEventCallback
wrap_SocketListenerEventCallback _cb :: SocketListenerEventCallback
_cb _ event :: CUInt
event socket :: Ptr Socket
socket _ = do
    let event' :: SocketListenerEvent
event' = (Int -> SocketListenerEvent
forall a. Enum a => Int -> a
toEnum (Int -> SocketListenerEvent)
-> (CUInt -> Int) -> CUInt -> SocketListenerEvent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
event
    Socket
socket' <- ((ManagedPtr Socket -> Socket) -> Ptr Socket -> IO Socket
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Socket -> Socket
Gio.Socket.Socket) Ptr Socket
socket
    SocketListenerEventCallback
_cb  SocketListenerEvent
event' Socket
socket'


{- |
Connect a signal handler for the “@event@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' socketListener #event callback
@
-}
onSocketListenerEvent :: (IsSocketListener a, MonadIO m) => a -> SocketListenerEventCallback -> m SignalHandlerId
onSocketListenerEvent :: a -> SocketListenerEventCallback -> m SignalHandlerId
onSocketListenerEvent obj :: a
obj cb :: SocketListenerEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SocketListenerEventCallback
cb' = SocketListenerEventCallback -> C_SocketListenerEventCallback
wrap_SocketListenerEventCallback SocketListenerEventCallback
cb
    FunPtr C_SocketListenerEventCallback
cb'' <- C_SocketListenerEventCallback
-> IO (FunPtr C_SocketListenerEventCallback)
mk_SocketListenerEventCallback C_SocketListenerEventCallback
cb'
    a
-> String
-> FunPtr C_SocketListenerEventCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "event" FunPtr C_SocketListenerEventCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@event@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' socketListener #event callback
@
-}
afterSocketListenerEvent :: (IsSocketListener a, MonadIO m) => a -> SocketListenerEventCallback -> m SignalHandlerId
afterSocketListenerEvent :: a -> SocketListenerEventCallback -> m SignalHandlerId
afterSocketListenerEvent obj :: a
obj cb :: SocketListenerEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SocketListenerEventCallback
cb' = SocketListenerEventCallback -> C_SocketListenerEventCallback
wrap_SocketListenerEventCallback SocketListenerEventCallback
cb
    FunPtr C_SocketListenerEventCallback
cb'' <- C_SocketListenerEventCallback
-> IO (FunPtr C_SocketListenerEventCallback)
mk_SocketListenerEventCallback C_SocketListenerEventCallback
cb'
    a
-> String
-> FunPtr C_SocketListenerEventCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "event" FunPtr C_SocketListenerEventCallback
cb'' SignalConnectMode
SignalConnectAfter


-- VVV Prop "listen-backlog"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@listen-backlog@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' socketListener #listenBacklog
@
-}
getSocketListenerListenBacklog :: (MonadIO m, IsSocketListener o) => o -> m Int32
getSocketListenerListenBacklog :: o -> m Int32
getSocketListenerListenBacklog obj :: o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
getObjectPropertyInt32 o
obj "listen-backlog"

{- |
Set the value of the “@listen-backlog@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' socketListener [ #listenBacklog 'Data.GI.Base.Attributes.:=' value ]
@
-}
setSocketListenerListenBacklog :: (MonadIO m, IsSocketListener o) => o -> Int32 -> m ()
setSocketListenerListenBacklog :: o -> Int32 -> m ()
setSocketListenerListenBacklog obj :: o
obj val :: Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
setObjectPropertyInt32 o
obj "listen-backlog" Int32
val

{- |
Construct a `GValueConstruct` with valid value for the “@listen-backlog@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructSocketListenerListenBacklog :: (IsSocketListener o) => Int32 -> IO (GValueConstruct o)
constructSocketListenerListenBacklog :: Int32 -> IO (GValueConstruct o)
constructSocketListenerListenBacklog val :: Int32
val = String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
constructObjectPropertyInt32 "listen-backlog" Int32
val

#if ENABLE_OVERLOADING
data SocketListenerListenBacklogPropertyInfo
instance AttrInfo SocketListenerListenBacklogPropertyInfo where
    type AttrAllowedOps SocketListenerListenBacklogPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint SocketListenerListenBacklogPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint SocketListenerListenBacklogPropertyInfo = IsSocketListener
    type AttrGetType SocketListenerListenBacklogPropertyInfo = Int32
    type AttrLabel SocketListenerListenBacklogPropertyInfo = "listen-backlog"
    type AttrOrigin SocketListenerListenBacklogPropertyInfo = SocketListener
    attrGet _ = getSocketListenerListenBacklog
    attrSet _ = setSocketListenerListenBacklog
    attrConstruct _ = constructSocketListenerListenBacklog
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList SocketListener
type instance O.AttributeList SocketListener = SocketListenerAttributeList
type SocketListenerAttributeList = ('[ '("listenBacklog", SocketListenerListenBacklogPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
socketListenerListenBacklog :: AttrLabelProxy "listenBacklog"
socketListenerListenBacklog = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data SocketListenerEventSignalInfo
instance SignalInfo SocketListenerEventSignalInfo where
    type HaskellCallbackType SocketListenerEventSignalInfo = SocketListenerEventCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_SocketListenerEventCallback cb
        cb'' <- mk_SocketListenerEventCallback cb'
        connectSignalFunPtr obj "event" cb'' connectMode

type instance O.SignalList SocketListener = SocketListenerSignalList
type SocketListenerSignalList = ('[ '("event", SocketListenerEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method SocketListener::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketListener"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_listener_new" g_socket_listener_new :: 
    IO (Ptr SocketListener)

{- |
Creates a new 'GI.Gio.Objects.SocketListener.SocketListener' with no sockets to listen for.
New listeners can be added with e.g. 'GI.Gio.Objects.SocketListener.socketListenerAddAddress'
or 'GI.Gio.Objects.SocketListener.socketListenerAddInetPort'.

/Since: 2.22/
-}
socketListenerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m SocketListener
    {- ^ __Returns:__ a new 'GI.Gio.Objects.SocketListener.SocketListener'. -}
socketListenerNew :: m SocketListener
socketListenerNew  = IO SocketListener -> m SocketListener
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SocketListener -> m SocketListener)
-> IO SocketListener -> m SocketListener
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
result <- IO (Ptr SocketListener)
g_socket_listener_new
    Text -> Ptr SocketListener -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "socketListenerNew" Ptr SocketListener
result
    SocketListener
result' <- ((ManagedPtr SocketListener -> SocketListener)
-> Ptr SocketListener -> IO SocketListener
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SocketListener -> SocketListener
SocketListener) Ptr SocketListener
result
    SocketListener -> IO SocketListener
forall (m :: * -> *) a. Monad m => a -> m a
return SocketListener
result'

#if ENABLE_OVERLOADING
#endif

-- method SocketListener::accept
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "location where #GObject pointer will be stored, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketConnection"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_accept" g_socket_listener_accept :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr (Ptr GObject.Object.Object) ->      -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.SocketConnection.SocketConnection)

{- |
Blocks waiting for a client to connect to any of the sockets added
to the listener. Returns a 'GI.Gio.Objects.SocketConnection.SocketConnection' for the socket that was
accepted.

If /@sourceObject@/ is not 'Nothing' it will be filled out with the source
object specified when the corresponding socket or address was added
to the listener.

If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
triggering the cancellable object from another thread. If the operation
was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.

/Since: 2.22/
-}
socketListenerAccept ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
    -> m ((Gio.SocketConnection.SocketConnection, Maybe GObject.Object.Object))
    {- ^ __Returns:__ a 'GI.Gio.Objects.SocketConnection.SocketConnection' on success, 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAccept :: a -> Maybe b -> m (SocketConnection, Maybe Object)
socketListenerAccept listener :: a
listener cancellable :: Maybe b
cancellable = IO (SocketConnection, Maybe Object)
-> m (SocketConnection, Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (SocketConnection, Maybe Object)
 -> m (SocketConnection, Maybe Object))
-> IO (SocketConnection, Maybe Object)
-> m (SocketConnection, Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr (Ptr Object)
sourceObject <- IO (Ptr (Ptr Object))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO (SocketConnection, Maybe Object)
-> IO () -> IO (SocketConnection, Maybe Object)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr SocketConnection
result <- (Ptr (Ptr GError) -> IO (Ptr SocketConnection))
-> IO (Ptr SocketConnection)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr SocketConnection))
 -> IO (Ptr SocketConnection))
-> (Ptr (Ptr GError) -> IO (Ptr SocketConnection))
-> IO (Ptr SocketConnection)
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener
-> Ptr (Ptr Object)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr SocketConnection)
g_socket_listener_accept Ptr SocketListener
listener' Ptr (Ptr Object)
sourceObject Ptr Cancellable
maybeCancellable
        Text -> Ptr SocketConnection -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "socketListenerAccept" Ptr SocketConnection
result
        SocketConnection
result' <- ((ManagedPtr SocketConnection -> SocketConnection)
-> Ptr SocketConnection -> IO SocketConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SocketConnection -> SocketConnection
Gio.SocketConnection.SocketConnection) Ptr SocketConnection
result
        Ptr Object
sourceObject' <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Object)
sourceObject
        Maybe Object
maybeSourceObject' <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
sourceObject' ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \sourceObject'' :: Ptr Object
sourceObject'' -> do
            Object
sourceObject''' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
sourceObject''
            Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
sourceObject'''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
        (SocketConnection, Maybe Object)
-> IO (SocketConnection, Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return (SocketConnection
result', Maybe Object
maybeSourceObject')
     ) (do
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
     )

#if ENABLE_OVERLOADING
data SocketListenerAcceptMethodInfo
instance (signature ~ (Maybe (b) -> m ((Gio.SocketConnection.SocketConnection, Maybe GObject.Object.Object))), MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketListenerAcceptMethodInfo a signature where
    overloadedMethod _ = socketListenerAccept

#endif

-- method SocketListener::accept_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_listener_accept_async" g_socket_listener_accept_async :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
This is the asynchronous version of 'GI.Gio.Objects.SocketListener.socketListenerAccept'.

When the operation is finished /@callback@/ will be
called. You can then call 'GI.Gio.Objects.SocketListener.socketListenerAcceptSocket'
to get the result of the operation.

/Since: 2.22/
-}
socketListenerAcceptAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m ()
socketListenerAcceptAsync :: a -> Maybe b -> Maybe AsyncReadyCallback -> m ()
socketListenerAcceptAsync listener :: a
listener cancellable :: Maybe b
cancellable callback :: Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr SocketListener
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_socket_listener_accept_async Ptr SocketListener
listener' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SocketListenerAcceptAsyncMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketListenerAcceptAsyncMethodInfo a signature where
    overloadedMethod _ = socketListenerAcceptAsync

#endif

-- method SocketListener::accept_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional #GObject identifying this source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketConnection"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_accept_finish" g_socket_listener_accept_finish :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GObject.Object.Object) ->      -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.SocketConnection.SocketConnection)

{- |
Finishes an async accept operation. See 'GI.Gio.Objects.SocketListener.socketListenerAcceptAsync'

/Since: 2.22/
-}
socketListenerAcceptFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
    -> m ((Gio.SocketConnection.SocketConnection, Maybe GObject.Object.Object))
    {- ^ __Returns:__ a 'GI.Gio.Objects.SocketConnection.SocketConnection' on success, 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAcceptFinish :: a -> b -> m (SocketConnection, Maybe Object)
socketListenerAcceptFinish listener :: a
listener result_ :: b
result_ = IO (SocketConnection, Maybe Object)
-> m (SocketConnection, Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (SocketConnection, Maybe Object)
 -> m (SocketConnection, Maybe Object))
-> IO (SocketConnection, Maybe Object)
-> m (SocketConnection, Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    Ptr (Ptr Object)
sourceObject <- IO (Ptr (Ptr Object))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    IO (SocketConnection, Maybe Object)
-> IO () -> IO (SocketConnection, Maybe Object)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr SocketConnection
result <- (Ptr (Ptr GError) -> IO (Ptr SocketConnection))
-> IO (Ptr SocketConnection)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr SocketConnection))
 -> IO (Ptr SocketConnection))
-> (Ptr (Ptr GError) -> IO (Ptr SocketConnection))
-> IO (Ptr SocketConnection)
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener
-> Ptr AsyncResult
-> Ptr (Ptr Object)
-> Ptr (Ptr GError)
-> IO (Ptr SocketConnection)
g_socket_listener_accept_finish Ptr SocketListener
listener' Ptr AsyncResult
result_' Ptr (Ptr Object)
sourceObject
        Text -> Ptr SocketConnection -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "socketListenerAcceptFinish" Ptr SocketConnection
result
        SocketConnection
result' <- ((ManagedPtr SocketConnection -> SocketConnection)
-> Ptr SocketConnection -> IO SocketConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SocketConnection -> SocketConnection
Gio.SocketConnection.SocketConnection) Ptr SocketConnection
result
        Ptr Object
sourceObject' <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Object)
sourceObject
        Maybe Object
maybeSourceObject' <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
sourceObject' ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \sourceObject'' :: Ptr Object
sourceObject'' -> do
            Object
sourceObject''' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
sourceObject''
            Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
sourceObject'''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
        (SocketConnection, Maybe Object)
-> IO (SocketConnection, Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return (SocketConnection
result', Maybe Object
maybeSourceObject')
     ) (do
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
     )

#if ENABLE_OVERLOADING
data SocketListenerAcceptFinishMethodInfo
instance (signature ~ (b -> m ((Gio.SocketConnection.SocketConnection, Maybe GObject.Object.Object))), MonadIO m, IsSocketListener a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SocketListenerAcceptFinishMethodInfo a signature where
    overloadedMethod _ = socketListenerAcceptFinish

#endif

-- method SocketListener::accept_socket
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "location where #GObject pointer will be stored, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "Socket"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_accept_socket" g_socket_listener_accept_socket :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr (Ptr GObject.Object.Object) ->      -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.Socket.Socket)

{- |
Blocks waiting for a client to connect to any of the sockets added
to the listener. Returns the 'GI.Gio.Objects.Socket.Socket' that was accepted.

If you want to accept the high-level 'GI.Gio.Objects.SocketConnection.SocketConnection', not a 'GI.Gio.Objects.Socket.Socket',
which is often the case, then you should use 'GI.Gio.Objects.SocketListener.socketListenerAccept'
instead.

If /@sourceObject@/ is not 'Nothing' it will be filled out with the source
object specified when the corresponding socket or address was added
to the listener.

If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
triggering the cancellable object from another thread. If the operation
was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.

/Since: 2.22/
-}
socketListenerAcceptSocket ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
    -> m ((Gio.Socket.Socket, Maybe GObject.Object.Object))
    {- ^ __Returns:__ a 'GI.Gio.Objects.Socket.Socket' on success, 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAcceptSocket :: a -> Maybe b -> m (Socket, Maybe Object)
socketListenerAcceptSocket listener :: a
listener cancellable :: Maybe b
cancellable = IO (Socket, Maybe Object) -> m (Socket, Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Socket, Maybe Object) -> m (Socket, Maybe Object))
-> IO (Socket, Maybe Object) -> m (Socket, Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr (Ptr Object)
sourceObject <- IO (Ptr (Ptr Object))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO (Socket, Maybe Object) -> IO () -> IO (Socket, Maybe Object)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Socket
result <- (Ptr (Ptr GError) -> IO (Ptr Socket)) -> IO (Ptr Socket)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Socket)) -> IO (Ptr Socket))
-> (Ptr (Ptr GError) -> IO (Ptr Socket)) -> IO (Ptr Socket)
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener
-> Ptr (Ptr Object)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr Socket)
g_socket_listener_accept_socket Ptr SocketListener
listener' Ptr (Ptr Object)
sourceObject Ptr Cancellable
maybeCancellable
        Text -> Ptr Socket -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "socketListenerAcceptSocket" Ptr Socket
result
        Socket
result' <- ((ManagedPtr Socket -> Socket) -> Ptr Socket -> IO Socket
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Socket -> Socket
Gio.Socket.Socket) Ptr Socket
result
        Ptr Object
sourceObject' <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Object)
sourceObject
        Maybe Object
maybeSourceObject' <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
sourceObject' ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \sourceObject'' :: Ptr Object
sourceObject'' -> do
            Object
sourceObject''' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
sourceObject''
            Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
sourceObject'''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
        (Socket, Maybe Object) -> IO (Socket, Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return (Socket
result', Maybe Object
maybeSourceObject')
     ) (do
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
     )

#if ENABLE_OVERLOADING
data SocketListenerAcceptSocketMethodInfo
instance (signature ~ (Maybe (b) -> m ((Gio.Socket.Socket, Maybe GObject.Object.Object))), MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketListenerAcceptSocketMethodInfo a signature where
    overloadedMethod _ = socketListenerAcceptSocket

#endif

-- method SocketListener::accept_socket_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_listener_accept_socket_async" g_socket_listener_accept_socket_async :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
This is the asynchronous version of 'GI.Gio.Objects.SocketListener.socketListenerAcceptSocket'.

When the operation is finished /@callback@/ will be
called. You can then call 'GI.Gio.Objects.SocketListener.socketListenerAcceptSocketFinish'
to get the result of the operation.

/Since: 2.22/
-}
socketListenerAcceptSocketAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m ()
socketListenerAcceptSocketAsync :: a -> Maybe b -> Maybe AsyncReadyCallback -> m ()
socketListenerAcceptSocketAsync listener :: a
listener cancellable :: Maybe b
cancellable callback :: Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr SocketListener
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_socket_listener_accept_socket_async Ptr SocketListener
listener' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SocketListenerAcceptSocketAsyncMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSocketListener a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SocketListenerAcceptSocketAsyncMethodInfo a signature where
    overloadedMethod _ = socketListenerAcceptSocketAsync

#endif

-- method SocketListener::accept_socket_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional #GObject identifying this source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "Socket"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_accept_socket_finish" g_socket_listener_accept_socket_finish :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GObject.Object.Object) ->      -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.Socket.Socket)

{- |
Finishes an async accept operation. See 'GI.Gio.Objects.SocketListener.socketListenerAcceptSocketAsync'

/Since: 2.22/
-}
socketListenerAcceptSocketFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
    -> m ((Gio.Socket.Socket, Maybe GObject.Object.Object))
    {- ^ __Returns:__ a 'GI.Gio.Objects.Socket.Socket' on success, 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAcceptSocketFinish :: a -> b -> m (Socket, Maybe Object)
socketListenerAcceptSocketFinish listener :: a
listener result_ :: b
result_ = IO (Socket, Maybe Object) -> m (Socket, Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Socket, Maybe Object) -> m (Socket, Maybe Object))
-> IO (Socket, Maybe Object) -> m (Socket, Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    Ptr (Ptr Object)
sourceObject <- IO (Ptr (Ptr Object))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    IO (Socket, Maybe Object) -> IO () -> IO (Socket, Maybe Object)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Socket
result <- (Ptr (Ptr GError) -> IO (Ptr Socket)) -> IO (Ptr Socket)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Socket)) -> IO (Ptr Socket))
-> (Ptr (Ptr GError) -> IO (Ptr Socket)) -> IO (Ptr Socket)
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener
-> Ptr AsyncResult
-> Ptr (Ptr Object)
-> Ptr (Ptr GError)
-> IO (Ptr Socket)
g_socket_listener_accept_socket_finish Ptr SocketListener
listener' Ptr AsyncResult
result_' Ptr (Ptr Object)
sourceObject
        Text -> Ptr Socket -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "socketListenerAcceptSocketFinish" Ptr Socket
result
        Socket
result' <- ((ManagedPtr Socket -> Socket) -> Ptr Socket -> IO Socket
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Socket -> Socket
Gio.Socket.Socket) Ptr Socket
result
        Ptr Object
sourceObject' <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Object)
sourceObject
        Maybe Object
maybeSourceObject' <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
sourceObject' ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \sourceObject'' :: Ptr Object
sourceObject'' -> do
            Object
sourceObject''' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
sourceObject''
            Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
sourceObject'''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
        (Socket, Maybe Object) -> IO (Socket, Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return (Socket
result', Maybe Object
maybeSourceObject')
     ) (do
        Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
sourceObject
     )

#if ENABLE_OVERLOADING
data SocketListenerAcceptSocketFinishMethodInfo
instance (signature ~ (b -> m ((Gio.Socket.Socket, Maybe GObject.Object.Object))), MonadIO m, IsSocketListener a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SocketListenerAcceptSocketFinishMethodInfo a signature where
    overloadedMethod _ = socketListenerAcceptSocketFinish

#endif

-- method SocketListener::add_address
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "SocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "SocketType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TInterface (Name {namespace = "Gio", name = "SocketProtocol"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketProtocol", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional #GObject identifying this source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "effective_address", argType = TInterface (Name {namespace = "Gio", name = "SocketAddress"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the address that was bound to, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_add_address" g_socket_listener_add_address :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr Gio.SocketAddress.SocketAddress ->  -- address : TInterface (Name {namespace = "Gio", name = "SocketAddress"})
    CUInt ->                                -- type : TInterface (Name {namespace = "Gio", name = "SocketType"})
    CInt ->                                 -- protocol : TInterface (Name {namespace = "Gio", name = "SocketProtocol"})
    Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (Ptr Gio.SocketAddress.SocketAddress) -> -- effective_address : TInterface (Name {namespace = "Gio", name = "SocketAddress"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Creates a socket of type /@type@/ and protocol /@protocol@/, binds
it to /@address@/ and adds it to the set of sockets we\'re accepting
sockets from.

Note that adding an IPv6 address, depending on the platform,
may or may not result in a listener that also accepts IPv4
connections.  For more deterministic behavior, see
'GI.Gio.Objects.SocketListener.socketListenerAddInetPort'.

/@sourceObject@/ will be passed out in the various calls
to accept to identify this particular source, which is
useful if you\'re listening on multiple addresses and do
different things depending on what address is connected to.

If successful and /@effectiveAddress@/ is non-'Nothing' then it will
be set to the address that the binding actually occurred at.  This
is helpful for determining the port number that was used for when
requesting a binding to port 0 (ie: \"any port\").  This address, if
requested, belongs to the caller and must be freed.

Call 'GI.Gio.Objects.SocketListener.socketListenerClose' to stop listening on /@address@/; this will not
be done automatically when you drop your final reference to /@listener@/, as
references may be held internally.

/Since: 2.22/
-}
socketListenerAddAddress ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.SocketAddress.IsSocketAddress b, GObject.Object.IsObject c) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> b
    {- ^ /@address@/: a 'GI.Gio.Objects.SocketAddress.SocketAddress' -}
    -> Gio.Enums.SocketType
    {- ^ /@type@/: a 'GI.Gio.Enums.SocketType' -}
    -> Gio.Enums.SocketProtocol
    {- ^ /@protocol@/: a 'GI.Gio.Enums.SocketProtocol' -}
    -> Maybe (c)
    {- ^ /@sourceObject@/: Optional 'GI.GObject.Objects.Object.Object' identifying this source -}
    -> m (Gio.SocketAddress.SocketAddress)
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAddAddress :: a
-> b -> SocketType -> SocketProtocol -> Maybe c -> m SocketAddress
socketListenerAddAddress listener :: a
listener address :: b
address type_ :: SocketType
type_ protocol :: SocketProtocol
protocol sourceObject :: Maybe c
sourceObject = IO SocketAddress -> m SocketAddress
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SocketAddress -> m SocketAddress)
-> IO SocketAddress -> m SocketAddress
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr SocketAddress
address' <- b -> IO (Ptr SocketAddress)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
address
    let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SocketType -> Int) -> SocketType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SocketType -> Int
forall a. Enum a => a -> Int
fromEnum) SocketType
type_
    let protocol' :: CInt
protocol' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (SocketProtocol -> Int) -> SocketProtocol -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SocketProtocol -> Int
forall a. Enum a => a -> Int
fromEnum) SocketProtocol
protocol
    Ptr Object
maybeSourceObject <- case Maybe c
sourceObject of
        Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
        Just jSourceObject :: c
jSourceObject -> do
            Ptr Object
jSourceObject' <- c -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSourceObject
            Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSourceObject'
    Ptr (Ptr SocketAddress)
effectiveAddress <- IO (Ptr (Ptr SocketAddress))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Gio.SocketAddress.SocketAddress))
    IO SocketAddress -> IO () -> IO SocketAddress
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener
-> Ptr SocketAddress
-> CUInt
-> CInt
-> Ptr Object
-> Ptr (Ptr SocketAddress)
-> Ptr (Ptr GError)
-> IO CInt
g_socket_listener_add_address Ptr SocketListener
listener' Ptr SocketAddress
address' CUInt
type_' CInt
protocol' Ptr Object
maybeSourceObject Ptr (Ptr SocketAddress)
effectiveAddress
        Ptr SocketAddress
effectiveAddress' <- Ptr (Ptr SocketAddress) -> IO (Ptr SocketAddress)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr SocketAddress)
effectiveAddress
        SocketAddress
effectiveAddress'' <- ((ManagedPtr SocketAddress -> SocketAddress)
-> Ptr SocketAddress -> IO SocketAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SocketAddress -> SocketAddress
Gio.SocketAddress.SocketAddress) Ptr SocketAddress
effectiveAddress'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
address
        Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sourceObject c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        Ptr (Ptr SocketAddress) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr SocketAddress)
effectiveAddress
        SocketAddress -> IO SocketAddress
forall (m :: * -> *) a. Monad m => a -> m a
return SocketAddress
effectiveAddress''
     ) (do
        Ptr (Ptr SocketAddress) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr SocketAddress)
effectiveAddress
     )

#if ENABLE_OVERLOADING
data SocketListenerAddAddressMethodInfo
instance (signature ~ (b -> Gio.Enums.SocketType -> Gio.Enums.SocketProtocol -> Maybe (c) -> m (Gio.SocketAddress.SocketAddress)), MonadIO m, IsSocketListener a, Gio.SocketAddress.IsSocketAddress b, GObject.Object.IsObject c) => O.MethodInfo SocketListenerAddAddressMethodInfo a signature where
    overloadedMethod _ = socketListenerAddAddress

#endif

-- method SocketListener::add_any_inet_port
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional #GObject identifying this source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt16)
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_add_any_inet_port" g_socket_listener_add_any_inet_port :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (Ptr GError) ->                     -- error
    IO Word16

{- |
Listens for TCP connections on any available port number for both
IPv6 and IPv4 (if each is available).

This is useful if you need to have a socket for incoming connections
but don\'t care about the specific port number.

/@sourceObject@/ will be passed out in the various calls
to accept to identify this particular source, which is
useful if you\'re listening on multiple addresses and do
different things depending on what address is connected to.

/Since: 2.24/
-}
socketListenerAddAnyInetPort ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, GObject.Object.IsObject b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> Maybe (b)
    {- ^ /@sourceObject@/: Optional 'GI.GObject.Objects.Object.Object' identifying this source -}
    -> m Word16
    {- ^ __Returns:__ the port number, or 0 in case of failure. /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAddAnyInetPort :: a -> Maybe b -> m Word16
socketListenerAddAnyInetPort listener :: a
listener sourceObject :: Maybe b
sourceObject = IO Word16 -> m Word16
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr Object
maybeSourceObject <- case Maybe b
sourceObject of
        Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
        Just jSourceObject :: b
jSourceObject -> do
            Ptr Object
jSourceObject' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSourceObject
            Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSourceObject'
    IO Word16 -> IO () -> IO Word16
forall a b. IO a -> IO b -> IO a
onException (do
        Word16
result <- (Ptr (Ptr GError) -> IO Word16) -> IO Word16
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Word16) -> IO Word16)
-> (Ptr (Ptr GError) -> IO Word16) -> IO Word16
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener -> Ptr Object -> Ptr (Ptr GError) -> IO Word16
g_socket_listener_add_any_inet_port Ptr SocketListener
listener' Ptr Object
maybeSourceObject
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sourceObject b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        Word16 -> IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
result
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data SocketListenerAddAnyInetPortMethodInfo
instance (signature ~ (Maybe (b) -> m Word16), MonadIO m, IsSocketListener a, GObject.Object.IsObject b) => O.MethodInfo SocketListenerAddAnyInetPortMethodInfo a signature where
    overloadedMethod _ = socketListenerAddAnyInetPort

#endif

-- method SocketListener::add_inet_port
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an IP port number (non-zero)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional #GObject identifying this source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_add_inet_port" g_socket_listener_add_inet_port :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Word16 ->                               -- port : TBasicType TUInt16
    Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Helper function for 'GI.Gio.Objects.SocketListener.socketListenerAddAddress' that
creates a TCP\/IP socket listening on IPv4 and IPv6 (if
supported) on the specified port on all interfaces.

/@sourceObject@/ will be passed out in the various calls
to accept to identify this particular source, which is
useful if you\'re listening on multiple addresses and do
different things depending on what address is connected to.

Call 'GI.Gio.Objects.SocketListener.socketListenerClose' to stop listening on /@port@/; this will not
be done automatically when you drop your final reference to /@listener@/, as
references may be held internally.

/Since: 2.22/
-}
socketListenerAddInetPort ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, GObject.Object.IsObject b) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> Word16
    {- ^ /@port@/: an IP port number (non-zero) -}
    -> Maybe (b)
    {- ^ /@sourceObject@/: Optional 'GI.GObject.Objects.Object.Object' identifying this source -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAddInetPort :: a -> Word16 -> Maybe b -> m ()
socketListenerAddInetPort listener :: a
listener port :: Word16
port sourceObject :: Maybe b
sourceObject = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr Object
maybeSourceObject <- case Maybe b
sourceObject of
        Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
        Just jSourceObject :: b
jSourceObject -> do
            Ptr Object
jSourceObject' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSourceObject
            Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSourceObject'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener
-> Word16 -> Ptr Object -> Ptr (Ptr GError) -> IO CInt
g_socket_listener_add_inet_port Ptr SocketListener
listener' Word16
port Ptr Object
maybeSourceObject
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sourceObject b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data SocketListenerAddInetPortMethodInfo
instance (signature ~ (Word16 -> Maybe (b) -> m ()), MonadIO m, IsSocketListener a, GObject.Object.IsObject b) => O.MethodInfo SocketListenerAddInetPortMethodInfo a signature where
    overloadedMethod _ = socketListenerAddInetPort

#endif

-- method SocketListener::add_socket
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "socket", argType = TInterface (Name {namespace = "Gio", name = "Socket"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a listening #GSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Optional #GObject identifying this source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_socket_listener_add_socket" g_socket_listener_add_socket :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Ptr Gio.Socket.Socket ->                -- socket : TInterface (Name {namespace = "Gio", name = "Socket"})
    Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Adds /@socket@/ to the set of sockets that we try to accept
new clients from. The socket must be bound to a local
address and listened to.

/@sourceObject@/ will be passed out in the various calls
to accept to identify this particular source, which is
useful if you\'re listening on multiple addresses and do
different things depending on what address is connected to.

The /@socket@/ will not be automatically closed when the /@listener@/ is finalized
unless the listener held the final reference to the socket. Before GLib 2.42,
the /@socket@/ was automatically closed on finalization of the /@listener@/, even
if references to it were held elsewhere.

/Since: 2.22/
-}
socketListenerAddSocket ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a, Gio.Socket.IsSocket b, GObject.Object.IsObject c) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> b
    {- ^ /@socket@/: a listening 'GI.Gio.Objects.Socket.Socket' -}
    -> Maybe (c)
    {- ^ /@sourceObject@/: Optional 'GI.GObject.Objects.Object.Object' identifying this source -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
socketListenerAddSocket :: a -> b -> Maybe c -> m ()
socketListenerAddSocket listener :: a
listener socket :: b
socket sourceObject :: Maybe c
sourceObject = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr Socket
socket' <- b -> IO (Ptr Socket)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
socket
    Ptr Object
maybeSourceObject <- case Maybe c
sourceObject of
        Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
        Just jSourceObject :: c
jSourceObject -> do
            Ptr Object
jSourceObject' <- c -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSourceObject
            Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSourceObject'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr SocketListener
-> Ptr Socket -> Ptr Object -> Ptr (Ptr GError) -> IO CInt
g_socket_listener_add_socket Ptr SocketListener
listener' Ptr Socket
socket' Ptr Object
maybeSourceObject
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
socket
        Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sourceObject c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data SocketListenerAddSocketMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsSocketListener a, Gio.Socket.IsSocket b, GObject.Object.IsObject c) => O.MethodInfo SocketListenerAddSocketMethodInfo a signature where
    overloadedMethod _ = socketListenerAddSocket

#endif

-- method SocketListener::close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_listener_close" g_socket_listener_close :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    IO ()

{- |
Closes all the sockets in the listener.

/Since: 2.22/
-}
socketListenerClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> m ()
socketListenerClose :: a -> m ()
socketListenerClose listener :: a
listener = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr SocketListener -> IO ()
g_socket_listener_close Ptr SocketListener
listener'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SocketListenerCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSocketListener a) => O.MethodInfo SocketListenerCloseMethodInfo a signature where
    overloadedMethod _ = socketListenerClose

#endif

-- method SocketListener::set_backlog
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "listener", argType = TInterface (Name {namespace = "Gio", name = "SocketListener"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketListener", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "listen_backlog", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an integer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_socket_listener_set_backlog" g_socket_listener_set_backlog :: 
    Ptr SocketListener ->                   -- listener : TInterface (Name {namespace = "Gio", name = "SocketListener"})
    Int32 ->                                -- listen_backlog : TBasicType TInt
    IO ()

{- |
Sets the listen backlog on the sockets in the listener. This must be called
before adding any sockets, addresses or ports to the 'GI.Gio.Objects.SocketListener.SocketListener' (for
example, by calling 'GI.Gio.Objects.SocketListener.socketListenerAddInetPort') to be effective.

See 'GI.Gio.Objects.Socket.socketSetListenBacklog' for details

/Since: 2.22/
-}
socketListenerSetBacklog ::
    (B.CallStack.HasCallStack, MonadIO m, IsSocketListener a) =>
    a
    {- ^ /@listener@/: a 'GI.Gio.Objects.SocketListener.SocketListener' -}
    -> Int32
    {- ^ /@listenBacklog@/: an integer -}
    -> m ()
socketListenerSetBacklog :: a -> Int32 -> m ()
socketListenerSetBacklog listener :: a
listener listenBacklog :: Int32
listenBacklog = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SocketListener
listener' <- a -> IO (Ptr SocketListener)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listener
    Ptr SocketListener -> Int32 -> IO ()
g_socket_listener_set_backlog Ptr SocketListener
listener' Int32
listenBacklog
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listener
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SocketListenerSetBacklogMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsSocketListener a) => O.MethodInfo SocketListenerSetBacklogMethodInfo a signature where
    overloadedMethod _ = socketListenerSetBacklog

#endif