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

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 (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !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.GClosure as B.GClosure
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.GI.Base.Properties as B.Properties
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 GHC.OverloadedLabels as OL

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 = c_g_socket_listener_get_type
    

-- | Type class for types which can be safely cast to `SocketListener`, for instance with `toSocketListener`.
class (GObject o, O.IsDescendantOf SocketListener o) => IsSocketListener o
instance (GObject o, O.IsDescendantOf SocketListener o) => IsSocketListener o

instance O.HasParentTypes SocketListener
type instance O.ParentTypes SocketListener = '[GObject.Object.Object]

-- | 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 = liftIO . unsafeCastTo SocketListener

-- | A convenience alias for `Nothing` :: `Maybe` `SocketListener`.
noSocketListener :: Maybe SocketListener
noSocketListener = 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) => OL.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

-- 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 = 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 `GClosure`.
genClosure_SocketListenerEvent :: MonadIO m => SocketListenerEventCallback -> m (GClosure C_SocketListenerEventCallback)
genClosure_SocketListenerEvent cb = liftIO $ do
    let cb' = wrap_SocketListenerEventCallback cb
    mk_SocketListenerEventCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `SocketListenerEventCallback` into a `C_SocketListenerEventCallback`.
wrap_SocketListenerEventCallback ::
    SocketListenerEventCallback ->
    C_SocketListenerEventCallback
wrap_SocketListenerEventCallback _cb _ event socket _ = do
    let event' = (toEnum . fromIntegral) event
    socket' <- (newObject Gio.Socket.Socket) socket
    _cb  event' 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 obj cb = liftIO $ do
    let cb' = wrap_SocketListenerEventCallback cb
    cb'' <- mk_SocketListenerEventCallback cb'
    connectSignalFunPtr obj "event" cb'' 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 obj cb = liftIO $ do
    let cb' = wrap_SocketListenerEventCallback cb
    cb'' <- mk_SocketListenerEventCallback cb'
    connectSignalFunPtr obj "event" cb'' 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 obj = liftIO $ B.Properties.getObjectPropertyInt32 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 obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "listen-backlog" 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 val = B.Properties.constructObjectPropertyInt32 "listen-backlog" 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  = liftIO $ do
    result <- g_socket_listener_new
    checkUnexpectedReturnNULL "socketListenerNew" result
    result' <- (wrapObject SocketListener) result
    return 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 listener cancellable = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    sourceObject <- allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ g_socket_listener_accept listener' sourceObject maybeCancellable
        checkUnexpectedReturnNULL "socketListenerAccept" result
        result' <- (wrapObject Gio.SocketConnection.SocketConnection) result
        sourceObject' <- peek sourceObject
        maybeSourceObject' <- convertIfNonNull sourceObject' $ \sourceObject'' -> do
            sourceObject''' <- (newObject GObject.Object.Object) sourceObject''
            return sourceObject'''
        touchManagedPtr listener
        whenJust cancellable touchManagedPtr
        freeMem sourceObject
        return (result', maybeSourceObject')
     ) (do
        freeMem 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 listener cancellable callback = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_socket_listener_accept_async listener' maybeCancellable maybeCallback userData
    touchManagedPtr listener
    whenJust cancellable touchManagedPtr
    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 listener result_ = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    result_' <- unsafeManagedPtrCastPtr result_
    sourceObject <- allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    onException (do
        result <- propagateGError $ g_socket_listener_accept_finish listener' result_' sourceObject
        checkUnexpectedReturnNULL "socketListenerAcceptFinish" result
        result' <- (wrapObject Gio.SocketConnection.SocketConnection) result
        sourceObject' <- peek sourceObject
        maybeSourceObject' <- convertIfNonNull sourceObject' $ \sourceObject'' -> do
            sourceObject''' <- (newObject GObject.Object.Object) sourceObject''
            return sourceObject'''
        touchManagedPtr listener
        touchManagedPtr result_
        freeMem sourceObject
        return (result', maybeSourceObject')
     ) (do
        freeMem 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 listener cancellable = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    sourceObject <- allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ g_socket_listener_accept_socket listener' sourceObject maybeCancellable
        checkUnexpectedReturnNULL "socketListenerAcceptSocket" result
        result' <- (wrapObject Gio.Socket.Socket) result
        sourceObject' <- peek sourceObject
        maybeSourceObject' <- convertIfNonNull sourceObject' $ \sourceObject'' -> do
            sourceObject''' <- (newObject GObject.Object.Object) sourceObject''
            return sourceObject'''
        touchManagedPtr listener
        whenJust cancellable touchManagedPtr
        freeMem sourceObject
        return (result', maybeSourceObject')
     ) (do
        freeMem 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 listener cancellable callback = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_socket_listener_accept_socket_async listener' maybeCancellable maybeCallback userData
    touchManagedPtr listener
    whenJust cancellable touchManagedPtr
    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 listener result_ = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    result_' <- unsafeManagedPtrCastPtr result_
    sourceObject <- allocMem :: IO (Ptr (Ptr GObject.Object.Object))
    onException (do
        result <- propagateGError $ g_socket_listener_accept_socket_finish listener' result_' sourceObject
        checkUnexpectedReturnNULL "socketListenerAcceptSocketFinish" result
        result' <- (wrapObject Gio.Socket.Socket) result
        sourceObject' <- peek sourceObject
        maybeSourceObject' <- convertIfNonNull sourceObject' $ \sourceObject'' -> do
            sourceObject''' <- (newObject GObject.Object.Object) sourceObject''
            return sourceObject'''
        touchManagedPtr listener
        touchManagedPtr result_
        freeMem sourceObject
        return (result', maybeSourceObject')
     ) (do
        freeMem 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 listener address type_ protocol sourceObject = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    address' <- unsafeManagedPtrCastPtr address
    let type_' = (fromIntegral . fromEnum) type_
    let protocol' = (fromIntegral . fromEnum) protocol
    maybeSourceObject <- case sourceObject of
        Nothing -> return nullPtr
        Just jSourceObject -> do
            jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject
            return jSourceObject'
    effectiveAddress <- allocMem :: IO (Ptr (Ptr Gio.SocketAddress.SocketAddress))
    onException (do
        _ <- propagateGError $ g_socket_listener_add_address listener' address' type_' protocol' maybeSourceObject effectiveAddress
        effectiveAddress' <- peek effectiveAddress
        effectiveAddress'' <- (wrapObject Gio.SocketAddress.SocketAddress) effectiveAddress'
        touchManagedPtr listener
        touchManagedPtr address
        whenJust sourceObject touchManagedPtr
        freeMem effectiveAddress
        return effectiveAddress''
     ) (do
        freeMem 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 listener sourceObject = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    maybeSourceObject <- case sourceObject of
        Nothing -> return nullPtr
        Just jSourceObject -> do
            jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject
            return jSourceObject'
    onException (do
        result <- propagateGError $ g_socket_listener_add_any_inet_port listener' maybeSourceObject
        touchManagedPtr listener
        whenJust sourceObject touchManagedPtr
        return result
     ) (do
        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 listener port sourceObject = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    maybeSourceObject <- case sourceObject of
        Nothing -> return nullPtr
        Just jSourceObject -> do
            jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject
            return jSourceObject'
    onException (do
        _ <- propagateGError $ g_socket_listener_add_inet_port listener' port maybeSourceObject
        touchManagedPtr listener
        whenJust sourceObject touchManagedPtr
        return ()
     ) (do
        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 listener socket sourceObject = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    socket' <- unsafeManagedPtrCastPtr socket
    maybeSourceObject <- case sourceObject of
        Nothing -> return nullPtr
        Just jSourceObject -> do
            jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject
            return jSourceObject'
    onException (do
        _ <- propagateGError $ g_socket_listener_add_socket listener' socket' maybeSourceObject
        touchManagedPtr listener
        touchManagedPtr socket
        whenJust sourceObject touchManagedPtr
        return ()
     ) (do
        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 listener = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    g_socket_listener_close listener'
    touchManagedPtr listener
    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.

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 listener listenBacklog = liftIO $ do
    listener' <- unsafeManagedPtrCastPtr listener
    g_socket_listener_set_backlog listener' listenBacklog
    touchManagedPtr listener
    return ()

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

#endif