-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Soup.Callbacks
    ( 

 -- * Signals
-- ** AddressCallback #signal:AddressCallback#

    AddressCallback                         ,
    AddressCallback_WithClosures            ,
    C_AddressCallback                       ,
    drop_closures_AddressCallback           ,
    dynamic_AddressCallback                 ,
    genClosure_AddressCallback              ,
    mk_AddressCallback                      ,
    noAddressCallback                       ,
    noAddressCallback_WithClosures          ,
    wrap_AddressCallback                    ,


-- ** AuthDomainBasicAuthCallback #signal:AuthDomainBasicAuthCallback#

    AuthDomainBasicAuthCallback             ,
    AuthDomainBasicAuthCallback_WithClosures,
    C_AuthDomainBasicAuthCallback           ,
    drop_closures_AuthDomainBasicAuthCallback,
    dynamic_AuthDomainBasicAuthCallback     ,
    genClosure_AuthDomainBasicAuthCallback  ,
    mk_AuthDomainBasicAuthCallback          ,
    noAuthDomainBasicAuthCallback           ,
    noAuthDomainBasicAuthCallback_WithClosures,
    wrap_AuthDomainBasicAuthCallback        ,


-- ** AuthDomainDigestAuthCallback #signal:AuthDomainDigestAuthCallback#

    AuthDomainDigestAuthCallback            ,
    AuthDomainDigestAuthCallback_WithClosures,
    C_AuthDomainDigestAuthCallback          ,
    drop_closures_AuthDomainDigestAuthCallback,
    dynamic_AuthDomainDigestAuthCallback    ,
    genClosure_AuthDomainDigestAuthCallback ,
    mk_AuthDomainDigestAuthCallback         ,
    noAuthDomainDigestAuthCallback          ,
    noAuthDomainDigestAuthCallback_WithClosures,
    wrap_AuthDomainDigestAuthCallback       ,


-- ** AuthDomainFilter #signal:AuthDomainFilter#

    AuthDomainFilter                        ,
    AuthDomainFilter_WithClosures           ,
    C_AuthDomainFilter                      ,
    drop_closures_AuthDomainFilter          ,
    dynamic_AuthDomainFilter                ,
    genClosure_AuthDomainFilter             ,
    mk_AuthDomainFilter                     ,
    noAuthDomainFilter                      ,
    noAuthDomainFilter_WithClosures         ,
    wrap_AuthDomainFilter                   ,


-- ** AuthDomainGenericAuthCallback #signal:AuthDomainGenericAuthCallback#

    AuthDomainGenericAuthCallback           ,
    AuthDomainGenericAuthCallback_WithClosures,
    C_AuthDomainGenericAuthCallback         ,
    drop_closures_AuthDomainGenericAuthCallback,
    dynamic_AuthDomainGenericAuthCallback   ,
    genClosure_AuthDomainGenericAuthCallback,
    mk_AuthDomainGenericAuthCallback        ,
    noAuthDomainGenericAuthCallback         ,
    noAuthDomainGenericAuthCallback_WithClosures,
    wrap_AuthDomainGenericAuthCallback      ,


-- ** ChunkAllocator #signal:ChunkAllocator#

    C_ChunkAllocator                        ,
    ChunkAllocator                          ,
    ChunkAllocator_WithClosures             ,
    drop_closures_ChunkAllocator            ,
    dynamic_ChunkAllocator                  ,
    genClosure_ChunkAllocator               ,
    mk_ChunkAllocator                       ,
    noChunkAllocator                        ,
    noChunkAllocator_WithClosures           ,
    wrap_ChunkAllocator                     ,


-- ** LoggerFilter #signal:LoggerFilter#

    C_LoggerFilter                          ,
    LoggerFilter                            ,
    LoggerFilter_WithClosures               ,
    drop_closures_LoggerFilter              ,
    dynamic_LoggerFilter                    ,
    genClosure_LoggerFilter                 ,
    mk_LoggerFilter                         ,
    noLoggerFilter                          ,
    noLoggerFilter_WithClosures             ,
    wrap_LoggerFilter                       ,


-- ** LoggerPrinter #signal:LoggerPrinter#

    C_LoggerPrinter                         ,
    LoggerPrinter                           ,
    LoggerPrinter_WithClosures              ,
    drop_closures_LoggerPrinter             ,
    dynamic_LoggerPrinter                   ,
    genClosure_LoggerPrinter                ,
    mk_LoggerPrinter                        ,
    noLoggerPrinter                         ,
    noLoggerPrinter_WithClosures            ,
    wrap_LoggerPrinter                      ,


-- ** MessageHeadersForeachFunc #signal:MessageHeadersForeachFunc#

    C_MessageHeadersForeachFunc             ,
    MessageHeadersForeachFunc               ,
    MessageHeadersForeachFunc_WithClosures  ,
    drop_closures_MessageHeadersForeachFunc ,
    dynamic_MessageHeadersForeachFunc       ,
    genClosure_MessageHeadersForeachFunc    ,
    mk_MessageHeadersForeachFunc            ,
    noMessageHeadersForeachFunc             ,
    noMessageHeadersForeachFunc_WithClosures,
    wrap_MessageHeadersForeachFunc          ,


-- ** PasswordManagerCallback #signal:PasswordManagerCallback#

    C_PasswordManagerCallback               ,
    PasswordManagerCallback                 ,
    PasswordManagerCallback_WithClosures    ,
    drop_closures_PasswordManagerCallback   ,
    dynamic_PasswordManagerCallback         ,
    genClosure_PasswordManagerCallback      ,
    mk_PasswordManagerCallback              ,
    noPasswordManagerCallback               ,
    noPasswordManagerCallback_WithClosures  ,
    wrap_PasswordManagerCallback            ,


-- ** ProxyResolverCallback #signal:ProxyResolverCallback#

    C_ProxyResolverCallback                 ,
    ProxyResolverCallback                   ,
    ProxyResolverCallback_WithClosures      ,
    drop_closures_ProxyResolverCallback     ,
    dynamic_ProxyResolverCallback           ,
    genClosure_ProxyResolverCallback        ,
    mk_ProxyResolverCallback                ,
    noProxyResolverCallback                 ,
    noProxyResolverCallback_WithClosures    ,
    wrap_ProxyResolverCallback              ,


-- ** ProxyURIResolverCallback #signal:ProxyURIResolverCallback#

    C_ProxyURIResolverCallback              ,
    ProxyURIResolverCallback                ,
    ProxyURIResolverCallback_WithClosures   ,
    drop_closures_ProxyURIResolverCallback  ,
    dynamic_ProxyURIResolverCallback        ,
    genClosure_ProxyURIResolverCallback     ,
    mk_ProxyURIResolverCallback             ,
    noProxyURIResolverCallback              ,
    noProxyURIResolverCallback_WithClosures ,
    wrap_ProxyURIResolverCallback           ,


-- ** ServerCallback #signal:ServerCallback#

    C_ServerCallback                        ,
    ServerCallback                          ,
    ServerCallback_WithClosures             ,
    drop_closures_ServerCallback            ,
    dynamic_ServerCallback                  ,
    genClosure_ServerCallback               ,
    mk_ServerCallback                       ,
    noServerCallback                        ,
    noServerCallback_WithClosures           ,
    wrap_ServerCallback                     ,


-- ** ServerWebsocketCallback #signal:ServerWebsocketCallback#

    C_ServerWebsocketCallback               ,
    ServerWebsocketCallback                 ,
    ServerWebsocketCallback_WithClosures    ,
    drop_closures_ServerWebsocketCallback   ,
    dynamic_ServerWebsocketCallback         ,
    genClosure_ServerWebsocketCallback      ,
    mk_ServerWebsocketCallback              ,
    noServerWebsocketCallback               ,
    noServerWebsocketCallback_WithClosures  ,
    wrap_ServerWebsocketCallback            ,


-- ** SessionCallback #signal:SessionCallback#

    C_SessionCallback                       ,
    SessionCallback                         ,
    SessionCallback_WithClosures            ,
    drop_closures_SessionCallback           ,
    dynamic_SessionCallback                 ,
    genClosure_SessionCallback              ,
    mk_SessionCallback                      ,
    noSessionCallback                       ,
    noSessionCallback_WithClosures          ,
    wrap_SessionCallback                    ,


-- ** SessionConnectProgressCallback #signal:SessionConnectProgressCallback#

    C_SessionConnectProgressCallback        ,
    SessionConnectProgressCallback          ,
    SessionConnectProgressCallback_WithClosures,
    drop_closures_SessionConnectProgressCallback,
    dynamic_SessionConnectProgressCallback  ,
    genClosure_SessionConnectProgressCallback,
    mk_SessionConnectProgressCallback       ,
    noSessionConnectProgressCallback        ,
    noSessionConnectProgressCallback_WithClosures,
    wrap_SessionConnectProgressCallback     ,


-- ** SocketCallback #signal:SocketCallback#

    C_SocketCallback                        ,
    SocketCallback                          ,
    SocketCallback_WithClosures             ,
    drop_closures_SocketCallback            ,
    dynamic_SocketCallback                  ,
    genClosure_SocketCallback               ,
    mk_SocketCallback                       ,
    noSocketCallback                        ,
    noSocketCallback_WithClosures           ,
    wrap_SocketCallback                     ,




    ) 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.GI.Base.Signals as B.Signals
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.Gio.Enums as Gio.Enums
import qualified GI.Gio.Objects.IOStream as Gio.IOStream
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Interfaces.PasswordManager as Soup.PasswordManager
import {-# SOURCE #-} qualified GI.Soup.Interfaces.ProxyResolver as Soup.ProxyResolver
import {-# SOURCE #-} qualified GI.Soup.Interfaces.ProxyURIResolver as Soup.ProxyURIResolver
import {-# SOURCE #-} qualified GI.Soup.Objects.Address as Soup.Address
import {-# SOURCE #-} qualified GI.Soup.Objects.Auth as Soup.Auth
import {-# SOURCE #-} qualified GI.Soup.Objects.AuthDomain as Soup.AuthDomain
import {-# SOURCE #-} qualified GI.Soup.Objects.AuthDomainBasic as Soup.AuthDomainBasic
import {-# SOURCE #-} qualified GI.Soup.Objects.AuthDomainDigest as Soup.AuthDomainDigest
import {-# SOURCE #-} qualified GI.Soup.Objects.Logger as Soup.Logger
import {-# SOURCE #-} qualified GI.Soup.Objects.Message as Soup.Message
import {-# SOURCE #-} qualified GI.Soup.Objects.Server as Soup.Server
import {-# SOURCE #-} qualified GI.Soup.Objects.Session as Soup.Session
import {-# SOURCE #-} qualified GI.Soup.Objects.Socket as Soup.Socket
import {-# SOURCE #-} qualified GI.Soup.Objects.WebsocketConnection as Soup.WebsocketConnection
import {-# SOURCE #-} qualified GI.Soup.Structs.Buffer as Soup.Buffer
import {-# SOURCE #-} qualified GI.Soup.Structs.ClientContext as Soup.ClientContext
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI

-- callback SocketCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "sock", argType = TInterface (Name {namespace = "Soup", name = "Socket"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "status", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an HTTP status code indicating success or failure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_socket_connect_async()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The callback function passed to soup_socket_connect_async().", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_SocketCallback =
    Ptr Soup.Socket.Socket ->
    Word32 ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "sock"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Socket" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupSocket" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "status"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "an HTTP status code indicating success or failure"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the data passed to soup_socket_connect_async()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SocketCallback :: FunPtr C_SocketCallback -> C_SocketCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SocketCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Socket.IsSocket a) =>
    FunPtr C_SocketCallback
    -> a
    -- ^ /@sock@/: the t'GI.Soup.Objects.Socket.Socket'
    -> Word32
    -- ^ /@status@/: an HTTP status code indicating success or failure
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Socket.socketConnectAsync'
    -> m ()
dynamic_SocketCallback :: FunPtr C_SocketCallback -> a -> Word32 -> Ptr () -> m ()
dynamic_SocketCallback __funPtr :: FunPtr C_SocketCallback
__funPtr sock :: a
sock status :: Word32
status userData :: Ptr ()
userData = 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 Socket
sock' <- a -> IO (Ptr Socket)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
sock
    (FunPtr C_SocketCallback -> C_SocketCallback
__dynamic_C_SocketCallback FunPtr C_SocketCallback
__funPtr) Ptr Socket
sock' Word32
status Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
sock
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | The callback function passed to 'GI.Soup.Objects.Socket.socketConnectAsync'.
type SocketCallback =
    Soup.Socket.Socket
    -- ^ /@sock@/: the t'GI.Soup.Objects.Socket.Socket'
    -> Word32
    -- ^ /@status@/: an HTTP status code indicating success or failure
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SocketCallback`@.
noSocketCallback :: Maybe SocketCallback
noSocketCallback :: Maybe SocketCallback
noSocketCallback = Maybe SocketCallback
forall a. Maybe a
Nothing

-- | The callback function passed to 'GI.Soup.Objects.Socket.socketConnectAsync'.
type SocketCallback_WithClosures =
    Soup.Socket.Socket
    -- ^ /@sock@/: the t'GI.Soup.Objects.Socket.Socket'
    -> Word32
    -- ^ /@status@/: an HTTP status code indicating success or failure
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Socket.socketConnectAsync'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SocketCallback_WithClosures`@.
noSocketCallback_WithClosures :: Maybe SocketCallback_WithClosures
noSocketCallback_WithClosures :: Maybe SocketCallback_WithClosures
noSocketCallback_WithClosures = Maybe SocketCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SocketCallback :: SocketCallback -> SocketCallback_WithClosures
drop_closures_SocketCallback :: SocketCallback -> SocketCallback_WithClosures
drop_closures_SocketCallback _f :: SocketCallback
_f sock :: Socket
sock status :: Word32
status _ = SocketCallback
_f Socket
sock Word32
status

-- | Wrap the callback into a `GClosure`.
genClosure_SocketCallback :: MonadIO m => SocketCallback -> m (GClosure C_SocketCallback)
genClosure_SocketCallback :: SocketCallback -> m (GClosure C_SocketCallback)
genClosure_SocketCallback cb :: SocketCallback
cb = IO (GClosure C_SocketCallback) -> m (GClosure C_SocketCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SocketCallback) -> m (GClosure C_SocketCallback))
-> IO (GClosure C_SocketCallback) -> m (GClosure C_SocketCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: SocketCallback_WithClosures
cb' = SocketCallback -> SocketCallback_WithClosures
drop_closures_SocketCallback SocketCallback
cb
    let cb'' :: C_SocketCallback
cb'' = Maybe (Ptr (FunPtr C_SocketCallback))
-> SocketCallback_WithClosures -> C_SocketCallback
wrap_SocketCallback Maybe (Ptr (FunPtr C_SocketCallback))
forall a. Maybe a
Nothing SocketCallback_WithClosures
cb'
    C_SocketCallback -> IO (FunPtr C_SocketCallback)
mk_SocketCallback C_SocketCallback
cb'' IO (FunPtr C_SocketCallback)
-> (FunPtr C_SocketCallback -> IO (GClosure C_SocketCallback))
-> IO (GClosure C_SocketCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SocketCallback -> IO (GClosure C_SocketCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SocketCallback` into a `C_SocketCallback`.
wrap_SocketCallback ::
    Maybe (Ptr (FunPtr C_SocketCallback)) ->
    SocketCallback_WithClosures ->
    C_SocketCallback
wrap_SocketCallback :: Maybe (Ptr (FunPtr C_SocketCallback))
-> SocketCallback_WithClosures -> C_SocketCallback
wrap_SocketCallback funptrptr :: Maybe (Ptr (FunPtr C_SocketCallback))
funptrptr _cb :: SocketCallback_WithClosures
_cb sock :: Ptr Socket
sock status :: Word32
status userData :: Ptr ()
userData = do
    Socket
sock' <- ((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
Soup.Socket.Socket) Ptr Socket
sock
    SocketCallback_WithClosures
_cb  Socket
sock' Word32
status Ptr ()
userData
    Maybe (Ptr (FunPtr C_SocketCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SocketCallback))
funptrptr


-- callback SessionConnectProgressCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "session", argType = TInterface (Name {namespace = "Soup", name = "Session"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupSession", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gio", name = "SocketClientEvent"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketClientEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the current state of the network connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_session_connect_async().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Prototype for the progress callback passed to soup_session_connect_async().", sinceVersion = Just "2.62"}}
-- | Type for the callback on the (unwrapped) C side.
type C_SessionConnectProgressCallback =
    Ptr Soup.Session.Session ->
    CUInt ->
    Ptr Gio.IOStream.IOStream ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "session"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Session" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupSession" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "SocketClientEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSocketClientEvent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "IOStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the current state of the network connection"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the data passed to soup_session_connect_async()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SessionConnectProgressCallback :: FunPtr C_SessionConnectProgressCallback -> C_SessionConnectProgressCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SessionConnectProgressCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Session.IsSession a, Gio.IOStream.IsIOStream b) =>
    FunPtr C_SessionConnectProgressCallback
    -> a
    -- ^ /@session@/: the t'GI.Soup.Objects.Session.Session'
    -> Gio.Enums.SocketClientEvent
    -- ^ /@event@/: a t'GI.Gio.Enums.SocketClientEvent'
    -> b
    -- ^ /@connection@/: the current state of the network connection
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Session.sessionConnectAsync'.
    -> m ()
dynamic_SessionConnectProgressCallback :: FunPtr C_SessionConnectProgressCallback
-> a -> SocketClientEvent -> b -> Ptr () -> m ()
dynamic_SessionConnectProgressCallback __funPtr :: FunPtr C_SessionConnectProgressCallback
__funPtr session :: a
session event :: SocketClientEvent
event connection :: b
connection userData :: Ptr ()
userData = 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 Session
session' <- a -> IO (Ptr Session)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
session
    let event' :: CUInt
event' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (SocketClientEvent -> Int) -> SocketClientEvent -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SocketClientEvent -> Int
forall a. Enum a => a -> Int
fromEnum) SocketClientEvent
event
    Ptr IOStream
connection' <- b -> IO (Ptr IOStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
connection
    (FunPtr C_SessionConnectProgressCallback
-> C_SessionConnectProgressCallback
__dynamic_C_SessionConnectProgressCallback FunPtr C_SessionConnectProgressCallback
__funPtr) Ptr Session
session' CUInt
event' Ptr IOStream
connection' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
session
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
connection
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | Prototype for the progress callback passed to 'GI.Soup.Objects.Session.sessionConnectAsync'.
-- 
-- /Since: 2.62/
type SessionConnectProgressCallback =
    Soup.Session.Session
    -- ^ /@session@/: the t'GI.Soup.Objects.Session.Session'
    -> Gio.Enums.SocketClientEvent
    -- ^ /@event@/: a t'GI.Gio.Enums.SocketClientEvent'
    -> Gio.IOStream.IOStream
    -- ^ /@connection@/: the current state of the network connection
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SessionConnectProgressCallback`@.
noSessionConnectProgressCallback :: Maybe SessionConnectProgressCallback
noSessionConnectProgressCallback :: Maybe SessionConnectProgressCallback
noSessionConnectProgressCallback = Maybe SessionConnectProgressCallback
forall a. Maybe a
Nothing

-- | Prototype for the progress callback passed to 'GI.Soup.Objects.Session.sessionConnectAsync'.
-- 
-- /Since: 2.62/
type SessionConnectProgressCallback_WithClosures =
    Soup.Session.Session
    -- ^ /@session@/: the t'GI.Soup.Objects.Session.Session'
    -> Gio.Enums.SocketClientEvent
    -- ^ /@event@/: a t'GI.Gio.Enums.SocketClientEvent'
    -> Gio.IOStream.IOStream
    -- ^ /@connection@/: the current state of the network connection
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Session.sessionConnectAsync'.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SessionConnectProgressCallback_WithClosures`@.
noSessionConnectProgressCallback_WithClosures :: Maybe SessionConnectProgressCallback_WithClosures
noSessionConnectProgressCallback_WithClosures :: Maybe SessionConnectProgressCallback_WithClosures
noSessionConnectProgressCallback_WithClosures = Maybe SessionConnectProgressCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SessionConnectProgressCallback :: SessionConnectProgressCallback -> SessionConnectProgressCallback_WithClosures
drop_closures_SessionConnectProgressCallback :: SessionConnectProgressCallback
-> SessionConnectProgressCallback_WithClosures
drop_closures_SessionConnectProgressCallback _f :: SessionConnectProgressCallback
_f session :: Session
session event :: SocketClientEvent
event connection :: IOStream
connection _ = SessionConnectProgressCallback
_f Session
session SocketClientEvent
event IOStream
connection

-- | Wrap the callback into a `GClosure`.
genClosure_SessionConnectProgressCallback :: MonadIO m => SessionConnectProgressCallback -> m (GClosure C_SessionConnectProgressCallback)
genClosure_SessionConnectProgressCallback :: SessionConnectProgressCallback
-> m (GClosure C_SessionConnectProgressCallback)
genClosure_SessionConnectProgressCallback cb :: SessionConnectProgressCallback
cb = IO (GClosure C_SessionConnectProgressCallback)
-> m (GClosure C_SessionConnectProgressCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SessionConnectProgressCallback)
 -> m (GClosure C_SessionConnectProgressCallback))
-> IO (GClosure C_SessionConnectProgressCallback)
-> m (GClosure C_SessionConnectProgressCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: SessionConnectProgressCallback_WithClosures
cb' = SessionConnectProgressCallback
-> SessionConnectProgressCallback_WithClosures
drop_closures_SessionConnectProgressCallback SessionConnectProgressCallback
cb
    let cb'' :: C_SessionConnectProgressCallback
cb'' = Maybe (Ptr (FunPtr C_SessionConnectProgressCallback))
-> SessionConnectProgressCallback_WithClosures
-> C_SessionConnectProgressCallback
wrap_SessionConnectProgressCallback Maybe (Ptr (FunPtr C_SessionConnectProgressCallback))
forall a. Maybe a
Nothing SessionConnectProgressCallback_WithClosures
cb'
    C_SessionConnectProgressCallback
-> IO (FunPtr C_SessionConnectProgressCallback)
mk_SessionConnectProgressCallback C_SessionConnectProgressCallback
cb'' IO (FunPtr C_SessionConnectProgressCallback)
-> (FunPtr C_SessionConnectProgressCallback
    -> IO (GClosure C_SessionConnectProgressCallback))
-> IO (GClosure C_SessionConnectProgressCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SessionConnectProgressCallback
-> IO (GClosure C_SessionConnectProgressCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SessionConnectProgressCallback` into a `C_SessionConnectProgressCallback`.
wrap_SessionConnectProgressCallback ::
    Maybe (Ptr (FunPtr C_SessionConnectProgressCallback)) ->
    SessionConnectProgressCallback_WithClosures ->
    C_SessionConnectProgressCallback
wrap_SessionConnectProgressCallback :: Maybe (Ptr (FunPtr C_SessionConnectProgressCallback))
-> SessionConnectProgressCallback_WithClosures
-> C_SessionConnectProgressCallback
wrap_SessionConnectProgressCallback funptrptr :: Maybe (Ptr (FunPtr C_SessionConnectProgressCallback))
funptrptr _cb :: SessionConnectProgressCallback_WithClosures
_cb session :: Ptr Session
session event :: CUInt
event connection :: Ptr IOStream
connection userData :: Ptr ()
userData = do
    Session
session' <- ((ManagedPtr Session -> Session) -> Ptr Session -> IO Session
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Session -> Session
Soup.Session.Session) Ptr Session
session
    let event' :: SocketClientEvent
event' = (Int -> SocketClientEvent
forall a. Enum a => Int -> a
toEnum (Int -> SocketClientEvent)
-> (CUInt -> Int) -> CUInt -> SocketClientEvent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
event
    IOStream
connection' <- ((ManagedPtr IOStream -> IOStream) -> Ptr IOStream -> IO IOStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr IOStream -> IOStream
Gio.IOStream.IOStream) Ptr IOStream
connection
    SessionConnectProgressCallback_WithClosures
_cb  Session
session' SocketClientEvent
event' IOStream
connection' Ptr ()
userData
    Maybe (Ptr (FunPtr C_SessionConnectProgressCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SessionConnectProgressCallback))
funptrptr


-- callback SessionCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "session", argType = TInterface (Name {namespace = "Soup", name = "Session"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the session", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message that has finished", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_session_queue_message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Prototype for the callback passed to soup_session_queue_message(),\nqv.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_SessionCallback =
    Ptr Soup.Session.Session ->
    Ptr Soup.Message.Message ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "session"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Session" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the session" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message that has finished"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data passed to soup_session_queue_message"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SessionCallback :: FunPtr C_SessionCallback -> C_SessionCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SessionCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Session.IsSession a, Soup.Message.IsMessage b) =>
    FunPtr C_SessionCallback
    -> a
    -- ^ /@session@/: the session
    -> b
    -- ^ /@msg@/: the message that has finished
    -> Ptr ()
    -- ^ /@userData@/: the data passed to soup_session_queue_message
    -> m ()
dynamic_SessionCallback :: FunPtr C_SessionCallback -> a -> b -> Ptr () -> m ()
dynamic_SessionCallback __funPtr :: FunPtr C_SessionCallback
__funPtr session :: a
session msg :: b
msg userData :: Ptr ()
userData = 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 Session
session' <- a -> IO (Ptr Session)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
session
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    (FunPtr C_SessionCallback -> C_SessionCallback
__dynamic_C_SessionCallback FunPtr C_SessionCallback
__funPtr) Ptr Session
session' Ptr Message
msg' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
session
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | Prototype for the callback passed to 'GI.Soup.Objects.Session.sessionQueueMessage',
-- qv.
type SessionCallback =
    Soup.Session.Session
    -- ^ /@session@/: the session
    -> Soup.Message.Message
    -- ^ /@msg@/: the message that has finished
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SessionCallback`@.
noSessionCallback :: Maybe SessionCallback
noSessionCallback :: Maybe SessionCallback
noSessionCallback = Maybe SessionCallback
forall a. Maybe a
Nothing

-- | Prototype for the callback passed to 'GI.Soup.Objects.Session.sessionQueueMessage',
-- qv.
type SessionCallback_WithClosures =
    Soup.Session.Session
    -- ^ /@session@/: the session
    -> Soup.Message.Message
    -- ^ /@msg@/: the message that has finished
    -> Ptr ()
    -- ^ /@userData@/: the data passed to soup_session_queue_message
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SessionCallback_WithClosures`@.
noSessionCallback_WithClosures :: Maybe SessionCallback_WithClosures
noSessionCallback_WithClosures :: Maybe SessionCallback_WithClosures
noSessionCallback_WithClosures = Maybe SessionCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SessionCallback :: SessionCallback -> SessionCallback_WithClosures
drop_closures_SessionCallback :: SessionCallback -> SessionCallback_WithClosures
drop_closures_SessionCallback _f :: SessionCallback
_f session :: Session
session msg :: Message
msg _ = SessionCallback
_f Session
session Message
msg

-- | Wrap the callback into a `GClosure`.
genClosure_SessionCallback :: MonadIO m => SessionCallback -> m (GClosure C_SessionCallback)
genClosure_SessionCallback :: SessionCallback -> m (GClosure C_SessionCallback)
genClosure_SessionCallback cb :: SessionCallback
cb = IO (GClosure C_SessionCallback) -> m (GClosure C_SessionCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SessionCallback) -> m (GClosure C_SessionCallback))
-> IO (GClosure C_SessionCallback)
-> m (GClosure C_SessionCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: SessionCallback_WithClosures
cb' = SessionCallback -> SessionCallback_WithClosures
drop_closures_SessionCallback SessionCallback
cb
    let cb'' :: C_SessionCallback
cb'' = Maybe (Ptr (FunPtr C_SessionCallback))
-> SessionCallback_WithClosures -> C_SessionCallback
wrap_SessionCallback Maybe (Ptr (FunPtr C_SessionCallback))
forall a. Maybe a
Nothing SessionCallback_WithClosures
cb'
    C_SessionCallback -> IO (FunPtr C_SessionCallback)
mk_SessionCallback C_SessionCallback
cb'' IO (FunPtr C_SessionCallback)
-> (FunPtr C_SessionCallback -> IO (GClosure C_SessionCallback))
-> IO (GClosure C_SessionCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SessionCallback -> IO (GClosure C_SessionCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SessionCallback` into a `C_SessionCallback`.
wrap_SessionCallback ::
    Maybe (Ptr (FunPtr C_SessionCallback)) ->
    SessionCallback_WithClosures ->
    C_SessionCallback
wrap_SessionCallback :: Maybe (Ptr (FunPtr C_SessionCallback))
-> SessionCallback_WithClosures -> C_SessionCallback
wrap_SessionCallback funptrptr :: Maybe (Ptr (FunPtr C_SessionCallback))
funptrptr _cb :: SessionCallback_WithClosures
_cb session :: Ptr Session
session msg :: Ptr Message
msg userData :: Ptr ()
userData = do
    Session
session' <- ((ManagedPtr Session -> Session) -> Ptr Session -> IO Session
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Session -> Session
Soup.Session.Session) Ptr Session
session
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    SessionCallback_WithClosures
_cb  Session
session' Message
msg' Ptr ()
userData
    Maybe (Ptr (FunPtr C_SessionCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SessionCallback))
funptrptr


-- callback ServerWebsocketCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "server", argType = TInterface (Name {namespace = "Soup", name = "Server"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupServer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "connection", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the newly created WebSocket connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path component of @msg's Request-URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "client", argType = TInterface (Name {namespace = "Soup", name = "ClientContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "additional contextual information about the client", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to @soup_server_add_handler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback used to handle WebSocket requests to a #SoupServer. The\ncallback will be invoked after sending the handshake response back\nto the client (and is only invoked if the handshake was\nsuccessful).\n\n@path contains the path of the Request-URI, subject to the same\nrules as #SoupServerCallback (qv).", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ServerWebsocketCallback =
    Ptr Soup.Server.Server ->
    Ptr Soup.WebsocketConnection.WebsocketConnection ->
    CString ->
    Ptr Soup.ClientContext.ClientContext ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "server"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Server" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupServer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "WebsocketConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the newly created WebSocket connection"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path component of @msg's Request-URI"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "client"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ClientContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "additional contextual information about the client"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data passed to @soup_server_add_handler"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ServerWebsocketCallback :: FunPtr C_ServerWebsocketCallback -> C_ServerWebsocketCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ServerWebsocketCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Server.IsServer a, Soup.WebsocketConnection.IsWebsocketConnection b) =>
    FunPtr C_ServerWebsocketCallback
    -> a
    -- ^ /@server@/: the t'GI.Soup.Objects.Server.Server'
    -> b
    -- ^ /@connection@/: the newly created WebSocket connection
    -> T.Text
    -- ^ /@path@/: the path component of /@msg@/\'s Request-URI
    -> Soup.ClientContext.ClientContext
    -- ^ /@client@/: additional contextual information about the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to /@soupServerAddHandler@/
    -> m ()
dynamic_ServerWebsocketCallback :: FunPtr C_ServerWebsocketCallback
-> a -> b -> Text -> ClientContext -> Ptr () -> m ()
dynamic_ServerWebsocketCallback __funPtr :: FunPtr C_ServerWebsocketCallback
__funPtr server :: a
server connection :: b
connection path :: Text
path client :: ClientContext
client userData :: Ptr ()
userData = 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 Server
server' <- a -> IO (Ptr Server)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
server
    Ptr WebsocketConnection
connection' <- b -> IO (Ptr WebsocketConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
connection
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr ClientContext
client' <- ClientContext -> IO (Ptr ClientContext)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ClientContext
client
    (FunPtr C_ServerWebsocketCallback -> C_ServerWebsocketCallback
__dynamic_C_ServerWebsocketCallback FunPtr C_ServerWebsocketCallback
__funPtr) Ptr Server
server' Ptr WebsocketConnection
connection' CString
path' Ptr ClientContext
client' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
server
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
connection
    ClientContext -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ClientContext
client
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | A callback used to handle WebSocket requests to a t'GI.Soup.Objects.Server.Server'. The
-- callback will be invoked after sending the handshake response back
-- to the client (and is only invoked if the handshake was
-- successful).
-- 
-- /@path@/ contains the path of the Request-URI, subject to the same
-- rules as t'GI.Soup.Callbacks.ServerCallback' (qv).
type ServerWebsocketCallback =
    Soup.Server.Server
    -- ^ /@server@/: the t'GI.Soup.Objects.Server.Server'
    -> Soup.WebsocketConnection.WebsocketConnection
    -- ^ /@connection@/: the newly created WebSocket connection
    -> T.Text
    -- ^ /@path@/: the path component of /@msg@/\'s Request-URI
    -> Soup.ClientContext.ClientContext
    -- ^ /@client@/: additional contextual information about the client
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ServerWebsocketCallback`@.
noServerWebsocketCallback :: Maybe ServerWebsocketCallback
noServerWebsocketCallback :: Maybe ServerWebsocketCallback
noServerWebsocketCallback = Maybe ServerWebsocketCallback
forall a. Maybe a
Nothing

-- | A callback used to handle WebSocket requests to a t'GI.Soup.Objects.Server.Server'. The
-- callback will be invoked after sending the handshake response back
-- to the client (and is only invoked if the handshake was
-- successful).
-- 
-- /@path@/ contains the path of the Request-URI, subject to the same
-- rules as t'GI.Soup.Callbacks.ServerCallback' (qv).
type ServerWebsocketCallback_WithClosures =
    Soup.Server.Server
    -- ^ /@server@/: the t'GI.Soup.Objects.Server.Server'
    -> Soup.WebsocketConnection.WebsocketConnection
    -- ^ /@connection@/: the newly created WebSocket connection
    -> T.Text
    -- ^ /@path@/: the path component of /@msg@/\'s Request-URI
    -> Soup.ClientContext.ClientContext
    -- ^ /@client@/: additional contextual information about the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to /@soupServerAddHandler@/
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ServerWebsocketCallback_WithClosures`@.
noServerWebsocketCallback_WithClosures :: Maybe ServerWebsocketCallback_WithClosures
noServerWebsocketCallback_WithClosures :: Maybe ServerWebsocketCallback_WithClosures
noServerWebsocketCallback_WithClosures = Maybe ServerWebsocketCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ServerWebsocketCallback :: ServerWebsocketCallback -> ServerWebsocketCallback_WithClosures
drop_closures_ServerWebsocketCallback :: ServerWebsocketCallback -> ServerWebsocketCallback_WithClosures
drop_closures_ServerWebsocketCallback _f :: ServerWebsocketCallback
_f server :: Server
server connection :: WebsocketConnection
connection path :: Text
path client :: ClientContext
client _ = ServerWebsocketCallback
_f Server
server WebsocketConnection
connection Text
path ClientContext
client

-- | Wrap the callback into a `GClosure`.
genClosure_ServerWebsocketCallback :: MonadIO m => ServerWebsocketCallback -> m (GClosure C_ServerWebsocketCallback)
genClosure_ServerWebsocketCallback :: ServerWebsocketCallback -> m (GClosure C_ServerWebsocketCallback)
genClosure_ServerWebsocketCallback cb :: ServerWebsocketCallback
cb = IO (GClosure C_ServerWebsocketCallback)
-> m (GClosure C_ServerWebsocketCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ServerWebsocketCallback)
 -> m (GClosure C_ServerWebsocketCallback))
-> IO (GClosure C_ServerWebsocketCallback)
-> m (GClosure C_ServerWebsocketCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: ServerWebsocketCallback_WithClosures
cb' = ServerWebsocketCallback -> ServerWebsocketCallback_WithClosures
drop_closures_ServerWebsocketCallback ServerWebsocketCallback
cb
    let cb'' :: C_ServerWebsocketCallback
cb'' = Maybe (Ptr (FunPtr C_ServerWebsocketCallback))
-> ServerWebsocketCallback_WithClosures
-> C_ServerWebsocketCallback
wrap_ServerWebsocketCallback Maybe (Ptr (FunPtr C_ServerWebsocketCallback))
forall a. Maybe a
Nothing ServerWebsocketCallback_WithClosures
cb'
    C_ServerWebsocketCallback -> IO (FunPtr C_ServerWebsocketCallback)
mk_ServerWebsocketCallback C_ServerWebsocketCallback
cb'' IO (FunPtr C_ServerWebsocketCallback)
-> (FunPtr C_ServerWebsocketCallback
    -> IO (GClosure C_ServerWebsocketCallback))
-> IO (GClosure C_ServerWebsocketCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ServerWebsocketCallback
-> IO (GClosure C_ServerWebsocketCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ServerWebsocketCallback` into a `C_ServerWebsocketCallback`.
wrap_ServerWebsocketCallback ::
    Maybe (Ptr (FunPtr C_ServerWebsocketCallback)) ->
    ServerWebsocketCallback_WithClosures ->
    C_ServerWebsocketCallback
wrap_ServerWebsocketCallback :: Maybe (Ptr (FunPtr C_ServerWebsocketCallback))
-> ServerWebsocketCallback_WithClosures
-> C_ServerWebsocketCallback
wrap_ServerWebsocketCallback funptrptr :: Maybe (Ptr (FunPtr C_ServerWebsocketCallback))
funptrptr _cb :: ServerWebsocketCallback_WithClosures
_cb server :: Ptr Server
server connection :: Ptr WebsocketConnection
connection path :: CString
path client :: Ptr ClientContext
client userData :: Ptr ()
userData = do
    Server
server' <- ((ManagedPtr Server -> Server) -> Ptr Server -> IO Server
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Server -> Server
Soup.Server.Server) Ptr Server
server
    WebsocketConnection
connection' <- ((ManagedPtr WebsocketConnection -> WebsocketConnection)
-> Ptr WebsocketConnection -> IO WebsocketConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr WebsocketConnection -> WebsocketConnection
Soup.WebsocketConnection.WebsocketConnection) Ptr WebsocketConnection
connection
    Text
path' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
path
    (ManagedPtr ClientContext -> ClientContext)
-> Ptr ClientContext -> (ClientContext -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr ClientContext -> ClientContext
Soup.ClientContext.ClientContext Ptr ClientContext
client ((ClientContext -> IO ()) -> IO ())
-> (ClientContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \client' :: ClientContext
client' -> do
        ServerWebsocketCallback_WithClosures
_cb  Server
server' WebsocketConnection
connection' Text
path' ClientContext
client' Ptr ()
userData
        Maybe (Ptr (FunPtr C_ServerWebsocketCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ServerWebsocketCallback))
funptrptr


-- callback ServerCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "server", argType = TInterface (Name {namespace = "Soup", name = "Server"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupServer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message being processed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path component of @msg's Request-URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the parsed query\n  component of @msg's Request-URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "client", argType = TInterface (Name {namespace = "Soup", name = "ClientContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "additional contextual information about the client", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_server_add_handler() or\n  soup_server_add_early_handler().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback used to handle requests to a #SoupServer.\n\n@path and @query contain the likewise-named components of the\nRequest-URI, subject to certain assumptions. By default,\n#SoupServer decodes all percent-encoding in the URI path, such that\n\"/foo%<!-- -->2Fbar\" is treated the same as \"/foo/bar\". If your\nserver is serving resources in some non-POSIX-filesystem namespace,\nyou may want to distinguish those as two distinct paths. In that\ncase, you can set the %SOUP_SERVER_RAW_PATHS property when creating\nthe #SoupServer, and it will leave those characters undecoded. (You\nmay want to call soup_uri_normalize() to decode any percent-encoded\ncharacters that you aren't handling specially.)\n\n@query contains the query component of the Request-URI parsed\naccording to the rules for HTML form handling. Although this is the\nonly commonly-used query string format in HTTP, there is nothing\nthat actually requires that HTTP URIs use that format; if your\nserver needs to use some other format, you can just ignore @query,\nand call soup_message_get_uri() and parse the URI's query field\nyourself.\n\nSee soup_server_add_handler() and soup_server_add_early_handler()\nfor details of what handlers can/should do.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ServerCallback =
    Ptr Soup.Server.Server ->
    Ptr Soup.Message.Message ->
    CString ->
    Ptr (GHashTable CString CString) ->
    Ptr Soup.ClientContext.ClientContext ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "server"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Server" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupServer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message being processed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path component of @msg's Request-URI"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "query"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the parsed query\n  component of @msg's Request-URI"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "client"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ClientContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "additional contextual information about the client"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the data passed to soup_server_add_handler() or\n  soup_server_add_early_handler()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ServerCallback :: FunPtr C_ServerCallback -> C_ServerCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ServerCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Server.IsServer a, Soup.Message.IsMessage b) =>
    FunPtr C_ServerCallback
    -> a
    -- ^ /@server@/: the t'GI.Soup.Objects.Server.Server'
    -> b
    -- ^ /@msg@/: the message being processed
    -> T.Text
    -- ^ /@path@/: the path component of /@msg@/\'s Request-URI
    -> Maybe (Map.Map T.Text T.Text)
    -- ^ /@query@/: the parsed query
    --   component of /@msg@/\'s Request-URI
    -> Soup.ClientContext.ClientContext
    -- ^ /@client@/: additional contextual information about the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Server.serverAddHandler' or
    --   'GI.Soup.Objects.Server.serverAddEarlyHandler'.
    -> m ()
dynamic_ServerCallback :: FunPtr C_ServerCallback
-> a
-> b
-> Text
-> Maybe (Map Text Text)
-> ClientContext
-> Ptr ()
-> m ()
dynamic_ServerCallback __funPtr :: FunPtr C_ServerCallback
__funPtr server :: a
server msg :: b
msg path :: Text
path query :: Maybe (Map Text Text)
query client :: ClientContext
client userData :: Ptr ()
userData = 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 Server
server' <- a -> IO (Ptr Server)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
server
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr (GHashTable CString CString)
maybeQuery <- case Maybe (Map Text Text)
query of
        Nothing -> Ptr (GHashTable CString CString)
-> IO (Ptr (GHashTable CString CString))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable CString CString)
forall a. Ptr a
nullPtr
        Just jQuery :: Map Text Text
jQuery -> do
            let jQuery' :: [(Text, Text)]
jQuery' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
jQuery
            [(CString, Text)]
jQuery'' <- (Text -> IO CString) -> [(Text, Text)] -> IO [(CString, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Text)]
jQuery'
            [(CString, CString)]
jQuery''' <- (Text -> IO CString)
-> [(CString, Text)] -> IO [(CString, CString)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO CString
textToCString [(CString, Text)]
jQuery''
            let jQuery'''' :: [(PtrWrapped CString, CString)]
jQuery'''' = (CString -> PtrWrapped CString)
-> [(CString, CString)] -> [(PtrWrapped CString, CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
cstringPackPtr [(CString, CString)]
jQuery'''
            let jQuery''''' :: [(PtrWrapped CString, PtrWrapped CString)]
jQuery''''' = (CString -> PtrWrapped CString)
-> [(PtrWrapped CString, CString)]
-> [(PtrWrapped CString, PtrWrapped CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond CString -> PtrWrapped CString
cstringPackPtr [(PtrWrapped CString, CString)]
jQuery''''
            Ptr (GHashTable CString CString)
jQuery'''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> IO (Ptr (GHashTable CString CString))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped CString, PtrWrapped CString)]
jQuery'''''
            Ptr (GHashTable CString CString)
-> IO (Ptr (GHashTable CString CString))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable CString CString)
jQuery''''''
    Ptr ClientContext
client' <- ClientContext -> IO (Ptr ClientContext)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ClientContext
client
    (FunPtr C_ServerCallback -> C_ServerCallback
__dynamic_C_ServerCallback FunPtr C_ServerCallback
__funPtr) Ptr Server
server' Ptr Message
msg' CString
path' Ptr (GHashTable CString CString)
maybeQuery Ptr ClientContext
client' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
server
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    ClientContext -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ClientContext
client
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
maybeQuery
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | A callback used to handle requests to a t'GI.Soup.Objects.Server.Server'.
-- 
-- /@path@/ and /@query@/ contain the likewise-named components of the
-- Request-URI, subject to certain assumptions. By default,
-- t'GI.Soup.Objects.Server.Server' decodes all percent-encoding in the URI path, such that
-- \"\/foo%\<!-- -->2Fbar\" is treated the same as \"\/foo\/bar\". If your
-- server is serving resources in some non-POSIX-filesystem namespace,
-- you may want to distinguish those as two distinct paths. In that
-- case, you can set the 'GI.Soup.Constants.SERVER_RAW_PATHS' property when creating
-- the t'GI.Soup.Objects.Server.Server', and it will leave those characters undecoded. (You
-- may want to call 'GI.Soup.Functions.uriNormalize' to decode any percent-encoded
-- characters that you aren\'t handling specially.)
-- 
-- /@query@/ contains the query component of the Request-URI parsed
-- according to the rules for HTML form handling. Although this is the
-- only commonly-used query string format in HTTP, there is nothing
-- that actually requires that HTTP URIs use that format; if your
-- server needs to use some other format, you can just ignore /@query@/,
-- and call 'GI.Soup.Objects.Message.messageGetUri' and parse the URI\'s query field
-- yourself.
-- 
-- See 'GI.Soup.Objects.Server.serverAddHandler' and 'GI.Soup.Objects.Server.serverAddEarlyHandler'
-- for details of what handlers can\/should do.
type ServerCallback =
    Soup.Server.Server
    -- ^ /@server@/: the t'GI.Soup.Objects.Server.Server'
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being processed
    -> T.Text
    -- ^ /@path@/: the path component of /@msg@/\'s Request-URI
    -> Maybe (Map.Map T.Text T.Text)
    -- ^ /@query@/: the parsed query
    --   component of /@msg@/\'s Request-URI
    -> Soup.ClientContext.ClientContext
    -- ^ /@client@/: additional contextual information about the client
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ServerCallback`@.
noServerCallback :: Maybe ServerCallback
noServerCallback :: Maybe ServerCallback
noServerCallback = Maybe ServerCallback
forall a. Maybe a
Nothing

-- | A callback used to handle requests to a t'GI.Soup.Objects.Server.Server'.
-- 
-- /@path@/ and /@query@/ contain the likewise-named components of the
-- Request-URI, subject to certain assumptions. By default,
-- t'GI.Soup.Objects.Server.Server' decodes all percent-encoding in the URI path, such that
-- \"\/foo%\<!-- -->2Fbar\" is treated the same as \"\/foo\/bar\". If your
-- server is serving resources in some non-POSIX-filesystem namespace,
-- you may want to distinguish those as two distinct paths. In that
-- case, you can set the 'GI.Soup.Constants.SERVER_RAW_PATHS' property when creating
-- the t'GI.Soup.Objects.Server.Server', and it will leave those characters undecoded. (You
-- may want to call 'GI.Soup.Functions.uriNormalize' to decode any percent-encoded
-- characters that you aren\'t handling specially.)
-- 
-- /@query@/ contains the query component of the Request-URI parsed
-- according to the rules for HTML form handling. Although this is the
-- only commonly-used query string format in HTTP, there is nothing
-- that actually requires that HTTP URIs use that format; if your
-- server needs to use some other format, you can just ignore /@query@/,
-- and call 'GI.Soup.Objects.Message.messageGetUri' and parse the URI\'s query field
-- yourself.
-- 
-- See 'GI.Soup.Objects.Server.serverAddHandler' and 'GI.Soup.Objects.Server.serverAddEarlyHandler'
-- for details of what handlers can\/should do.
type ServerCallback_WithClosures =
    Soup.Server.Server
    -- ^ /@server@/: the t'GI.Soup.Objects.Server.Server'
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being processed
    -> T.Text
    -- ^ /@path@/: the path component of /@msg@/\'s Request-URI
    -> Maybe (Map.Map T.Text T.Text)
    -- ^ /@query@/: the parsed query
    --   component of /@msg@/\'s Request-URI
    -> Soup.ClientContext.ClientContext
    -- ^ /@client@/: additional contextual information about the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Server.serverAddHandler' or
    --   'GI.Soup.Objects.Server.serverAddEarlyHandler'.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ServerCallback_WithClosures`@.
noServerCallback_WithClosures :: Maybe ServerCallback_WithClosures
noServerCallback_WithClosures :: Maybe ServerCallback_WithClosures
noServerCallback_WithClosures = Maybe ServerCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ServerCallback :: ServerCallback -> ServerCallback_WithClosures
drop_closures_ServerCallback :: ServerCallback -> ServerCallback_WithClosures
drop_closures_ServerCallback _f :: ServerCallback
_f server :: Server
server msg :: Message
msg path :: Text
path query :: Maybe (Map Text Text)
query client :: ClientContext
client _ = ServerCallback
_f Server
server Message
msg Text
path Maybe (Map Text Text)
query ClientContext
client

-- | Wrap the callback into a `GClosure`.
genClosure_ServerCallback :: MonadIO m => ServerCallback -> m (GClosure C_ServerCallback)
genClosure_ServerCallback :: ServerCallback -> m (GClosure C_ServerCallback)
genClosure_ServerCallback cb :: ServerCallback
cb = IO (GClosure C_ServerCallback) -> m (GClosure C_ServerCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ServerCallback) -> m (GClosure C_ServerCallback))
-> IO (GClosure C_ServerCallback) -> m (GClosure C_ServerCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: ServerCallback_WithClosures
cb' = ServerCallback -> ServerCallback_WithClosures
drop_closures_ServerCallback ServerCallback
cb
    let cb'' :: C_ServerCallback
cb'' = Maybe (Ptr (FunPtr C_ServerCallback))
-> ServerCallback_WithClosures -> C_ServerCallback
wrap_ServerCallback Maybe (Ptr (FunPtr C_ServerCallback))
forall a. Maybe a
Nothing ServerCallback_WithClosures
cb'
    C_ServerCallback -> IO (FunPtr C_ServerCallback)
mk_ServerCallback C_ServerCallback
cb'' IO (FunPtr C_ServerCallback)
-> (FunPtr C_ServerCallback -> IO (GClosure C_ServerCallback))
-> IO (GClosure C_ServerCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ServerCallback -> IO (GClosure C_ServerCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ServerCallback` into a `C_ServerCallback`.
wrap_ServerCallback ::
    Maybe (Ptr (FunPtr C_ServerCallback)) ->
    ServerCallback_WithClosures ->
    C_ServerCallback
wrap_ServerCallback :: Maybe (Ptr (FunPtr C_ServerCallback))
-> ServerCallback_WithClosures -> C_ServerCallback
wrap_ServerCallback funptrptr :: Maybe (Ptr (FunPtr C_ServerCallback))
funptrptr _cb :: ServerCallback_WithClosures
_cb server :: Ptr Server
server msg :: Ptr Message
msg path :: CString
path query :: Ptr (GHashTable CString CString)
query client :: Ptr ClientContext
client userData :: Ptr ()
userData = do
    Server
server' <- ((ManagedPtr Server -> Server) -> Ptr Server -> IO Server
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Server -> Server
Soup.Server.Server) Ptr Server
server
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Text
path' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
path
    Maybe (Map Text Text)
maybeQuery <-
        if Ptr (GHashTable CString CString)
query Ptr (GHashTable CString CString)
-> Ptr (GHashTable CString CString) -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr (GHashTable CString CString)
forall a. Ptr a
nullPtr
        then Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map Text Text)
forall a. Maybe a
Nothing
        else do
            [(PtrWrapped CString, PtrWrapped CString)]
query' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
query
            let query'' :: [(CString, PtrWrapped CString)]
query'' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
query'
            [(Text, PtrWrapped CString)]
query''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
query''
            let query'''' :: [(Text, CString)]
query'''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
cstringUnpackPtr [(Text, PtrWrapped CString)]
query'''
            [(Text, Text)]
query''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
query''''
            let query'''''' :: Map Text Text
query'''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
query'''''
            Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Map Text Text) -> IO (Maybe (Map Text Text)))
-> Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just Map Text Text
query''''''
    (ManagedPtr ClientContext -> ClientContext)
-> Ptr ClientContext -> (ClientContext -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr ClientContext -> ClientContext
Soup.ClientContext.ClientContext Ptr ClientContext
client ((ClientContext -> IO ()) -> IO ())
-> (ClientContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \client' :: ClientContext
client' -> do
        ServerCallback_WithClosures
_cb  Server
server' Message
msg' Text
path' Maybe (Map Text Text)
maybeQuery ClientContext
client' Ptr ()
userData
        Maybe (Ptr (FunPtr C_ServerCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ServerCallback))
funptrptr


-- callback ProxyURIResolverCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Soup", name = "ProxyURIResolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupProxyURIResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "status", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupStatus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the resolved proxy URI, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data passed to soup_proxy_uri_resolver_get_proxy_uri_async()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Callback for soup_proxy_uri_resolver_get_proxy_uri_async()", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ProxyURIResolverCallback =
    Ptr Soup.ProxyURIResolver.ProxyURIResolver ->
    Word32 ->
    Ptr Soup.URI.URI ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "resolver"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ProxyURIResolver" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupProxyURIResolver"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "status"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupStatus" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "proxy_uri"
--           , argType = TInterface Name { namespace = "Soup" , name = "URI" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the resolved proxy URI, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "data passed to soup_proxy_uri_resolver_get_proxy_uri_async()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ProxyURIResolverCallback :: FunPtr C_ProxyURIResolverCallback -> C_ProxyURIResolverCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ProxyURIResolverCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.ProxyURIResolver.IsProxyURIResolver a) =>
    FunPtr C_ProxyURIResolverCallback
    -> a
    -- ^ /@resolver@/: the t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver'
    -> Word32
    -- ^ /@status@/: a t'GI.Soup.Enums.Status'
    -> Soup.URI.URI
    -- ^ /@proxyUri@/: the resolved proxy URI, or 'P.Nothing'
    -> Ptr ()
    -- ^ /@userData@/: data passed to 'GI.Soup.Interfaces.ProxyURIResolver.proxyURIResolverGetProxyUriAsync'
    -> m ()
dynamic_ProxyURIResolverCallback :: FunPtr C_ProxyURIResolverCallback
-> a -> Word32 -> URI -> Ptr () -> m ()
dynamic_ProxyURIResolverCallback __funPtr :: FunPtr C_ProxyURIResolverCallback
__funPtr resolver :: a
resolver status :: Word32
status proxyUri :: URI
proxyUri userData :: Ptr ()
userData = 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 ProxyURIResolver
resolver' <- a -> IO (Ptr ProxyURIResolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr URI
proxyUri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
proxyUri
    (FunPtr C_ProxyURIResolverCallback -> C_ProxyURIResolverCallback
__dynamic_C_ProxyURIResolverCallback FunPtr C_ProxyURIResolverCallback
__funPtr) Ptr ProxyURIResolver
resolver' Word32
status Ptr URI
proxyUri' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
resolver
    URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
proxyUri
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | Callback for 'GI.Soup.Interfaces.ProxyURIResolver.proxyURIResolverGetProxyUriAsync'
type ProxyURIResolverCallback =
    Soup.ProxyURIResolver.ProxyURIResolver
    -- ^ /@resolver@/: the t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver'
    -> Word32
    -- ^ /@status@/: a t'GI.Soup.Enums.Status'
    -> Soup.URI.URI
    -- ^ /@proxyUri@/: the resolved proxy URI, or 'P.Nothing'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ProxyURIResolverCallback`@.
noProxyURIResolverCallback :: Maybe ProxyURIResolverCallback
noProxyURIResolverCallback :: Maybe ProxyURIResolverCallback
noProxyURIResolverCallback = Maybe ProxyURIResolverCallback
forall a. Maybe a
Nothing

-- | Callback for 'GI.Soup.Interfaces.ProxyURIResolver.proxyURIResolverGetProxyUriAsync'
type ProxyURIResolverCallback_WithClosures =
    Soup.ProxyURIResolver.ProxyURIResolver
    -- ^ /@resolver@/: the t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver'
    -> Word32
    -- ^ /@status@/: a t'GI.Soup.Enums.Status'
    -> Soup.URI.URI
    -- ^ /@proxyUri@/: the resolved proxy URI, or 'P.Nothing'
    -> Ptr ()
    -- ^ /@userData@/: data passed to 'GI.Soup.Interfaces.ProxyURIResolver.proxyURIResolverGetProxyUriAsync'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ProxyURIResolverCallback_WithClosures`@.
noProxyURIResolverCallback_WithClosures :: Maybe ProxyURIResolverCallback_WithClosures
noProxyURIResolverCallback_WithClosures :: Maybe ProxyURIResolverCallback_WithClosures
noProxyURIResolverCallback_WithClosures = Maybe ProxyURIResolverCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ProxyURIResolverCallback :: ProxyURIResolverCallback -> ProxyURIResolverCallback_WithClosures
drop_closures_ProxyURIResolverCallback :: ProxyURIResolverCallback -> ProxyURIResolverCallback_WithClosures
drop_closures_ProxyURIResolverCallback _f :: ProxyURIResolverCallback
_f resolver :: ProxyURIResolver
resolver status :: Word32
status proxyUri :: URI
proxyUri _ = ProxyURIResolverCallback
_f ProxyURIResolver
resolver Word32
status URI
proxyUri

-- | Wrap the callback into a `GClosure`.
genClosure_ProxyURIResolverCallback :: MonadIO m => ProxyURIResolverCallback -> m (GClosure C_ProxyURIResolverCallback)
genClosure_ProxyURIResolverCallback :: ProxyURIResolverCallback -> m (GClosure C_ProxyURIResolverCallback)
genClosure_ProxyURIResolverCallback cb :: ProxyURIResolverCallback
cb = IO (GClosure C_ProxyURIResolverCallback)
-> m (GClosure C_ProxyURIResolverCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ProxyURIResolverCallback)
 -> m (GClosure C_ProxyURIResolverCallback))
-> IO (GClosure C_ProxyURIResolverCallback)
-> m (GClosure C_ProxyURIResolverCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: ProxyURIResolverCallback_WithClosures
cb' = ProxyURIResolverCallback -> ProxyURIResolverCallback_WithClosures
drop_closures_ProxyURIResolverCallback ProxyURIResolverCallback
cb
    let cb'' :: C_ProxyURIResolverCallback
cb'' = Maybe (Ptr (FunPtr C_ProxyURIResolverCallback))
-> ProxyURIResolverCallback_WithClosures
-> C_ProxyURIResolverCallback
wrap_ProxyURIResolverCallback Maybe (Ptr (FunPtr C_ProxyURIResolverCallback))
forall a. Maybe a
Nothing ProxyURIResolverCallback_WithClosures
cb'
    C_ProxyURIResolverCallback
-> IO (FunPtr C_ProxyURIResolverCallback)
mk_ProxyURIResolverCallback C_ProxyURIResolverCallback
cb'' IO (FunPtr C_ProxyURIResolverCallback)
-> (FunPtr C_ProxyURIResolverCallback
    -> IO (GClosure C_ProxyURIResolverCallback))
-> IO (GClosure C_ProxyURIResolverCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ProxyURIResolverCallback
-> IO (GClosure C_ProxyURIResolverCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ProxyURIResolverCallback` into a `C_ProxyURIResolverCallback`.
wrap_ProxyURIResolverCallback ::
    Maybe (Ptr (FunPtr C_ProxyURIResolverCallback)) ->
    ProxyURIResolverCallback_WithClosures ->
    C_ProxyURIResolverCallback
wrap_ProxyURIResolverCallback :: Maybe (Ptr (FunPtr C_ProxyURIResolverCallback))
-> ProxyURIResolverCallback_WithClosures
-> C_ProxyURIResolverCallback
wrap_ProxyURIResolverCallback funptrptr :: Maybe (Ptr (FunPtr C_ProxyURIResolverCallback))
funptrptr _cb :: ProxyURIResolverCallback_WithClosures
_cb resolver :: Ptr ProxyURIResolver
resolver status :: Word32
status proxyUri :: Ptr URI
proxyUri userData :: Ptr ()
userData = do
    ProxyURIResolver
resolver' <- ((ManagedPtr ProxyURIResolver -> ProxyURIResolver)
-> Ptr ProxyURIResolver -> IO ProxyURIResolver
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ProxyURIResolver -> ProxyURIResolver
Soup.ProxyURIResolver.ProxyURIResolver) Ptr ProxyURIResolver
resolver
    (ManagedPtr URI -> URI) -> Ptr URI -> (URI -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr URI -> URI
Soup.URI.URI Ptr URI
proxyUri ((URI -> IO ()) -> IO ()) -> (URI -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \proxyUri' :: URI
proxyUri' -> do
        ProxyURIResolverCallback_WithClosures
_cb  ProxyURIResolver
resolver' Word32
status URI
proxyUri' Ptr ()
userData
        Maybe (Ptr (FunPtr C_ProxyURIResolverCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ProxyURIResolverCallback))
funptrptr


-- callback ProxyResolverCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "proxy_resolver", argType = TInterface (Name {namespace = "Soup", name = "ProxyResolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "arg", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "2.28", deprecationMessage = Just "Use SoupProxyURIResolver instead"}), callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ProxyResolverCallback =
    Ptr Soup.ProxyResolver.ProxyResolver ->
    Ptr Soup.Message.Message ->
    Word32 ->
    Ptr Soup.Address.Address ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "proxy_resolver"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ProxyResolver" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "arg"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "addr"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Address" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ProxyResolverCallback :: FunPtr C_ProxyResolverCallback -> C_ProxyResolverCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ProxyResolverCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.ProxyResolver.IsProxyResolver a, Soup.Message.IsMessage b, Soup.Address.IsAddress c) =>
    FunPtr C_ProxyResolverCallback
    -> a
    -> b
    -> Word32
    -> c
    -> Ptr ()
    -> m ()
dynamic_ProxyResolverCallback :: FunPtr C_ProxyResolverCallback
-> a -> b -> Word32 -> c -> Ptr () -> m ()
dynamic_ProxyResolverCallback __funPtr :: FunPtr C_ProxyResolverCallback
__funPtr proxyResolver :: a
proxyResolver msg :: b
msg arg :: Word32
arg addr :: c
addr userData :: Ptr ()
userData = 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 ProxyResolver
proxyResolver' <- a -> IO (Ptr ProxyResolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
proxyResolver
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    Ptr Address
addr' <- c -> IO (Ptr Address)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
addr
    (FunPtr C_ProxyResolverCallback -> C_ProxyResolverCallback
__dynamic_C_ProxyResolverCallback FunPtr C_ProxyResolverCallback
__funPtr) Ptr ProxyResolver
proxyResolver' Ptr Message
msg' Word32
arg Ptr Address
addr' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
proxyResolver
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
addr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

{-# DEPRECATED ProxyResolverCallback ["(Since version 2.28)","Use SoupProxyURIResolver instead"] #-}
-- | /No description available in the introspection data./
type ProxyResolverCallback =
    Soup.ProxyResolver.ProxyResolver
    -> Soup.Message.Message
    -> Word32
    -> Soup.Address.Address
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ProxyResolverCallback`@.
noProxyResolverCallback :: Maybe ProxyResolverCallback
noProxyResolverCallback :: Maybe ProxyResolverCallback
noProxyResolverCallback = Maybe ProxyResolverCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type ProxyResolverCallback_WithClosures =
    Soup.ProxyResolver.ProxyResolver
    -> Soup.Message.Message
    -> Word32
    -> Soup.Address.Address
    -> Ptr ()
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ProxyResolverCallback_WithClosures`@.
noProxyResolverCallback_WithClosures :: Maybe ProxyResolverCallback_WithClosures
noProxyResolverCallback_WithClosures :: Maybe ProxyResolverCallback_WithClosures
noProxyResolverCallback_WithClosures = Maybe ProxyResolverCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ProxyResolverCallback :: ProxyResolverCallback -> ProxyResolverCallback_WithClosures
drop_closures_ProxyResolverCallback :: ProxyResolverCallback -> ProxyResolverCallback_WithClosures
drop_closures_ProxyResolverCallback _f :: ProxyResolverCallback
_f proxyResolver :: ProxyResolver
proxyResolver msg :: Message
msg arg :: Word32
arg addr :: Address
addr _ = ProxyResolverCallback
_f ProxyResolver
proxyResolver Message
msg Word32
arg Address
addr

-- | Wrap the callback into a `GClosure`.
genClosure_ProxyResolverCallback :: MonadIO m => ProxyResolverCallback -> m (GClosure C_ProxyResolverCallback)
genClosure_ProxyResolverCallback :: ProxyResolverCallback -> m (GClosure C_ProxyResolverCallback)
genClosure_ProxyResolverCallback cb :: ProxyResolverCallback
cb = IO (GClosure C_ProxyResolverCallback)
-> m (GClosure C_ProxyResolverCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ProxyResolverCallback)
 -> m (GClosure C_ProxyResolverCallback))
-> IO (GClosure C_ProxyResolverCallback)
-> m (GClosure C_ProxyResolverCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: ProxyResolverCallback_WithClosures
cb' = ProxyResolverCallback -> ProxyResolverCallback_WithClosures
drop_closures_ProxyResolverCallback ProxyResolverCallback
cb
    let cb'' :: C_ProxyResolverCallback
cb'' = Maybe (Ptr (FunPtr C_ProxyResolverCallback))
-> ProxyResolverCallback_WithClosures -> C_ProxyResolverCallback
wrap_ProxyResolverCallback Maybe (Ptr (FunPtr C_ProxyResolverCallback))
forall a. Maybe a
Nothing ProxyResolverCallback_WithClosures
cb'
    C_ProxyResolverCallback -> IO (FunPtr C_ProxyResolverCallback)
mk_ProxyResolverCallback C_ProxyResolverCallback
cb'' IO (FunPtr C_ProxyResolverCallback)
-> (FunPtr C_ProxyResolverCallback
    -> IO (GClosure C_ProxyResolverCallback))
-> IO (GClosure C_ProxyResolverCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ProxyResolverCallback
-> IO (GClosure C_ProxyResolverCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ProxyResolverCallback` into a `C_ProxyResolverCallback`.
wrap_ProxyResolverCallback ::
    Maybe (Ptr (FunPtr C_ProxyResolverCallback)) ->
    ProxyResolverCallback_WithClosures ->
    C_ProxyResolverCallback
wrap_ProxyResolverCallback :: Maybe (Ptr (FunPtr C_ProxyResolverCallback))
-> ProxyResolverCallback_WithClosures -> C_ProxyResolverCallback
wrap_ProxyResolverCallback funptrptr :: Maybe (Ptr (FunPtr C_ProxyResolverCallback))
funptrptr _cb :: ProxyResolverCallback_WithClosures
_cb proxyResolver :: Ptr ProxyResolver
proxyResolver msg :: Ptr Message
msg arg :: Word32
arg addr :: Ptr Address
addr userData :: Ptr ()
userData = do
    ProxyResolver
proxyResolver' <- ((ManagedPtr ProxyResolver -> ProxyResolver)
-> Ptr ProxyResolver -> IO ProxyResolver
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ProxyResolver -> ProxyResolver
Soup.ProxyResolver.ProxyResolver) Ptr ProxyResolver
proxyResolver
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Address
addr' <- ((ManagedPtr Address -> Address) -> Ptr Address -> IO Address
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Address -> Address
Soup.Address.Address) Ptr Address
addr
    ProxyResolverCallback_WithClosures
_cb  ProxyResolver
proxyResolver' Message
msg' Word32
arg Address
addr' Ptr ()
userData
    Maybe (Ptr (FunPtr C_ProxyResolverCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ProxyResolverCallback))
funptrptr


-- callback PasswordManagerCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "password_manager", argType = TInterface (Name {namespace = "Soup", name = "PasswordManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "auth", argType = TInterface (Name {namespace = "Soup", name = "Auth"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "retrying", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_PasswordManagerCallback =
    Ptr Soup.PasswordManager.PasswordManager ->
    Ptr Soup.Message.Message ->
    Ptr Soup.Auth.Auth ->
    CInt ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "password_manager"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "PasswordManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "auth"
--           , argType = TInterface Name { namespace = "Soup" , name = "Auth" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "retrying"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_PasswordManagerCallback :: FunPtr C_PasswordManagerCallback -> C_PasswordManagerCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_PasswordManagerCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.PasswordManager.IsPasswordManager a, Soup.Message.IsMessage b, Soup.Auth.IsAuth c) =>
    FunPtr C_PasswordManagerCallback
    -> a
    -> b
    -> c
    -> Bool
    -> Ptr ()
    -> m ()
dynamic_PasswordManagerCallback :: FunPtr C_PasswordManagerCallback
-> a -> b -> c -> Bool -> Ptr () -> m ()
dynamic_PasswordManagerCallback __funPtr :: FunPtr C_PasswordManagerCallback
__funPtr passwordManager :: a
passwordManager msg :: b
msg auth :: c
auth retrying :: Bool
retrying userData :: Ptr ()
userData = 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 PasswordManager
passwordManager' <- a -> IO (Ptr PasswordManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
passwordManager
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    Ptr Auth
auth' <- c -> IO (Ptr Auth)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
auth
    let retrying' :: CInt
retrying' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
retrying
    (FunPtr C_PasswordManagerCallback -> C_PasswordManagerCallback
__dynamic_C_PasswordManagerCallback FunPtr C_PasswordManagerCallback
__funPtr) Ptr PasswordManager
passwordManager' Ptr Message
msg' Ptr Auth
auth' CInt
retrying' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
passwordManager
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
auth
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | /No description available in the introspection data./
type PasswordManagerCallback =
    Soup.PasswordManager.PasswordManager
    -> Soup.Message.Message
    -> Soup.Auth.Auth
    -> Bool
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PasswordManagerCallback`@.
noPasswordManagerCallback :: Maybe PasswordManagerCallback
noPasswordManagerCallback :: Maybe PasswordManagerCallback
noPasswordManagerCallback = Maybe PasswordManagerCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type PasswordManagerCallback_WithClosures =
    Soup.PasswordManager.PasswordManager
    -> Soup.Message.Message
    -> Soup.Auth.Auth
    -> Bool
    -> Ptr ()
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PasswordManagerCallback_WithClosures`@.
noPasswordManagerCallback_WithClosures :: Maybe PasswordManagerCallback_WithClosures
noPasswordManagerCallback_WithClosures :: Maybe PasswordManagerCallback_WithClosures
noPasswordManagerCallback_WithClosures = Maybe PasswordManagerCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PasswordManagerCallback :: PasswordManagerCallback -> PasswordManagerCallback_WithClosures
drop_closures_PasswordManagerCallback :: PasswordManagerCallback -> PasswordManagerCallback_WithClosures
drop_closures_PasswordManagerCallback _f :: PasswordManagerCallback
_f passwordManager :: PasswordManager
passwordManager msg :: Message
msg auth :: Auth
auth retrying :: Bool
retrying _ = PasswordManagerCallback
_f PasswordManager
passwordManager Message
msg Auth
auth Bool
retrying

-- | Wrap the callback into a `GClosure`.
genClosure_PasswordManagerCallback :: MonadIO m => PasswordManagerCallback -> m (GClosure C_PasswordManagerCallback)
genClosure_PasswordManagerCallback :: PasswordManagerCallback -> m (GClosure C_PasswordManagerCallback)
genClosure_PasswordManagerCallback cb :: PasswordManagerCallback
cb = IO (GClosure C_PasswordManagerCallback)
-> m (GClosure C_PasswordManagerCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PasswordManagerCallback)
 -> m (GClosure C_PasswordManagerCallback))
-> IO (GClosure C_PasswordManagerCallback)
-> m (GClosure C_PasswordManagerCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: PasswordManagerCallback_WithClosures
cb' = PasswordManagerCallback -> PasswordManagerCallback_WithClosures
drop_closures_PasswordManagerCallback PasswordManagerCallback
cb
    let cb'' :: C_PasswordManagerCallback
cb'' = Maybe (Ptr (FunPtr C_PasswordManagerCallback))
-> PasswordManagerCallback_WithClosures
-> C_PasswordManagerCallback
wrap_PasswordManagerCallback Maybe (Ptr (FunPtr C_PasswordManagerCallback))
forall a. Maybe a
Nothing PasswordManagerCallback_WithClosures
cb'
    C_PasswordManagerCallback -> IO (FunPtr C_PasswordManagerCallback)
mk_PasswordManagerCallback C_PasswordManagerCallback
cb'' IO (FunPtr C_PasswordManagerCallback)
-> (FunPtr C_PasswordManagerCallback
    -> IO (GClosure C_PasswordManagerCallback))
-> IO (GClosure C_PasswordManagerCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PasswordManagerCallback
-> IO (GClosure C_PasswordManagerCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PasswordManagerCallback` into a `C_PasswordManagerCallback`.
wrap_PasswordManagerCallback ::
    Maybe (Ptr (FunPtr C_PasswordManagerCallback)) ->
    PasswordManagerCallback_WithClosures ->
    C_PasswordManagerCallback
wrap_PasswordManagerCallback :: Maybe (Ptr (FunPtr C_PasswordManagerCallback))
-> PasswordManagerCallback_WithClosures
-> C_PasswordManagerCallback
wrap_PasswordManagerCallback funptrptr :: Maybe (Ptr (FunPtr C_PasswordManagerCallback))
funptrptr _cb :: PasswordManagerCallback_WithClosures
_cb passwordManager :: Ptr PasswordManager
passwordManager msg :: Ptr Message
msg auth :: Ptr Auth
auth retrying :: CInt
retrying userData :: Ptr ()
userData = do
    PasswordManager
passwordManager' <- ((ManagedPtr PasswordManager -> PasswordManager)
-> Ptr PasswordManager -> IO PasswordManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PasswordManager -> PasswordManager
Soup.PasswordManager.PasswordManager) Ptr PasswordManager
passwordManager
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Auth
auth' <- ((ManagedPtr Auth -> Auth) -> Ptr Auth -> IO Auth
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Auth -> Auth
Soup.Auth.Auth) Ptr Auth
auth
    let retrying' :: Bool
retrying' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
retrying
    PasswordManagerCallback_WithClosures
_cb  PasswordManager
passwordManager' Message
msg' Auth
auth' Bool
retrying' Ptr ()
userData
    Maybe (Ptr (FunPtr C_PasswordManagerCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_PasswordManagerCallback))
funptrptr


-- callback MessageHeadersForeachFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the header name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the header value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_message_headers_foreach()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The callback passed to soup_message_headers_foreach().", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_MessageHeadersForeachFunc =
    CString ->
    CString ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the header name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the header value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the data passed to soup_message_headers_foreach()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_MessageHeadersForeachFunc :: FunPtr C_MessageHeadersForeachFunc -> C_MessageHeadersForeachFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_MessageHeadersForeachFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_MessageHeadersForeachFunc
    -> T.Text
    -- ^ /@name@/: the header name
    -> T.Text
    -- ^ /@value@/: the header value
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Structs.MessageHeaders.messageHeadersForeach'
    -> m ()
dynamic_MessageHeadersForeachFunc :: FunPtr C_MessageHeadersForeachFunc
-> Text -> Text -> Ptr () -> m ()
dynamic_MessageHeadersForeachFunc __funPtr :: FunPtr C_MessageHeadersForeachFunc
__funPtr name :: Text
name value :: Text
value userData :: Ptr ()
userData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
value' <- Text -> IO CString
textToCString Text
value
    (FunPtr C_MessageHeadersForeachFunc -> C_MessageHeadersForeachFunc
__dynamic_C_MessageHeadersForeachFunc FunPtr C_MessageHeadersForeachFunc
__funPtr) CString
name' CString
value' Ptr ()
userData
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | The callback passed to 'GI.Soup.Structs.MessageHeaders.messageHeadersForeach'.
type MessageHeadersForeachFunc =
    T.Text
    -- ^ /@name@/: the header name
    -> T.Text
    -- ^ /@value@/: the header value
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MessageHeadersForeachFunc`@.
noMessageHeadersForeachFunc :: Maybe MessageHeadersForeachFunc
noMessageHeadersForeachFunc :: Maybe MessageHeadersForeachFunc
noMessageHeadersForeachFunc = Maybe MessageHeadersForeachFunc
forall a. Maybe a
Nothing

-- | The callback passed to 'GI.Soup.Structs.MessageHeaders.messageHeadersForeach'.
type MessageHeadersForeachFunc_WithClosures =
    T.Text
    -- ^ /@name@/: the header name
    -> T.Text
    -- ^ /@value@/: the header value
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Structs.MessageHeaders.messageHeadersForeach'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MessageHeadersForeachFunc_WithClosures`@.
noMessageHeadersForeachFunc_WithClosures :: Maybe MessageHeadersForeachFunc_WithClosures
noMessageHeadersForeachFunc_WithClosures :: Maybe MessageHeadersForeachFunc_WithClosures
noMessageHeadersForeachFunc_WithClosures = Maybe MessageHeadersForeachFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_MessageHeadersForeachFunc :: MessageHeadersForeachFunc -> MessageHeadersForeachFunc_WithClosures
drop_closures_MessageHeadersForeachFunc :: MessageHeadersForeachFunc -> MessageHeadersForeachFunc_WithClosures
drop_closures_MessageHeadersForeachFunc _f :: MessageHeadersForeachFunc
_f name :: Text
name value :: Text
value _ = MessageHeadersForeachFunc
_f Text
name Text
value

-- | Wrap the callback into a `GClosure`.
genClosure_MessageHeadersForeachFunc :: MonadIO m => MessageHeadersForeachFunc -> m (GClosure C_MessageHeadersForeachFunc)
genClosure_MessageHeadersForeachFunc :: MessageHeadersForeachFunc
-> m (GClosure C_MessageHeadersForeachFunc)
genClosure_MessageHeadersForeachFunc cb :: MessageHeadersForeachFunc
cb = IO (GClosure C_MessageHeadersForeachFunc)
-> m (GClosure C_MessageHeadersForeachFunc)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_MessageHeadersForeachFunc)
 -> m (GClosure C_MessageHeadersForeachFunc))
-> IO (GClosure C_MessageHeadersForeachFunc)
-> m (GClosure C_MessageHeadersForeachFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: MessageHeadersForeachFunc_WithClosures
cb' = MessageHeadersForeachFunc -> MessageHeadersForeachFunc_WithClosures
drop_closures_MessageHeadersForeachFunc MessageHeadersForeachFunc
cb
    let cb'' :: C_MessageHeadersForeachFunc
cb'' = Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc))
-> MessageHeadersForeachFunc_WithClosures
-> C_MessageHeadersForeachFunc
wrap_MessageHeadersForeachFunc Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc))
forall a. Maybe a
Nothing MessageHeadersForeachFunc_WithClosures
cb'
    C_MessageHeadersForeachFunc
-> IO (FunPtr C_MessageHeadersForeachFunc)
mk_MessageHeadersForeachFunc C_MessageHeadersForeachFunc
cb'' IO (FunPtr C_MessageHeadersForeachFunc)
-> (FunPtr C_MessageHeadersForeachFunc
    -> IO (GClosure C_MessageHeadersForeachFunc))
-> IO (GClosure C_MessageHeadersForeachFunc)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MessageHeadersForeachFunc
-> IO (GClosure C_MessageHeadersForeachFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `MessageHeadersForeachFunc` into a `C_MessageHeadersForeachFunc`.
wrap_MessageHeadersForeachFunc ::
    Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc)) ->
    MessageHeadersForeachFunc_WithClosures ->
    C_MessageHeadersForeachFunc
wrap_MessageHeadersForeachFunc :: Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc))
-> MessageHeadersForeachFunc_WithClosures
-> C_MessageHeadersForeachFunc
wrap_MessageHeadersForeachFunc funptrptr :: Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc))
funptrptr _cb :: MessageHeadersForeachFunc_WithClosures
_cb name :: CString
name value :: CString
value userData :: Ptr ()
userData = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    Text
value' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value
    MessageHeadersForeachFunc_WithClosures
_cb  Text
name' Text
value' Ptr ()
userData
    Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc))
funptrptr


-- callback LoggerPrinter
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "logger", argType = TInterface (Name {namespace = "Soup", name = "Logger"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupLogger", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface (Name {namespace = "Soup", name = "LoggerLogLevel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the level of the information being printed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TBasicType TInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a single-character prefix to @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data to print", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_logger_set_printer()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The prototype for a custom printing callback.\n\n@level indicates what kind of information is being printed. Eg, it\nwill be %SOUP_LOGGER_LOG_HEADERS if @data is header data.\n\n@direction is either '<', '>', or ' ', and @data is the single line\nto print; the printer is expected to add a terminating newline.\n\nTo get the effect of the default printer, you would do:\n\n<informalexample><programlisting>\nprintf (\"%c %s\\n\", direction, data);\n</programlisting></informalexample>", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_LoggerPrinter =
    Ptr Soup.Logger.Logger ->
    CUInt ->
    Int8 ->
    CString ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "logger"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Logger" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupLogger" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "level"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "LoggerLogLevel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the level of the information being printed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType = TBasicType TInt8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a single-character prefix to @data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to print" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data passed to soup_logger_set_printer()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_LoggerPrinter :: FunPtr C_LoggerPrinter -> C_LoggerPrinter

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_LoggerPrinter ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Logger.IsLogger a) =>
    FunPtr C_LoggerPrinter
    -> a
    -- ^ /@logger@/: the t'GI.Soup.Objects.Logger.Logger'
    -> Soup.Enums.LoggerLogLevel
    -- ^ /@level@/: the level of the information being printed.
    -> Int8
    -- ^ /@direction@/: a single-character prefix to /@data@/
    -> T.Text
    -- ^ /@data@/: data to print
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Logger.loggerSetPrinter'
    -> m ()
dynamic_LoggerPrinter :: FunPtr C_LoggerPrinter
-> a -> LoggerLogLevel -> Int8 -> Text -> Ptr () -> m ()
dynamic_LoggerPrinter __funPtr :: FunPtr C_LoggerPrinter
__funPtr logger :: a
logger level :: LoggerLogLevel
level direction :: Int8
direction data_ :: Text
data_ userData :: Ptr ()
userData = 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 Logger
logger' <- a -> IO (Ptr Logger)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
logger
    let level' :: CUInt
level' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (LoggerLogLevel -> Int) -> LoggerLogLevel -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LoggerLogLevel -> Int
forall a. Enum a => a -> Int
fromEnum) LoggerLogLevel
level
    CString
data_' <- Text -> IO CString
textToCString Text
data_
    (FunPtr C_LoggerPrinter -> C_LoggerPrinter
__dynamic_C_LoggerPrinter FunPtr C_LoggerPrinter
__funPtr) Ptr Logger
logger' CUInt
level' Int8
direction CString
data_' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
logger
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | The prototype for a custom printing callback.
-- 
-- /@level@/ indicates what kind of information is being printed. Eg, it
-- will be 'GI.Soup.Enums.LoggerLogLevelHeaders' if /@data@/ is header data.
-- 
-- /@direction@/ is either \'\<\', \'>\', or \' \', and /@data@/ is the single line
-- to print; the printer is expected to add a terminating newline.
-- 
-- To get the effect of the default printer, you would do:
-- 
-- \<informalexample>\<programlisting>
-- printf (\"@/c/@ @/s/@\\n\", direction, data);
-- \<\/programlisting>\<\/informalexample>
type LoggerPrinter =
    Soup.Logger.Logger
    -- ^ /@logger@/: the t'GI.Soup.Objects.Logger.Logger'
    -> Soup.Enums.LoggerLogLevel
    -- ^ /@level@/: the level of the information being printed.
    -> Int8
    -- ^ /@direction@/: a single-character prefix to /@data@/
    -> T.Text
    -- ^ /@data@/: data to print
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `LoggerPrinter`@.
noLoggerPrinter :: Maybe LoggerPrinter
noLoggerPrinter :: Maybe LoggerPrinter
noLoggerPrinter = Maybe LoggerPrinter
forall a. Maybe a
Nothing

-- | The prototype for a custom printing callback.
-- 
-- /@level@/ indicates what kind of information is being printed. Eg, it
-- will be 'GI.Soup.Enums.LoggerLogLevelHeaders' if /@data@/ is header data.
-- 
-- /@direction@/ is either \'\<\', \'>\', or \' \', and /@data@/ is the single line
-- to print; the printer is expected to add a terminating newline.
-- 
-- To get the effect of the default printer, you would do:
-- 
-- \<informalexample>\<programlisting>
-- printf (\"@/c/@ @/s/@\\n\", direction, data);
-- \<\/programlisting>\<\/informalexample>
type LoggerPrinter_WithClosures =
    Soup.Logger.Logger
    -- ^ /@logger@/: the t'GI.Soup.Objects.Logger.Logger'
    -> Soup.Enums.LoggerLogLevel
    -- ^ /@level@/: the level of the information being printed.
    -> Int8
    -- ^ /@direction@/: a single-character prefix to /@data@/
    -> T.Text
    -- ^ /@data@/: data to print
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Logger.loggerSetPrinter'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `LoggerPrinter_WithClosures`@.
noLoggerPrinter_WithClosures :: Maybe LoggerPrinter_WithClosures
noLoggerPrinter_WithClosures :: Maybe LoggerPrinter_WithClosures
noLoggerPrinter_WithClosures = Maybe LoggerPrinter_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_LoggerPrinter :: LoggerPrinter -> LoggerPrinter_WithClosures
drop_closures_LoggerPrinter :: LoggerPrinter -> LoggerPrinter_WithClosures
drop_closures_LoggerPrinter _f :: LoggerPrinter
_f logger :: Logger
logger level :: LoggerLogLevel
level direction :: Int8
direction data_ :: Text
data_ _ = LoggerPrinter
_f Logger
logger LoggerLogLevel
level Int8
direction Text
data_

-- | Wrap the callback into a `GClosure`.
genClosure_LoggerPrinter :: MonadIO m => LoggerPrinter -> m (GClosure C_LoggerPrinter)
genClosure_LoggerPrinter :: LoggerPrinter -> m (GClosure C_LoggerPrinter)
genClosure_LoggerPrinter cb :: LoggerPrinter
cb = IO (GClosure C_LoggerPrinter) -> m (GClosure C_LoggerPrinter)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_LoggerPrinter) -> m (GClosure C_LoggerPrinter))
-> IO (GClosure C_LoggerPrinter) -> m (GClosure C_LoggerPrinter)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: LoggerPrinter_WithClosures
cb' = LoggerPrinter -> LoggerPrinter_WithClosures
drop_closures_LoggerPrinter LoggerPrinter
cb
    let cb'' :: C_LoggerPrinter
cb'' = Maybe (Ptr (FunPtr C_LoggerPrinter))
-> LoggerPrinter_WithClosures -> C_LoggerPrinter
wrap_LoggerPrinter Maybe (Ptr (FunPtr C_LoggerPrinter))
forall a. Maybe a
Nothing LoggerPrinter_WithClosures
cb'
    C_LoggerPrinter -> IO (FunPtr C_LoggerPrinter)
mk_LoggerPrinter C_LoggerPrinter
cb'' IO (FunPtr C_LoggerPrinter)
-> (FunPtr C_LoggerPrinter -> IO (GClosure C_LoggerPrinter))
-> IO (GClosure C_LoggerPrinter)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_LoggerPrinter -> IO (GClosure C_LoggerPrinter)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `LoggerPrinter` into a `C_LoggerPrinter`.
wrap_LoggerPrinter ::
    Maybe (Ptr (FunPtr C_LoggerPrinter)) ->
    LoggerPrinter_WithClosures ->
    C_LoggerPrinter
wrap_LoggerPrinter :: Maybe (Ptr (FunPtr C_LoggerPrinter))
-> LoggerPrinter_WithClosures -> C_LoggerPrinter
wrap_LoggerPrinter funptrptr :: Maybe (Ptr (FunPtr C_LoggerPrinter))
funptrptr _cb :: LoggerPrinter_WithClosures
_cb logger :: Ptr Logger
logger level :: CUInt
level direction :: Int8
direction data_ :: CString
data_ userData :: Ptr ()
userData = do
    Logger
logger' <- ((ManagedPtr Logger -> Logger) -> Ptr Logger -> IO Logger
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Logger -> Logger
Soup.Logger.Logger) Ptr Logger
logger
    let level' :: LoggerLogLevel
level' = (Int -> LoggerLogLevel
forall a. Enum a => Int -> a
toEnum (Int -> LoggerLogLevel)
-> (CUInt -> Int) -> CUInt -> LoggerLogLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
level
    Text
data_' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
data_
    LoggerPrinter_WithClosures
_cb  Logger
logger' LoggerLogLevel
level' Int8
direction Text
data_' Ptr ()
userData
    Maybe (Ptr (FunPtr C_LoggerPrinter)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_LoggerPrinter))
funptrptr


-- callback LoggerFilter
--          -> Callable {returnType = Just (TInterface (Name {namespace = "Soup", name = "LoggerLogLevel"})), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "a #SoupLoggerLogLevel value indicating how much of\nthe message to log", sinceVersion = Nothing}, args = [Arg {argCName = "logger", argType = TInterface (Name {namespace = "Soup", name = "Logger"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupLogger", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message being logged", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_logger_set_request_filter()\nor soup_logger_set_response_filter()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The prototype for a logging filter. The filter callback will be\ninvoked for each request or response, and should analyze it and\nreturn a #SoupLoggerLogLevel value indicating how much of the\nmessage to log. Eg, it might choose between %SOUP_LOGGER_LOG_BODY\nand %SOUP_LOGGER_LOG_HEADERS depending on the Content-Type.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_LoggerFilter =
    Ptr Soup.Logger.Logger ->
    Ptr Soup.Message.Message ->
    Ptr () ->
    IO CUInt

-- Args: [ Arg
--           { argCName = "logger"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Logger" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupLogger" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message being logged"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the data passed to soup_logger_set_request_filter()\nor soup_logger_set_response_filter()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "LoggerLogLevel" })
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_LoggerFilter :: FunPtr C_LoggerFilter -> C_LoggerFilter

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_LoggerFilter ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Logger.IsLogger a, Soup.Message.IsMessage b) =>
    FunPtr C_LoggerFilter
    -> a
    -- ^ /@logger@/: the t'GI.Soup.Objects.Logger.Logger'
    -> b
    -- ^ /@msg@/: the message being logged
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Logger.loggerSetRequestFilter'
    -- or 'GI.Soup.Objects.Logger.loggerSetResponseFilter'
    -> m Soup.Enums.LoggerLogLevel
    -- ^ __Returns:__ a t'GI.Soup.Enums.LoggerLogLevel' value indicating how much of
    -- the message to log
dynamic_LoggerFilter :: FunPtr C_LoggerFilter -> a -> b -> Ptr () -> m LoggerLogLevel
dynamic_LoggerFilter __funPtr :: FunPtr C_LoggerFilter
__funPtr logger :: a
logger msg :: b
msg userData :: Ptr ()
userData = IO LoggerLogLevel -> m LoggerLogLevel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LoggerLogLevel -> m LoggerLogLevel)
-> IO LoggerLogLevel -> m LoggerLogLevel
forall a b. (a -> b) -> a -> b
$ do
    Ptr Logger
logger' <- a -> IO (Ptr Logger)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
logger
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    CUInt
result <- (FunPtr C_LoggerFilter -> C_LoggerFilter
__dynamic_C_LoggerFilter FunPtr C_LoggerFilter
__funPtr) Ptr Logger
logger' Ptr Message
msg' Ptr ()
userData
    let result' :: LoggerLogLevel
result' = (Int -> LoggerLogLevel
forall a. Enum a => Int -> a
toEnum (Int -> LoggerLogLevel)
-> (CUInt -> Int) -> CUInt -> LoggerLogLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
logger
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    LoggerLogLevel -> IO LoggerLogLevel
forall (m :: * -> *) a. Monad m => a -> m a
return LoggerLogLevel
result'

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

-- | The prototype for a logging filter. The filter callback will be
-- invoked for each request or response, and should analyze it and
-- return a t'GI.Soup.Enums.LoggerLogLevel' value indicating how much of the
-- message to log. Eg, it might choose between 'GI.Soup.Enums.LoggerLogLevelBody'
-- and 'GI.Soup.Enums.LoggerLogLevelHeaders' depending on the Content-Type.
type LoggerFilter =
    Soup.Logger.Logger
    -- ^ /@logger@/: the t'GI.Soup.Objects.Logger.Logger'
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being logged
    -> IO Soup.Enums.LoggerLogLevel
    -- ^ __Returns:__ a t'GI.Soup.Enums.LoggerLogLevel' value indicating how much of
    -- the message to log

-- | A convenience synonym for @`Nothing` :: `Maybe` `LoggerFilter`@.
noLoggerFilter :: Maybe LoggerFilter
noLoggerFilter :: Maybe LoggerFilter
noLoggerFilter = Maybe LoggerFilter
forall a. Maybe a
Nothing

-- | The prototype for a logging filter. The filter callback will be
-- invoked for each request or response, and should analyze it and
-- return a t'GI.Soup.Enums.LoggerLogLevel' value indicating how much of the
-- message to log. Eg, it might choose between 'GI.Soup.Enums.LoggerLogLevelBody'
-- and 'GI.Soup.Enums.LoggerLogLevelHeaders' depending on the Content-Type.
type LoggerFilter_WithClosures =
    Soup.Logger.Logger
    -- ^ /@logger@/: the t'GI.Soup.Objects.Logger.Logger'
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being logged
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Logger.loggerSetRequestFilter'
    -- or 'GI.Soup.Objects.Logger.loggerSetResponseFilter'
    -> IO Soup.Enums.LoggerLogLevel
    -- ^ __Returns:__ a t'GI.Soup.Enums.LoggerLogLevel' value indicating how much of
    -- the message to log

-- | A convenience synonym for @`Nothing` :: `Maybe` `LoggerFilter_WithClosures`@.
noLoggerFilter_WithClosures :: Maybe LoggerFilter_WithClosures
noLoggerFilter_WithClosures :: Maybe LoggerFilter_WithClosures
noLoggerFilter_WithClosures = Maybe LoggerFilter_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_LoggerFilter :: LoggerFilter -> LoggerFilter_WithClosures
drop_closures_LoggerFilter :: LoggerFilter -> LoggerFilter_WithClosures
drop_closures_LoggerFilter _f :: LoggerFilter
_f logger :: Logger
logger msg :: Message
msg _ = LoggerFilter
_f Logger
logger Message
msg

-- | Wrap the callback into a `GClosure`.
genClosure_LoggerFilter :: MonadIO m => LoggerFilter -> m (GClosure C_LoggerFilter)
genClosure_LoggerFilter :: LoggerFilter -> m (GClosure C_LoggerFilter)
genClosure_LoggerFilter cb :: LoggerFilter
cb = IO (GClosure C_LoggerFilter) -> m (GClosure C_LoggerFilter)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_LoggerFilter) -> m (GClosure C_LoggerFilter))
-> IO (GClosure C_LoggerFilter) -> m (GClosure C_LoggerFilter)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: LoggerFilter_WithClosures
cb' = LoggerFilter -> LoggerFilter_WithClosures
drop_closures_LoggerFilter LoggerFilter
cb
    let cb'' :: C_LoggerFilter
cb'' = Maybe (Ptr (FunPtr C_LoggerFilter))
-> LoggerFilter_WithClosures -> C_LoggerFilter
wrap_LoggerFilter Maybe (Ptr (FunPtr C_LoggerFilter))
forall a. Maybe a
Nothing LoggerFilter_WithClosures
cb'
    C_LoggerFilter -> IO (FunPtr C_LoggerFilter)
mk_LoggerFilter C_LoggerFilter
cb'' IO (FunPtr C_LoggerFilter)
-> (FunPtr C_LoggerFilter -> IO (GClosure C_LoggerFilter))
-> IO (GClosure C_LoggerFilter)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_LoggerFilter -> IO (GClosure C_LoggerFilter)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `LoggerFilter` into a `C_LoggerFilter`.
wrap_LoggerFilter ::
    Maybe (Ptr (FunPtr C_LoggerFilter)) ->
    LoggerFilter_WithClosures ->
    C_LoggerFilter
wrap_LoggerFilter :: Maybe (Ptr (FunPtr C_LoggerFilter))
-> LoggerFilter_WithClosures -> C_LoggerFilter
wrap_LoggerFilter funptrptr :: Maybe (Ptr (FunPtr C_LoggerFilter))
funptrptr _cb :: LoggerFilter_WithClosures
_cb logger :: Ptr Logger
logger msg :: Ptr Message
msg userData :: Ptr ()
userData = do
    Logger
logger' <- ((ManagedPtr Logger -> Logger) -> Ptr Logger -> IO Logger
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Logger -> Logger
Soup.Logger.Logger) Ptr Logger
logger
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    LoggerLogLevel
result <- LoggerFilter_WithClosures
_cb  Logger
logger' Message
msg' Ptr ()
userData
    Maybe (Ptr (FunPtr C_LoggerFilter)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_LoggerFilter))
funptrptr
    let result' :: CUInt
result' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (LoggerLogLevel -> Int) -> LoggerLogLevel -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LoggerLogLevel -> Int
forall a. Enum a => a -> Int
fromEnum) LoggerLogLevel
result
    CUInt -> IO CUInt
forall (m :: * -> *) a. Monad m => a -> m a
return CUInt
result'


-- callback ChunkAllocator
--          -> Callable {returnType = Just (TInterface (Name {namespace = "Soup", name = "Buffer"})), returnMayBeNull = True, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "the new buffer (or %NULL)", sinceVersion = Nothing}, args = [Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupMessage the chunk is being allocated for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum length that will be read, or 0.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_message_set_chunk_allocator()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Nothing, deprecationMessage = Just "Use #SoupRequest if you want to read into your\nown buffers."}), callableDocumentation = Documentation {rawDocText = Just "The prototype for a chunk allocation callback. This should allocate\na new #SoupBuffer and return it for the I/O layer to read message\nbody data off the network into.\n\nIf @max_len is non-0, it indicates the maximum number of bytes that\ncould be read, based on what is known about the message size. Note\nthat this might be a very large number, and you should not simply\ntry to allocate that many bytes blindly. If @max_len is 0, that\nmeans that libsoup does not know how many bytes remain to be read,\nand the allocator should return a buffer of a size that it finds\nconvenient.\n\nIf the allocator returns %NULL, the message will be paused. It is\nup to the application to make sure that it gets unpaused when it\nbecomes possible to allocate a new buffer.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ChunkAllocator =
    Ptr Soup.Message.Message ->
    Word64 ->
    Ptr () ->
    IO (Ptr Soup.Buffer.Buffer)

-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #SoupMessage the chunk is being allocated for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max_len"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the maximum length that will be read, or 0."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the data passed to soup_message_set_chunk_allocator()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Buffer" })
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ChunkAllocator :: FunPtr C_ChunkAllocator -> C_ChunkAllocator

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ChunkAllocator ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    FunPtr C_ChunkAllocator
    -> a
    -- ^ /@msg@/: the t'GI.Soup.Objects.Message.Message' the chunk is being allocated for
    -> Word64
    -- ^ /@maxLen@/: the maximum length that will be read, or 0.
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Message.messageSetChunkAllocator'
    -> m (Maybe Soup.Buffer.Buffer)
    -- ^ __Returns:__ the new buffer (or 'P.Nothing')
dynamic_ChunkAllocator :: FunPtr C_ChunkAllocator
-> a -> Word64 -> Ptr () -> m (Maybe Buffer)
dynamic_ChunkAllocator __funPtr :: FunPtr C_ChunkAllocator
__funPtr msg :: a
msg maxLen :: Word64
maxLen userData :: Ptr ()
userData = IO (Maybe Buffer) -> m (Maybe Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Buffer
result <- (FunPtr C_ChunkAllocator -> C_ChunkAllocator
__dynamic_C_ChunkAllocator FunPtr C_ChunkAllocator
__funPtr) Ptr Message
msg' Word64
maxLen Ptr ()
userData
    Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Buffer
result' -> do
        Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Soup.Buffer.Buffer) Ptr Buffer
result'
        Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult

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

{-# DEPRECATED ChunkAllocator ["Use t'GI.Soup.Objects.Request.Request' if you want to read into your","own buffers."] #-}
-- | The prototype for a chunk allocation callback. This should allocate
-- a new t'GI.Soup.Structs.Buffer.Buffer' and return it for the I\/O layer to read message
-- body data off the network into.
-- 
-- If /@maxLen@/ is non-0, it indicates the maximum number of bytes that
-- could be read, based on what is known about the message size. Note
-- that this might be a very large number, and you should not simply
-- try to allocate that many bytes blindly. If /@maxLen@/ is 0, that
-- means that libsoup does not know how many bytes remain to be read,
-- and the allocator should return a buffer of a size that it finds
-- convenient.
-- 
-- If the allocator returns 'P.Nothing', the message will be paused. It is
-- up to the application to make sure that it gets unpaused when it
-- becomes possible to allocate a new buffer.
type ChunkAllocator =
    Soup.Message.Message
    -- ^ /@msg@/: the t'GI.Soup.Objects.Message.Message' the chunk is being allocated for
    -> Word64
    -- ^ /@maxLen@/: the maximum length that will be read, or 0.
    -> IO (Maybe Soup.Buffer.Buffer)
    -- ^ __Returns:__ the new buffer (or 'P.Nothing')

-- | A convenience synonym for @`Nothing` :: `Maybe` `ChunkAllocator`@.
noChunkAllocator :: Maybe ChunkAllocator
noChunkAllocator :: Maybe ChunkAllocator
noChunkAllocator = Maybe ChunkAllocator
forall a. Maybe a
Nothing

-- | The prototype for a chunk allocation callback. This should allocate
-- a new t'GI.Soup.Structs.Buffer.Buffer' and return it for the I\/O layer to read message
-- body data off the network into.
-- 
-- If /@maxLen@/ is non-0, it indicates the maximum number of bytes that
-- could be read, based on what is known about the message size. Note
-- that this might be a very large number, and you should not simply
-- try to allocate that many bytes blindly. If /@maxLen@/ is 0, that
-- means that libsoup does not know how many bytes remain to be read,
-- and the allocator should return a buffer of a size that it finds
-- convenient.
-- 
-- If the allocator returns 'P.Nothing', the message will be paused. It is
-- up to the application to make sure that it gets unpaused when it
-- becomes possible to allocate a new buffer.
type ChunkAllocator_WithClosures =
    Soup.Message.Message
    -- ^ /@msg@/: the t'GI.Soup.Objects.Message.Message' the chunk is being allocated for
    -> Word64
    -- ^ /@maxLen@/: the maximum length that will be read, or 0.
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.Message.messageSetChunkAllocator'
    -> IO (Maybe Soup.Buffer.Buffer)
    -- ^ __Returns:__ the new buffer (or 'P.Nothing')

-- | A convenience synonym for @`Nothing` :: `Maybe` `ChunkAllocator_WithClosures`@.
noChunkAllocator_WithClosures :: Maybe ChunkAllocator_WithClosures
noChunkAllocator_WithClosures :: Maybe ChunkAllocator_WithClosures
noChunkAllocator_WithClosures = Maybe ChunkAllocator_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ChunkAllocator :: ChunkAllocator -> ChunkAllocator_WithClosures
drop_closures_ChunkAllocator :: ChunkAllocator -> ChunkAllocator_WithClosures
drop_closures_ChunkAllocator _f :: ChunkAllocator
_f msg :: Message
msg maxLen :: Word64
maxLen _ = ChunkAllocator
_f Message
msg Word64
maxLen

-- | Wrap the callback into a `GClosure`.
genClosure_ChunkAllocator :: MonadIO m => ChunkAllocator -> m (GClosure C_ChunkAllocator)
genClosure_ChunkAllocator :: ChunkAllocator -> m (GClosure C_ChunkAllocator)
genClosure_ChunkAllocator cb :: ChunkAllocator
cb = IO (GClosure C_ChunkAllocator) -> m (GClosure C_ChunkAllocator)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ChunkAllocator) -> m (GClosure C_ChunkAllocator))
-> IO (GClosure C_ChunkAllocator) -> m (GClosure C_ChunkAllocator)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: ChunkAllocator_WithClosures
cb' = ChunkAllocator -> ChunkAllocator_WithClosures
drop_closures_ChunkAllocator ChunkAllocator
cb
    let cb'' :: C_ChunkAllocator
cb'' = Maybe (Ptr (FunPtr C_ChunkAllocator))
-> ChunkAllocator_WithClosures -> C_ChunkAllocator
wrap_ChunkAllocator Maybe (Ptr (FunPtr C_ChunkAllocator))
forall a. Maybe a
Nothing ChunkAllocator_WithClosures
cb'
    C_ChunkAllocator -> IO (FunPtr C_ChunkAllocator)
mk_ChunkAllocator C_ChunkAllocator
cb'' IO (FunPtr C_ChunkAllocator)
-> (FunPtr C_ChunkAllocator -> IO (GClosure C_ChunkAllocator))
-> IO (GClosure C_ChunkAllocator)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ChunkAllocator -> IO (GClosure C_ChunkAllocator)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ChunkAllocator` into a `C_ChunkAllocator`.
wrap_ChunkAllocator ::
    Maybe (Ptr (FunPtr C_ChunkAllocator)) ->
    ChunkAllocator_WithClosures ->
    C_ChunkAllocator
wrap_ChunkAllocator :: Maybe (Ptr (FunPtr C_ChunkAllocator))
-> ChunkAllocator_WithClosures -> C_ChunkAllocator
wrap_ChunkAllocator funptrptr :: Maybe (Ptr (FunPtr C_ChunkAllocator))
funptrptr _cb :: ChunkAllocator_WithClosures
_cb msg :: Ptr Message
msg maxLen :: Word64
maxLen userData :: Ptr ()
userData = do
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Maybe Buffer
result <- ChunkAllocator_WithClosures
_cb  Message
msg' Word64
maxLen Ptr ()
userData
    Maybe (Ptr (FunPtr C_ChunkAllocator)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ChunkAllocator))
funptrptr
    Ptr Buffer
-> Maybe Buffer -> (Buffer -> IO (Ptr Buffer)) -> IO (Ptr Buffer)
forall (m :: * -> *) b a.
Monad m =>
b -> Maybe a -> (a -> m b) -> m b
maybeM Ptr Buffer
forall a. Ptr a
nullPtr Maybe Buffer
result ((Buffer -> IO (Ptr Buffer)) -> IO (Ptr Buffer))
-> (Buffer -> IO (Ptr Buffer)) -> IO (Ptr Buffer)
forall a b. (a -> b) -> a -> b
$ \result' :: Buffer
result' -> do
        Ptr Buffer
result'' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
result'
        Ptr Buffer -> IO (Ptr Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Buffer
result''


-- callback AuthDomainGenericAuthCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if @msg is authenticated, %FALSE if not.", sinceVersion = Nothing}, args = [Arg {argCName = "domain", argType = TInterface (Name {namespace = "Soup", name = "AuthDomain"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAuthDomain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupMessage being authenticated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the username from @msg", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to\nsoup_auth_domain_set_generic_auth_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The prototype for a #SoupAuthDomain generic authentication callback.\n\nThe callback should look up the user's password, call\nsoup_auth_domain_check_password(), and use the return value from\nthat method as its own return value.\n\nIn general, for security reasons, it is preferable to use the\nauth-domain-specific auth callbacks (eg,\n#SoupAuthDomainBasicAuthCallback and\n#SoupAuthDomainDigestAuthCallback), because they don't require\nkeeping a cleartext password database. Most users will use the same\npassword for many different sites, meaning if any site with a\ncleartext password database is compromised, accounts on other\nservers might be compromised as well. For many of the cases where\n#SoupServer is used, this is not really relevant, but it may still\nbe worth considering.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_AuthDomainGenericAuthCallback =
    Ptr Soup.AuthDomain.AuthDomain ->
    Ptr Soup.Message.Message ->
    CString ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "domain"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "AuthDomain" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupAuthDomain" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupMessage being authenticated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "username"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the username from @msg"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the data passed to\nsoup_auth_domain_set_generic_auth_callback()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_AuthDomainGenericAuthCallback :: FunPtr C_AuthDomainGenericAuthCallback -> C_AuthDomainGenericAuthCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_AuthDomainGenericAuthCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.AuthDomain.IsAuthDomain a, Soup.Message.IsMessage b) =>
    FunPtr C_AuthDomainGenericAuthCallback
    -> a
    -- ^ /@domain@/: a t'GI.Soup.Objects.AuthDomain.AuthDomain'
    -> b
    -- ^ /@msg@/: the t'GI.Soup.Objects.Message.Message' being authenticated
    -> T.Text
    -- ^ /@username@/: the username from /@msg@/
    -> Ptr ()
    -- ^ /@userData@/: the data passed to
    -- 'GI.Soup.Objects.AuthDomain.authDomainSetGenericAuthCallback'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@msg@/ is authenticated, 'P.False' if not.
dynamic_AuthDomainGenericAuthCallback :: FunPtr C_AuthDomainGenericAuthCallback
-> a -> b -> Text -> Ptr () -> m Bool
dynamic_AuthDomainGenericAuthCallback __funPtr :: FunPtr C_AuthDomainGenericAuthCallback
__funPtr domain :: a
domain msg :: b
msg username :: Text
username userData :: Ptr ()
userData = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr AuthDomain
domain' <- a -> IO (Ptr AuthDomain)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
domain
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    CString
username' <- Text -> IO CString
textToCString Text
username
    CInt
result <- (FunPtr C_AuthDomainGenericAuthCallback
-> C_AuthDomainGenericAuthCallback
__dynamic_C_AuthDomainGenericAuthCallback FunPtr C_AuthDomainGenericAuthCallback
__funPtr) Ptr AuthDomain
domain' Ptr Message
msg' CString
username' Ptr ()
userData
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
domain
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
username'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

-- | The prototype for a t'GI.Soup.Objects.AuthDomain.AuthDomain' generic authentication callback.
-- 
-- The callback should look up the user\'s password, call
-- 'GI.Soup.Objects.AuthDomain.authDomainCheckPassword', and use the return value from
-- that method as its own return value.
-- 
-- In general, for security reasons, it is preferable to use the
-- auth-domain-specific auth callbacks (eg,
-- t'GI.Soup.Callbacks.AuthDomainBasicAuthCallback' and
-- t'GI.Soup.Callbacks.AuthDomainDigestAuthCallback'), because they don\'t require
-- keeping a cleartext password database. Most users will use the same
-- password for many different sites, meaning if any site with a
-- cleartext password database is compromised, accounts on other
-- servers might be compromised as well. For many of the cases where
-- t'GI.Soup.Objects.Server.Server' is used, this is not really relevant, but it may still
-- be worth considering.
type AuthDomainGenericAuthCallback =
    Soup.AuthDomain.AuthDomain
    -- ^ /@domain@/: a t'GI.Soup.Objects.AuthDomain.AuthDomain'
    -> Soup.Message.Message
    -- ^ /@msg@/: the t'GI.Soup.Objects.Message.Message' being authenticated
    -> T.Text
    -- ^ /@username@/: the username from /@msg@/
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@msg@/ is authenticated, 'P.False' if not.

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainGenericAuthCallback`@.
noAuthDomainGenericAuthCallback :: Maybe AuthDomainGenericAuthCallback
noAuthDomainGenericAuthCallback :: Maybe AuthDomainGenericAuthCallback
noAuthDomainGenericAuthCallback = Maybe AuthDomainGenericAuthCallback
forall a. Maybe a
Nothing

-- | The prototype for a t'GI.Soup.Objects.AuthDomain.AuthDomain' generic authentication callback.
-- 
-- The callback should look up the user\'s password, call
-- 'GI.Soup.Objects.AuthDomain.authDomainCheckPassword', and use the return value from
-- that method as its own return value.
-- 
-- In general, for security reasons, it is preferable to use the
-- auth-domain-specific auth callbacks (eg,
-- t'GI.Soup.Callbacks.AuthDomainBasicAuthCallback' and
-- t'GI.Soup.Callbacks.AuthDomainDigestAuthCallback'), because they don\'t require
-- keeping a cleartext password database. Most users will use the same
-- password for many different sites, meaning if any site with a
-- cleartext password database is compromised, accounts on other
-- servers might be compromised as well. For many of the cases where
-- t'GI.Soup.Objects.Server.Server' is used, this is not really relevant, but it may still
-- be worth considering.
type AuthDomainGenericAuthCallback_WithClosures =
    Soup.AuthDomain.AuthDomain
    -- ^ /@domain@/: a t'GI.Soup.Objects.AuthDomain.AuthDomain'
    -> Soup.Message.Message
    -- ^ /@msg@/: the t'GI.Soup.Objects.Message.Message' being authenticated
    -> T.Text
    -- ^ /@username@/: the username from /@msg@/
    -> Ptr ()
    -- ^ /@userData@/: the data passed to
    -- 'GI.Soup.Objects.AuthDomain.authDomainSetGenericAuthCallback'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@msg@/ is authenticated, 'P.False' if not.

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainGenericAuthCallback_WithClosures`@.
noAuthDomainGenericAuthCallback_WithClosures :: Maybe AuthDomainGenericAuthCallback_WithClosures
noAuthDomainGenericAuthCallback_WithClosures :: Maybe AuthDomainGenericAuthCallback_WithClosures
noAuthDomainGenericAuthCallback_WithClosures = Maybe AuthDomainGenericAuthCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AuthDomainGenericAuthCallback :: AuthDomainGenericAuthCallback -> AuthDomainGenericAuthCallback_WithClosures
drop_closures_AuthDomainGenericAuthCallback :: AuthDomainGenericAuthCallback
-> AuthDomainGenericAuthCallback_WithClosures
drop_closures_AuthDomainGenericAuthCallback _f :: AuthDomainGenericAuthCallback
_f domain :: AuthDomain
domain msg :: Message
msg username :: Text
username _ = AuthDomainGenericAuthCallback
_f AuthDomain
domain Message
msg Text
username

-- | Wrap the callback into a `GClosure`.
genClosure_AuthDomainGenericAuthCallback :: MonadIO m => AuthDomainGenericAuthCallback -> m (GClosure C_AuthDomainGenericAuthCallback)
genClosure_AuthDomainGenericAuthCallback :: AuthDomainGenericAuthCallback
-> m (GClosure C_AuthDomainGenericAuthCallback)
genClosure_AuthDomainGenericAuthCallback cb :: AuthDomainGenericAuthCallback
cb = IO (GClosure C_AuthDomainGenericAuthCallback)
-> m (GClosure C_AuthDomainGenericAuthCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AuthDomainGenericAuthCallback)
 -> m (GClosure C_AuthDomainGenericAuthCallback))
-> IO (GClosure C_AuthDomainGenericAuthCallback)
-> m (GClosure C_AuthDomainGenericAuthCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: AuthDomainGenericAuthCallback_WithClosures
cb' = AuthDomainGenericAuthCallback
-> AuthDomainGenericAuthCallback_WithClosures
drop_closures_AuthDomainGenericAuthCallback AuthDomainGenericAuthCallback
cb
    let cb'' :: C_AuthDomainGenericAuthCallback
cb'' = Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback))
-> AuthDomainGenericAuthCallback_WithClosures
-> C_AuthDomainGenericAuthCallback
wrap_AuthDomainGenericAuthCallback Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback))
forall a. Maybe a
Nothing AuthDomainGenericAuthCallback_WithClosures
cb'
    C_AuthDomainGenericAuthCallback
-> IO (FunPtr C_AuthDomainGenericAuthCallback)
mk_AuthDomainGenericAuthCallback C_AuthDomainGenericAuthCallback
cb'' IO (FunPtr C_AuthDomainGenericAuthCallback)
-> (FunPtr C_AuthDomainGenericAuthCallback
    -> IO (GClosure C_AuthDomainGenericAuthCallback))
-> IO (GClosure C_AuthDomainGenericAuthCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AuthDomainGenericAuthCallback
-> IO (GClosure C_AuthDomainGenericAuthCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AuthDomainGenericAuthCallback` into a `C_AuthDomainGenericAuthCallback`.
wrap_AuthDomainGenericAuthCallback ::
    Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback)) ->
    AuthDomainGenericAuthCallback_WithClosures ->
    C_AuthDomainGenericAuthCallback
wrap_AuthDomainGenericAuthCallback :: Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback))
-> AuthDomainGenericAuthCallback_WithClosures
-> C_AuthDomainGenericAuthCallback
wrap_AuthDomainGenericAuthCallback funptrptr :: Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback))
funptrptr _cb :: AuthDomainGenericAuthCallback_WithClosures
_cb domain :: Ptr AuthDomain
domain msg :: Ptr Message
msg username :: CString
username userData :: Ptr ()
userData = do
    AuthDomain
domain' <- ((ManagedPtr AuthDomain -> AuthDomain)
-> Ptr AuthDomain -> IO AuthDomain
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr AuthDomain -> AuthDomain
Soup.AuthDomain.AuthDomain) Ptr AuthDomain
domain
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Text
username' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
username
    Bool
result <- AuthDomainGenericAuthCallback_WithClosures
_cb  AuthDomain
domain' Message
msg' Text
username' Ptr ()
userData
    Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback))
funptrptr
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- callback AuthDomainFilter
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if @msg requires authentication, %FALSE if not.", sinceVersion = Nothing}, args = [Arg {argCName = "domain", argType = TInterface (Name {namespace = "Soup", name = "AuthDomain"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAuthDomain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_auth_domain_set_filter()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The prototype for a #SoupAuthDomain filter; see\nsoup_auth_domain_set_filter() for details.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_AuthDomainFilter =
    Ptr Soup.AuthDomain.AuthDomain ->
    Ptr Soup.Message.Message ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "domain"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "AuthDomain" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupAuthDomain" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the data passed to soup_auth_domain_set_filter()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_AuthDomainFilter :: FunPtr C_AuthDomainFilter -> C_AuthDomainFilter

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_AuthDomainFilter ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.AuthDomain.IsAuthDomain a, Soup.Message.IsMessage b) =>
    FunPtr C_AuthDomainFilter
    -> a
    -- ^ /@domain@/: a t'GI.Soup.Objects.AuthDomain.AuthDomain'
    -> b
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.AuthDomain.authDomainSetFilter'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@msg@/ requires authentication, 'P.False' if not.
dynamic_AuthDomainFilter :: FunPtr C_AuthDomainFilter -> a -> b -> Ptr () -> m Bool
dynamic_AuthDomainFilter __funPtr :: FunPtr C_AuthDomainFilter
__funPtr domain :: a
domain msg :: b
msg userData :: Ptr ()
userData = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr AuthDomain
domain' <- a -> IO (Ptr AuthDomain)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
domain
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    CInt
result <- (FunPtr C_AuthDomainFilter -> C_AuthDomainFilter
__dynamic_C_AuthDomainFilter FunPtr C_AuthDomainFilter
__funPtr) Ptr AuthDomain
domain' Ptr Message
msg' Ptr ()
userData
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
domain
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

-- | The prototype for a t'GI.Soup.Objects.AuthDomain.AuthDomain' filter; see
-- 'GI.Soup.Objects.AuthDomain.authDomainSetFilter' for details.
type AuthDomainFilter =
    Soup.AuthDomain.AuthDomain
    -- ^ /@domain@/: a t'GI.Soup.Objects.AuthDomain.AuthDomain'
    -> Soup.Message.Message
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@msg@/ requires authentication, 'P.False' if not.

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainFilter`@.
noAuthDomainFilter :: Maybe AuthDomainFilter
noAuthDomainFilter :: Maybe AuthDomainFilter
noAuthDomainFilter = Maybe AuthDomainFilter
forall a. Maybe a
Nothing

-- | The prototype for a t'GI.Soup.Objects.AuthDomain.AuthDomain' filter; see
-- 'GI.Soup.Objects.AuthDomain.authDomainSetFilter' for details.
type AuthDomainFilter_WithClosures =
    Soup.AuthDomain.AuthDomain
    -- ^ /@domain@/: a t'GI.Soup.Objects.AuthDomain.AuthDomain'
    -> Soup.Message.Message
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.AuthDomain.authDomainSetFilter'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@msg@/ requires authentication, 'P.False' if not.

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainFilter_WithClosures`@.
noAuthDomainFilter_WithClosures :: Maybe AuthDomainFilter_WithClosures
noAuthDomainFilter_WithClosures :: Maybe AuthDomainFilter_WithClosures
noAuthDomainFilter_WithClosures = Maybe AuthDomainFilter_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AuthDomainFilter :: AuthDomainFilter -> AuthDomainFilter_WithClosures
drop_closures_AuthDomainFilter :: AuthDomainFilter -> AuthDomainFilter_WithClosures
drop_closures_AuthDomainFilter _f :: AuthDomainFilter
_f domain :: AuthDomain
domain msg :: Message
msg _ = AuthDomainFilter
_f AuthDomain
domain Message
msg

-- | Wrap the callback into a `GClosure`.
genClosure_AuthDomainFilter :: MonadIO m => AuthDomainFilter -> m (GClosure C_AuthDomainFilter)
genClosure_AuthDomainFilter :: AuthDomainFilter -> m (GClosure C_AuthDomainFilter)
genClosure_AuthDomainFilter cb :: AuthDomainFilter
cb = IO (GClosure C_AuthDomainFilter) -> m (GClosure C_AuthDomainFilter)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AuthDomainFilter)
 -> m (GClosure C_AuthDomainFilter))
-> IO (GClosure C_AuthDomainFilter)
-> m (GClosure C_AuthDomainFilter)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: AuthDomainFilter_WithClosures
cb' = AuthDomainFilter -> AuthDomainFilter_WithClosures
drop_closures_AuthDomainFilter AuthDomainFilter
cb
    let cb'' :: C_AuthDomainFilter
cb'' = Maybe (Ptr (FunPtr C_AuthDomainFilter))
-> AuthDomainFilter_WithClosures -> C_AuthDomainFilter
wrap_AuthDomainFilter Maybe (Ptr (FunPtr C_AuthDomainFilter))
forall a. Maybe a
Nothing AuthDomainFilter_WithClosures
cb'
    C_AuthDomainFilter -> IO (FunPtr C_AuthDomainFilter)
mk_AuthDomainFilter C_AuthDomainFilter
cb'' IO (FunPtr C_AuthDomainFilter)
-> (FunPtr C_AuthDomainFilter -> IO (GClosure C_AuthDomainFilter))
-> IO (GClosure C_AuthDomainFilter)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AuthDomainFilter -> IO (GClosure C_AuthDomainFilter)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AuthDomainFilter` into a `C_AuthDomainFilter`.
wrap_AuthDomainFilter ::
    Maybe (Ptr (FunPtr C_AuthDomainFilter)) ->
    AuthDomainFilter_WithClosures ->
    C_AuthDomainFilter
wrap_AuthDomainFilter :: Maybe (Ptr (FunPtr C_AuthDomainFilter))
-> AuthDomainFilter_WithClosures -> C_AuthDomainFilter
wrap_AuthDomainFilter funptrptr :: Maybe (Ptr (FunPtr C_AuthDomainFilter))
funptrptr _cb :: AuthDomainFilter_WithClosures
_cb domain :: Ptr AuthDomain
domain msg :: Ptr Message
msg userData :: Ptr ()
userData = do
    AuthDomain
domain' <- ((ManagedPtr AuthDomain -> AuthDomain)
-> Ptr AuthDomain -> IO AuthDomain
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr AuthDomain -> AuthDomain
Soup.AuthDomain.AuthDomain) Ptr AuthDomain
domain
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Bool
result <- AuthDomainFilter_WithClosures
_cb  AuthDomain
domain' Message
msg' Ptr ()
userData
    Maybe (Ptr (FunPtr C_AuthDomainFilter)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AuthDomainFilter))
funptrptr
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- callback AuthDomainDigestAuthCallback
--          -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = True, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "the encoded password, or %NULL if\n@username is not a valid user. @domain will free the password when\nit is done with it.", sinceVersion = Nothing}, args = [Arg {argCName = "domain", argType = TInterface (Name {namespace = "Soup", name = "AuthDomainDigest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the domain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message being authenticated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the username provided by the client", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_auth_domain_digest_set_auth_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Callback used by #SoupAuthDomainDigest for authentication purposes.\nThe application should look up @username in its password database,\nand return the corresponding encoded password (see\nsoup_auth_domain_digest_encode_password()).", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_AuthDomainDigestAuthCallback =
    Ptr Soup.AuthDomainDigest.AuthDomainDigest ->
    Ptr Soup.Message.Message ->
    CString ->
    Ptr () ->
    IO CString

-- Args: [ Arg
--           { argCName = "domain"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "AuthDomainDigest" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the domain" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message being authenticated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "username"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the username provided by the client"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the data passed to soup_auth_domain_digest_set_auth_callback()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_AuthDomainDigestAuthCallback :: FunPtr C_AuthDomainDigestAuthCallback -> C_AuthDomainDigestAuthCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_AuthDomainDigestAuthCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.AuthDomainDigest.IsAuthDomainDigest a, Soup.Message.IsMessage b) =>
    FunPtr C_AuthDomainDigestAuthCallback
    -> a
    -- ^ /@domain@/: the domain
    -> b
    -- ^ /@msg@/: the message being authenticated
    -> T.Text
    -- ^ /@username@/: the username provided by the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.AuthDomainDigest.authDomainDigestSetAuthCallback'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the encoded password, or 'P.Nothing' if
    -- /@username@/ is not a valid user. /@domain@/ will free the password when
    -- it is done with it.
dynamic_AuthDomainDigestAuthCallback :: FunPtr C_AuthDomainDigestAuthCallback
-> a -> b -> Text -> Ptr () -> m (Maybe Text)
dynamic_AuthDomainDigestAuthCallback __funPtr :: FunPtr C_AuthDomainDigestAuthCallback
__funPtr domain :: a
domain msg :: b
msg username :: Text
username userData :: Ptr ()
userData = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr AuthDomainDigest
domain' <- a -> IO (Ptr AuthDomainDigest)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
domain
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    CString
username' <- Text -> IO CString
textToCString Text
username
    CString
result <- (FunPtr C_AuthDomainDigestAuthCallback
-> C_AuthDomainDigestAuthCallback
__dynamic_C_AuthDomainDigestAuthCallback FunPtr C_AuthDomainDigestAuthCallback
__funPtr) Ptr AuthDomainDigest
domain' Ptr Message
msg' CString
username' Ptr ()
userData
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
domain
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
username'
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

-- | Callback used by t'GI.Soup.Objects.AuthDomainDigest.AuthDomainDigest' for authentication purposes.
-- The application should look up /@username@/ in its password database,
-- and return the corresponding encoded password (see
-- 'GI.Soup.Objects.AuthDomainDigest.authDomainDigestEncodePassword').
type AuthDomainDigestAuthCallback =
    Soup.AuthDomainDigest.AuthDomainDigest
    -- ^ /@domain@/: the domain
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being authenticated
    -> T.Text
    -- ^ /@username@/: the username provided by the client
    -> IO (Maybe T.Text)
    -- ^ __Returns:__ the encoded password, or 'P.Nothing' if
    -- /@username@/ is not a valid user. /@domain@/ will free the password when
    -- it is done with it.

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainDigestAuthCallback`@.
noAuthDomainDigestAuthCallback :: Maybe AuthDomainDigestAuthCallback
noAuthDomainDigestAuthCallback :: Maybe AuthDomainDigestAuthCallback
noAuthDomainDigestAuthCallback = Maybe AuthDomainDigestAuthCallback
forall a. Maybe a
Nothing

-- | Callback used by t'GI.Soup.Objects.AuthDomainDigest.AuthDomainDigest' for authentication purposes.
-- The application should look up /@username@/ in its password database,
-- and return the corresponding encoded password (see
-- 'GI.Soup.Objects.AuthDomainDigest.authDomainDigestEncodePassword').
type AuthDomainDigestAuthCallback_WithClosures =
    Soup.AuthDomainDigest.AuthDomainDigest
    -- ^ /@domain@/: the domain
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being authenticated
    -> T.Text
    -- ^ /@username@/: the username provided by the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.AuthDomainDigest.authDomainDigestSetAuthCallback'
    -> IO (Maybe T.Text)
    -- ^ __Returns:__ the encoded password, or 'P.Nothing' if
    -- /@username@/ is not a valid user. /@domain@/ will free the password when
    -- it is done with it.

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainDigestAuthCallback_WithClosures`@.
noAuthDomainDigestAuthCallback_WithClosures :: Maybe AuthDomainDigestAuthCallback_WithClosures
noAuthDomainDigestAuthCallback_WithClosures :: Maybe AuthDomainDigestAuthCallback_WithClosures
noAuthDomainDigestAuthCallback_WithClosures = Maybe AuthDomainDigestAuthCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AuthDomainDigestAuthCallback :: AuthDomainDigestAuthCallback -> AuthDomainDigestAuthCallback_WithClosures
drop_closures_AuthDomainDigestAuthCallback :: AuthDomainDigestAuthCallback
-> AuthDomainDigestAuthCallback_WithClosures
drop_closures_AuthDomainDigestAuthCallback _f :: AuthDomainDigestAuthCallback
_f domain :: AuthDomainDigest
domain msg :: Message
msg username :: Text
username _ = AuthDomainDigestAuthCallback
_f AuthDomainDigest
domain Message
msg Text
username

-- | Wrap the callback into a `GClosure`.
genClosure_AuthDomainDigestAuthCallback :: MonadIO m => AuthDomainDigestAuthCallback -> m (GClosure C_AuthDomainDigestAuthCallback)
genClosure_AuthDomainDigestAuthCallback :: AuthDomainDigestAuthCallback
-> m (GClosure C_AuthDomainDigestAuthCallback)
genClosure_AuthDomainDigestAuthCallback cb :: AuthDomainDigestAuthCallback
cb = IO (GClosure C_AuthDomainDigestAuthCallback)
-> m (GClosure C_AuthDomainDigestAuthCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AuthDomainDigestAuthCallback)
 -> m (GClosure C_AuthDomainDigestAuthCallback))
-> IO (GClosure C_AuthDomainDigestAuthCallback)
-> m (GClosure C_AuthDomainDigestAuthCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: AuthDomainDigestAuthCallback_WithClosures
cb' = AuthDomainDigestAuthCallback
-> AuthDomainDigestAuthCallback_WithClosures
drop_closures_AuthDomainDigestAuthCallback AuthDomainDigestAuthCallback
cb
    let cb'' :: C_AuthDomainDigestAuthCallback
cb'' = Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback))
-> AuthDomainDigestAuthCallback_WithClosures
-> C_AuthDomainDigestAuthCallback
wrap_AuthDomainDigestAuthCallback Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback))
forall a. Maybe a
Nothing AuthDomainDigestAuthCallback_WithClosures
cb'
    C_AuthDomainDigestAuthCallback
-> IO (FunPtr C_AuthDomainDigestAuthCallback)
mk_AuthDomainDigestAuthCallback C_AuthDomainDigestAuthCallback
cb'' IO (FunPtr C_AuthDomainDigestAuthCallback)
-> (FunPtr C_AuthDomainDigestAuthCallback
    -> IO (GClosure C_AuthDomainDigestAuthCallback))
-> IO (GClosure C_AuthDomainDigestAuthCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AuthDomainDigestAuthCallback
-> IO (GClosure C_AuthDomainDigestAuthCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AuthDomainDigestAuthCallback` into a `C_AuthDomainDigestAuthCallback`.
wrap_AuthDomainDigestAuthCallback ::
    Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback)) ->
    AuthDomainDigestAuthCallback_WithClosures ->
    C_AuthDomainDigestAuthCallback
wrap_AuthDomainDigestAuthCallback :: Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback))
-> AuthDomainDigestAuthCallback_WithClosures
-> C_AuthDomainDigestAuthCallback
wrap_AuthDomainDigestAuthCallback funptrptr :: Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback))
funptrptr _cb :: AuthDomainDigestAuthCallback_WithClosures
_cb domain :: Ptr AuthDomainDigest
domain msg :: Ptr Message
msg username :: CString
username userData :: Ptr ()
userData = do
    AuthDomainDigest
domain' <- ((ManagedPtr AuthDomainDigest -> AuthDomainDigest)
-> Ptr AuthDomainDigest -> IO AuthDomainDigest
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr AuthDomainDigest -> AuthDomainDigest
Soup.AuthDomainDigest.AuthDomainDigest) Ptr AuthDomainDigest
domain
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Text
username' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
username
    Maybe Text
result <- AuthDomainDigestAuthCallback_WithClosures
_cb  AuthDomainDigest
domain' Message
msg' Text
username' Ptr ()
userData
    Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback))
funptrptr
    CString -> Maybe Text -> (Text -> IO CString) -> IO CString
forall (m :: * -> *) b a.
Monad m =>
b -> Maybe a -> (a -> m b) -> m b
maybeM CString
forall a. Ptr a
nullPtr Maybe Text
result ((Text -> IO CString) -> IO CString)
-> (Text -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ \result' :: Text
result' -> do
        CString
result'' <- Text -> IO CString
textToCString Text
result'
        CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
result''


-- callback AuthDomainBasicAuthCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if @username and @password are valid", sinceVersion = Nothing}, args = [Arg {argCName = "domain", argType = TInterface (Name {namespace = "Soup", name = "AuthDomainBasic"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the domain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface (Name {namespace = "Soup", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message being authenticated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the username provided by the client", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the password provided by the client", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data passed to soup_auth_domain_basic_set_auth_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Callback used by #SoupAuthDomainBasic for authentication purposes.\nThe application should verify that @username and @password and valid\nand return %TRUE or %FALSE.\n\nIf you are maintaining your own password database (rather than\nusing the password to authenticate against some other system like\nPAM or a remote server), you should make sure you know what you are\ndoing. In particular, don't store cleartext passwords, or\neasily-computed hashes of cleartext passwords, even if you don't\ncare that much about the security of your server, because users\nwill frequently use the same password for multiple sites, and so\ncompromising any site with a cleartext (or easily-cracked) password\ndatabase may give attackers access to other more-interesting sites\nas well.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_AuthDomainBasicAuthCallback =
    Ptr Soup.AuthDomainBasic.AuthDomainBasic ->
    Ptr Soup.Message.Message ->
    CString ->
    CString ->
    Ptr () ->
    IO CInt

-- Args: [ Arg
--           { argCName = "domain"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "AuthDomainBasic" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the domain" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message being authenticated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "username"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the username provided by the client"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "password"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the password provided by the client"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the data passed to soup_auth_domain_basic_set_auth_callback()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_AuthDomainBasicAuthCallback :: FunPtr C_AuthDomainBasicAuthCallback -> C_AuthDomainBasicAuthCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_AuthDomainBasicAuthCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.AuthDomainBasic.IsAuthDomainBasic a, Soup.Message.IsMessage b) =>
    FunPtr C_AuthDomainBasicAuthCallback
    -> a
    -- ^ /@domain@/: the domain
    -> b
    -- ^ /@msg@/: the message being authenticated
    -> T.Text
    -- ^ /@username@/: the username provided by the client
    -> T.Text
    -- ^ /@password@/: the password provided by the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.AuthDomainBasic.authDomainBasicSetAuthCallback'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@username@/ and /@password@/ are valid
dynamic_AuthDomainBasicAuthCallback :: FunPtr C_AuthDomainBasicAuthCallback
-> a -> b -> Text -> Text -> Ptr () -> m Bool
dynamic_AuthDomainBasicAuthCallback __funPtr :: FunPtr C_AuthDomainBasicAuthCallback
__funPtr domain :: a
domain msg :: b
msg username :: Text
username password :: Text
password userData :: Ptr ()
userData = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr AuthDomainBasic
domain' <- a -> IO (Ptr AuthDomainBasic)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
domain
    Ptr Message
msg' <- b -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
msg
    CString
username' <- Text -> IO CString
textToCString Text
username
    CString
password' <- Text -> IO CString
textToCString Text
password
    CInt
result <- (FunPtr C_AuthDomainBasicAuthCallback
-> C_AuthDomainBasicAuthCallback
__dynamic_C_AuthDomainBasicAuthCallback FunPtr C_AuthDomainBasicAuthCallback
__funPtr) Ptr AuthDomainBasic
domain' Ptr Message
msg' CString
username' CString
password' Ptr ()
userData
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
domain
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
msg
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
username'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
password'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

-- | Callback used by t'GI.Soup.Objects.AuthDomainBasic.AuthDomainBasic' for authentication purposes.
-- The application should verify that /@username@/ and /@password@/ and valid
-- and return 'P.True' or 'P.False'.
-- 
-- If you are maintaining your own password database (rather than
-- using the password to authenticate against some other system like
-- PAM or a remote server), you should make sure you know what you are
-- doing. In particular, don\'t store cleartext passwords, or
-- easily-computed hashes of cleartext passwords, even if you don\'t
-- care that much about the security of your server, because users
-- will frequently use the same password for multiple sites, and so
-- compromising any site with a cleartext (or easily-cracked) password
-- database may give attackers access to other more-interesting sites
-- as well.
type AuthDomainBasicAuthCallback =
    Soup.AuthDomainBasic.AuthDomainBasic
    -- ^ /@domain@/: the domain
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being authenticated
    -> T.Text
    -- ^ /@username@/: the username provided by the client
    -> T.Text
    -- ^ /@password@/: the password provided by the client
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@username@/ and /@password@/ are valid

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainBasicAuthCallback`@.
noAuthDomainBasicAuthCallback :: Maybe AuthDomainBasicAuthCallback
noAuthDomainBasicAuthCallback :: Maybe AuthDomainBasicAuthCallback
noAuthDomainBasicAuthCallback = Maybe AuthDomainBasicAuthCallback
forall a. Maybe a
Nothing

-- | Callback used by t'GI.Soup.Objects.AuthDomainBasic.AuthDomainBasic' for authentication purposes.
-- The application should verify that /@username@/ and /@password@/ and valid
-- and return 'P.True' or 'P.False'.
-- 
-- If you are maintaining your own password database (rather than
-- using the password to authenticate against some other system like
-- PAM or a remote server), you should make sure you know what you are
-- doing. In particular, don\'t store cleartext passwords, or
-- easily-computed hashes of cleartext passwords, even if you don\'t
-- care that much about the security of your server, because users
-- will frequently use the same password for multiple sites, and so
-- compromising any site with a cleartext (or easily-cracked) password
-- database may give attackers access to other more-interesting sites
-- as well.
type AuthDomainBasicAuthCallback_WithClosures =
    Soup.AuthDomainBasic.AuthDomainBasic
    -- ^ /@domain@/: the domain
    -> Soup.Message.Message
    -- ^ /@msg@/: the message being authenticated
    -> T.Text
    -- ^ /@username@/: the username provided by the client
    -> T.Text
    -- ^ /@password@/: the password provided by the client
    -> Ptr ()
    -- ^ /@userData@/: the data passed to 'GI.Soup.Objects.AuthDomainBasic.authDomainBasicSetAuthCallback'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@username@/ and /@password@/ are valid

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthDomainBasicAuthCallback_WithClosures`@.
noAuthDomainBasicAuthCallback_WithClosures :: Maybe AuthDomainBasicAuthCallback_WithClosures
noAuthDomainBasicAuthCallback_WithClosures :: Maybe AuthDomainBasicAuthCallback_WithClosures
noAuthDomainBasicAuthCallback_WithClosures = Maybe AuthDomainBasicAuthCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AuthDomainBasicAuthCallback :: AuthDomainBasicAuthCallback -> AuthDomainBasicAuthCallback_WithClosures
drop_closures_AuthDomainBasicAuthCallback :: AuthDomainBasicAuthCallback
-> AuthDomainBasicAuthCallback_WithClosures
drop_closures_AuthDomainBasicAuthCallback _f :: AuthDomainBasicAuthCallback
_f domain :: AuthDomainBasic
domain msg :: Message
msg username :: Text
username password :: Text
password _ = AuthDomainBasicAuthCallback
_f AuthDomainBasic
domain Message
msg Text
username Text
password

-- | Wrap the callback into a `GClosure`.
genClosure_AuthDomainBasicAuthCallback :: MonadIO m => AuthDomainBasicAuthCallback -> m (GClosure C_AuthDomainBasicAuthCallback)
genClosure_AuthDomainBasicAuthCallback :: AuthDomainBasicAuthCallback
-> m (GClosure C_AuthDomainBasicAuthCallback)
genClosure_AuthDomainBasicAuthCallback cb :: AuthDomainBasicAuthCallback
cb = IO (GClosure C_AuthDomainBasicAuthCallback)
-> m (GClosure C_AuthDomainBasicAuthCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AuthDomainBasicAuthCallback)
 -> m (GClosure C_AuthDomainBasicAuthCallback))
-> IO (GClosure C_AuthDomainBasicAuthCallback)
-> m (GClosure C_AuthDomainBasicAuthCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: AuthDomainBasicAuthCallback_WithClosures
cb' = AuthDomainBasicAuthCallback
-> AuthDomainBasicAuthCallback_WithClosures
drop_closures_AuthDomainBasicAuthCallback AuthDomainBasicAuthCallback
cb
    let cb'' :: C_AuthDomainBasicAuthCallback
cb'' = Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback))
-> AuthDomainBasicAuthCallback_WithClosures
-> C_AuthDomainBasicAuthCallback
wrap_AuthDomainBasicAuthCallback Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback))
forall a. Maybe a
Nothing AuthDomainBasicAuthCallback_WithClosures
cb'
    C_AuthDomainBasicAuthCallback
-> IO (FunPtr C_AuthDomainBasicAuthCallback)
mk_AuthDomainBasicAuthCallback C_AuthDomainBasicAuthCallback
cb'' IO (FunPtr C_AuthDomainBasicAuthCallback)
-> (FunPtr C_AuthDomainBasicAuthCallback
    -> IO (GClosure C_AuthDomainBasicAuthCallback))
-> IO (GClosure C_AuthDomainBasicAuthCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AuthDomainBasicAuthCallback
-> IO (GClosure C_AuthDomainBasicAuthCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AuthDomainBasicAuthCallback` into a `C_AuthDomainBasicAuthCallback`.
wrap_AuthDomainBasicAuthCallback ::
    Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback)) ->
    AuthDomainBasicAuthCallback_WithClosures ->
    C_AuthDomainBasicAuthCallback
wrap_AuthDomainBasicAuthCallback :: Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback))
-> AuthDomainBasicAuthCallback_WithClosures
-> C_AuthDomainBasicAuthCallback
wrap_AuthDomainBasicAuthCallback funptrptr :: Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback))
funptrptr _cb :: AuthDomainBasicAuthCallback_WithClosures
_cb domain :: Ptr AuthDomainBasic
domain msg :: Ptr Message
msg username :: CString
username password :: CString
password userData :: Ptr ()
userData = do
    AuthDomainBasic
domain' <- ((ManagedPtr AuthDomainBasic -> AuthDomainBasic)
-> Ptr AuthDomainBasic -> IO AuthDomainBasic
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr AuthDomainBasic -> AuthDomainBasic
Soup.AuthDomainBasic.AuthDomainBasic) Ptr AuthDomainBasic
domain
    Message
msg' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
msg
    Text
username' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
username
    Text
password' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
password
    Bool
result <- AuthDomainBasicAuthCallback_WithClosures
_cb  AuthDomainBasic
domain' Message
msg' Text
username' Text
password' Ptr ()
userData
    Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback))
funptrptr
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- callback AddressCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "addr", argType = TInterface (Name {namespace = "Soup", name = "Address"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupAddress that was resolved", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "status", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%SOUP_STATUS_OK, %SOUP_STATUS_CANT_RESOLVE, or\n%SOUP_STATUS_CANCELLED", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the user data that was passed to\nsoup_address_resolve_async()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The callback function passed to soup_address_resolve_async().", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_AddressCallback =
    Ptr Soup.Address.Address ->
    Word32 ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "addr"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Address" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupAddress that was resolved"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "status"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%SOUP_STATUS_OK, %SOUP_STATUS_CANT_RESOLVE, or\n%SOUP_STATUS_CANCELLED"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the user data that was passed to\nsoup_address_resolve_async()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_AddressCallback :: FunPtr C_AddressCallback -> C_AddressCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_AddressCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Address.IsAddress a) =>
    FunPtr C_AddressCallback
    -> a
    -- ^ /@addr@/: the t'GI.Soup.Objects.Address.Address' that was resolved
    -> Word32
    -- ^ /@status@/: 'GI.Soup.Enums.StatusOk', 'GI.Soup.Enums.StatusCantResolve', or
    -- 'GI.Soup.Enums.StatusCancelled'
    -> Ptr ()
    -- ^ /@userData@/: the user data that was passed to
    -- 'GI.Soup.Objects.Address.addressResolveAsync'
    -> m ()
dynamic_AddressCallback :: FunPtr C_AddressCallback -> a -> Word32 -> Ptr () -> m ()
dynamic_AddressCallback __funPtr :: FunPtr C_AddressCallback
__funPtr addr :: a
addr status :: Word32
status userData :: Ptr ()
userData = 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 Address
addr' <- a -> IO (Ptr Address)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
addr
    (FunPtr C_AddressCallback -> C_AddressCallback
__dynamic_C_AddressCallback FunPtr C_AddressCallback
__funPtr) Ptr Address
addr' Word32
status Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
addr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | The callback function passed to 'GI.Soup.Objects.Address.addressResolveAsync'.
type AddressCallback =
    Soup.Address.Address
    -- ^ /@addr@/: the t'GI.Soup.Objects.Address.Address' that was resolved
    -> Word32
    -- ^ /@status@/: 'GI.Soup.Enums.StatusOk', 'GI.Soup.Enums.StatusCantResolve', or
    -- 'GI.Soup.Enums.StatusCancelled'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AddressCallback`@.
noAddressCallback :: Maybe AddressCallback
noAddressCallback :: Maybe AddressCallback
noAddressCallback = Maybe AddressCallback
forall a. Maybe a
Nothing

-- | The callback function passed to 'GI.Soup.Objects.Address.addressResolveAsync'.
type AddressCallback_WithClosures =
    Soup.Address.Address
    -- ^ /@addr@/: the t'GI.Soup.Objects.Address.Address' that was resolved
    -> Word32
    -- ^ /@status@/: 'GI.Soup.Enums.StatusOk', 'GI.Soup.Enums.StatusCantResolve', or
    -- 'GI.Soup.Enums.StatusCancelled'
    -> Ptr ()
    -- ^ /@userData@/: the user data that was passed to
    -- 'GI.Soup.Objects.Address.addressResolveAsync'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AddressCallback_WithClosures`@.
noAddressCallback_WithClosures :: Maybe AddressCallback_WithClosures
noAddressCallback_WithClosures :: Maybe AddressCallback_WithClosures
noAddressCallback_WithClosures = Maybe AddressCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AddressCallback :: AddressCallback -> AddressCallback_WithClosures
drop_closures_AddressCallback :: AddressCallback -> AddressCallback_WithClosures
drop_closures_AddressCallback _f :: AddressCallback
_f addr :: Address
addr status :: Word32
status _ = AddressCallback
_f Address
addr Word32
status

-- | Wrap the callback into a `GClosure`.
genClosure_AddressCallback :: MonadIO m => AddressCallback -> m (GClosure C_AddressCallback)
genClosure_AddressCallback :: AddressCallback -> m (GClosure C_AddressCallback)
genClosure_AddressCallback cb :: AddressCallback
cb = IO (GClosure C_AddressCallback) -> m (GClosure C_AddressCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AddressCallback) -> m (GClosure C_AddressCallback))
-> IO (GClosure C_AddressCallback)
-> m (GClosure C_AddressCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: AddressCallback_WithClosures
cb' = AddressCallback -> AddressCallback_WithClosures
drop_closures_AddressCallback AddressCallback
cb
    let cb'' :: C_AddressCallback
cb'' = Maybe (Ptr (FunPtr C_AddressCallback))
-> AddressCallback_WithClosures -> C_AddressCallback
wrap_AddressCallback Maybe (Ptr (FunPtr C_AddressCallback))
forall a. Maybe a
Nothing AddressCallback_WithClosures
cb'
    C_AddressCallback -> IO (FunPtr C_AddressCallback)
mk_AddressCallback C_AddressCallback
cb'' IO (FunPtr C_AddressCallback)
-> (FunPtr C_AddressCallback -> IO (GClosure C_AddressCallback))
-> IO (GClosure C_AddressCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AddressCallback -> IO (GClosure C_AddressCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AddressCallback` into a `C_AddressCallback`.
wrap_AddressCallback ::
    Maybe (Ptr (FunPtr C_AddressCallback)) ->
    AddressCallback_WithClosures ->
    C_AddressCallback
wrap_AddressCallback :: Maybe (Ptr (FunPtr C_AddressCallback))
-> AddressCallback_WithClosures -> C_AddressCallback
wrap_AddressCallback funptrptr :: Maybe (Ptr (FunPtr C_AddressCallback))
funptrptr _cb :: AddressCallback_WithClosures
_cb addr :: Ptr Address
addr status :: Word32
status userData :: Ptr ()
userData = do
    Address
addr' <- ((ManagedPtr Address -> Address) -> Ptr Address -> IO Address
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Address -> Address
Soup.Address.Address) Ptr Address
addr
    AddressCallback_WithClosures
_cb  Address
addr' Word32
status Ptr ()
userData
    Maybe (Ptr (FunPtr C_AddressCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AddressCallback))
funptrptr