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

module GI.Soup.Objects.Logger
    ( 

-- * Exported types
    Logger(..)                              ,
    IsLogger                                ,
    toLogger                                ,
    noLogger                                ,


 -- * Methods
-- ** attach #method:attach#
    LoggerAttachMethodInfo                  ,
    loggerAttach                            ,


-- ** detach #method:detach#
    LoggerDetachMethodInfo                  ,
    loggerDetach                            ,


-- ** new #method:new#
    loggerNew                               ,


-- ** setPrinter #method:setPrinter#
    LoggerSetPrinterMethodInfo              ,
    loggerSetPrinter                        ,


-- ** setRequestFilter #method:setRequestFilter#
    LoggerSetRequestFilterMethodInfo        ,
    loggerSetRequestFilter                  ,


-- ** setResponseFilter #method:setResponseFilter#
    LoggerSetResponseFilterMethodInfo       ,
    loggerSetResponseFilter                 ,




 -- * Properties
-- ** level #attr:level#
    LoggerLevelPropertyInfo                 ,
    constructLoggerLevel                    ,
    getLoggerLevel                          ,
    loggerLevel                             ,
    setLoggerLevel                          ,


-- ** maxBodySize #attr:maxBodySize#
    LoggerMaxBodySizePropertyInfo           ,
    constructLoggerMaxBodySize              ,
    getLoggerMaxBodySize                    ,
    loggerMaxBodySize                       ,
    setLoggerMaxBodySize                    ,




    ) where

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

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

import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Soup.Callbacks as Soup.Callbacks
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
import {-# SOURCE #-} qualified GI.Soup.Objects.Session as Soup.Session

newtype Logger = Logger (ManagedPtr Logger)
foreign import ccall "soup_logger_get_type"
    c_soup_logger_get_type :: IO GType

instance GObject Logger where
    gobjectType _ = c_soup_logger_get_type
    

class GObject o => IsLogger o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Logger a) =>
    IsLogger a
#endif
instance IsLogger Logger
instance GObject.Object.IsObject Logger
instance Soup.SessionFeature.IsSessionFeature Logger

toLogger :: IsLogger o => o -> IO Logger
toLogger = unsafeCastTo Logger

noLogger :: Maybe Logger
noLogger = Nothing

type family ResolveLoggerMethod (t :: Symbol) (o :: *) :: * where
    ResolveLoggerMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
    ResolveLoggerMethod "attach" o = LoggerAttachMethodInfo
    ResolveLoggerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveLoggerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveLoggerMethod "detach" o = LoggerDetachMethodInfo
    ResolveLoggerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveLoggerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveLoggerMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
    ResolveLoggerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveLoggerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveLoggerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveLoggerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveLoggerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveLoggerMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
    ResolveLoggerMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveLoggerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveLoggerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveLoggerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveLoggerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveLoggerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveLoggerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveLoggerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveLoggerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveLoggerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveLoggerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveLoggerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveLoggerMethod "setPrinter" o = LoggerSetPrinterMethodInfo
    ResolveLoggerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveLoggerMethod "setRequestFilter" o = LoggerSetRequestFilterMethodInfo
    ResolveLoggerMethod "setResponseFilter" o = LoggerSetResponseFilterMethodInfo
    ResolveLoggerMethod l o = O.MethodResolutionFailed l o

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

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

-- VVV Prop "level"
   -- Type: TInterface (Name {namespace = "Soup", name = "LoggerLogLevel"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getLoggerLevel :: (MonadIO m, IsLogger o) => o -> m Soup.Enums.LoggerLogLevel
getLoggerLevel obj = liftIO $ getObjectPropertyEnum obj "level"

setLoggerLevel :: (MonadIO m, IsLogger o) => o -> Soup.Enums.LoggerLogLevel -> m ()
setLoggerLevel obj val = liftIO $ setObjectPropertyEnum obj "level" val

constructLoggerLevel :: (IsLogger o) => Soup.Enums.LoggerLogLevel -> IO (GValueConstruct o)
constructLoggerLevel val = constructObjectPropertyEnum "level" val

data LoggerLevelPropertyInfo
instance AttrInfo LoggerLevelPropertyInfo where
    type AttrAllowedOps LoggerLevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LoggerLevelPropertyInfo = (~) Soup.Enums.LoggerLogLevel
    type AttrBaseTypeConstraint LoggerLevelPropertyInfo = IsLogger
    type AttrGetType LoggerLevelPropertyInfo = Soup.Enums.LoggerLogLevel
    type AttrLabel LoggerLevelPropertyInfo = "level"
    type AttrOrigin LoggerLevelPropertyInfo = Logger
    attrGet _ = getLoggerLevel
    attrSet _ = setLoggerLevel
    attrConstruct _ = constructLoggerLevel
    attrClear _ = undefined

-- VVV Prop "max-body-size"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getLoggerMaxBodySize :: (MonadIO m, IsLogger o) => o -> m Int32
getLoggerMaxBodySize obj = liftIO $ getObjectPropertyInt32 obj "max-body-size"

setLoggerMaxBodySize :: (MonadIO m, IsLogger o) => o -> Int32 -> m ()
setLoggerMaxBodySize obj val = liftIO $ setObjectPropertyInt32 obj "max-body-size" val

constructLoggerMaxBodySize :: (IsLogger o) => Int32 -> IO (GValueConstruct o)
constructLoggerMaxBodySize val = constructObjectPropertyInt32 "max-body-size" val

data LoggerMaxBodySizePropertyInfo
instance AttrInfo LoggerMaxBodySizePropertyInfo where
    type AttrAllowedOps LoggerMaxBodySizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LoggerMaxBodySizePropertyInfo = (~) Int32
    type AttrBaseTypeConstraint LoggerMaxBodySizePropertyInfo = IsLogger
    type AttrGetType LoggerMaxBodySizePropertyInfo = Int32
    type AttrLabel LoggerMaxBodySizePropertyInfo = "max-body-size"
    type AttrOrigin LoggerMaxBodySizePropertyInfo = Logger
    attrGet _ = getLoggerMaxBodySize
    attrSet _ = setLoggerMaxBodySize
    attrConstruct _ = constructLoggerMaxBodySize
    attrClear _ = undefined

instance O.HasAttributeList Logger
type instance O.AttributeList Logger = LoggerAttributeList
type LoggerAttributeList = ('[ '("level", LoggerLevelPropertyInfo), '("maxBodySize", LoggerMaxBodySizePropertyInfo)] :: [(Symbol, *)])

loggerLevel :: AttrLabelProxy "level"
loggerLevel = AttrLabelProxy

loggerMaxBodySize :: AttrLabelProxy "maxBodySize"
loggerMaxBodySize = AttrLabelProxy

type instance O.SignalList Logger = LoggerSignalList
type LoggerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method Logger::new
-- method type : Constructor
-- Args : [Arg {argCName = "level", argType = TInterface (Name {namespace = "Soup", name = "LoggerLogLevel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the debug level", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_body_size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum body size to output, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Logger"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_logger_new" soup_logger_new :: 
    CUInt ->                                -- level : TInterface (Name {namespace = "Soup", name = "LoggerLogLevel"})
    Int32 ->                                -- max_body_size : TBasicType TInt
    IO (Ptr Logger)

{- |
Creates a new 'GI.Soup.Objects.Logger.Logger' with the given debug level. If /@level@/ is
'GI.Soup.Enums.LoggerLogLevelBody', /@maxBodySize@/ gives the maximum number of
bytes of the body that will be logged. (-1 means \"no limit\".)

If you need finer control over what message parts are and aren\'t
logged, use 'GI.Soup.Objects.Logger.loggerSetRequestFilter' and
'GI.Soup.Objects.Logger.loggerSetResponseFilter'.
-}
loggerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Soup.Enums.LoggerLogLevel
    {- ^ /@level@/: the debug level -}
    -> Int32
    {- ^ /@maxBodySize@/: the maximum body size to output, or -1 -}
    -> m Logger
    {- ^ __Returns:__ a new 'GI.Soup.Objects.Logger.Logger' -}
loggerNew level maxBodySize = liftIO $ do
    let level' = (fromIntegral . fromEnum) level
    result <- soup_logger_new level' maxBodySize
    checkUnexpectedReturnNULL "loggerNew" result
    result' <- (wrapObject Logger) result
    return result'

-- method Logger::attach
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "logger", argType = TInterface (Name {namespace = "Soup", name = "Logger"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupLogger", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "session", argType = TInterface (Name {namespace = "Soup", name = "Session"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupSession", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_logger_attach" soup_logger_attach :: 
    Ptr Logger ->                           -- logger : TInterface (Name {namespace = "Soup", name = "Logger"})
    Ptr Soup.Session.Session ->             -- session : TInterface (Name {namespace = "Soup", name = "Session"})
    IO ()

{-# DEPRECATED loggerAttach ["Use 'GI.Soup.Objects.Session.sessionAddFeature' instead."] #-}
{- |
Sets /@logger@/ to watch /@session@/ and print debug information for
its messages.

(The session will take a reference on /@logger@/, which will be
removed when you call 'GI.Soup.Objects.Logger.loggerDetach', or when the session is
destroyed.)
-}
loggerAttach ::
    (B.CallStack.HasCallStack, MonadIO m, IsLogger a, Soup.Session.IsSession b) =>
    a
    {- ^ /@logger@/: a 'GI.Soup.Objects.Logger.Logger' -}
    -> b
    {- ^ /@session@/: a 'GI.Soup.Objects.Session.Session' -}
    -> m ()
loggerAttach logger session = liftIO $ do
    logger' <- unsafeManagedPtrCastPtr logger
    session' <- unsafeManagedPtrCastPtr session
    soup_logger_attach logger' session'
    touchManagedPtr logger
    touchManagedPtr session
    return ()

data LoggerAttachMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsLogger a, Soup.Session.IsSession b) => O.MethodInfo LoggerAttachMethodInfo a signature where
    overloadedMethod _ = loggerAttach

-- method Logger::detach
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "logger", argType = TInterface (Name {namespace = "Soup", name = "Logger"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupLogger", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "session", argType = TInterface (Name {namespace = "Soup", name = "Session"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupSession", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_logger_detach" soup_logger_detach :: 
    Ptr Logger ->                           -- logger : TInterface (Name {namespace = "Soup", name = "Logger"})
    Ptr Soup.Session.Session ->             -- session : TInterface (Name {namespace = "Soup", name = "Session"})
    IO ()

{-# DEPRECATED loggerDetach ["Use 'GI.Soup.Objects.Session.sessionRemoveFeature' instead."] #-}
{- |
Stops /@logger@/ from watching /@session@/.
-}
loggerDetach ::
    (B.CallStack.HasCallStack, MonadIO m, IsLogger a, Soup.Session.IsSession b) =>
    a
    {- ^ /@logger@/: a 'GI.Soup.Objects.Logger.Logger' -}
    -> b
    {- ^ /@session@/: a 'GI.Soup.Objects.Session.Session' -}
    -> m ()
loggerDetach logger session = liftIO $ do
    logger' <- unsafeManagedPtrCastPtr logger
    session' <- unsafeManagedPtrCastPtr session
    soup_logger_detach logger' session'
    touchManagedPtr logger
    touchManagedPtr session
    return ()

data LoggerDetachMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsLogger a, Soup.Session.IsSession b) => O.MethodInfo LoggerDetachMethodInfo a signature where
    overloadedMethod _ = loggerDetach

-- method Logger::set_printer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "logger", argType = TInterface (Name {namespace = "Soup", name = "Logger"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupLogger", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "printer", argType = TInterface (Name {namespace = "Soup", name = "LoggerPrinter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the callback for printing logging output", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "printer_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDestroyNotify to free @printer_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_logger_set_printer" soup_logger_set_printer :: 
    Ptr Logger ->                           -- logger : TInterface (Name {namespace = "Soup", name = "Logger"})
    FunPtr Soup.Callbacks.C_LoggerPrinter -> -- printer : TInterface (Name {namespace = "Soup", name = "LoggerPrinter"})
    Ptr () ->                               -- printer_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets up an alternate log printing routine, if you don\'t want
the log to go to \<literal>stdout\<\/literal>.
-}
loggerSetPrinter ::
    (B.CallStack.HasCallStack, MonadIO m, IsLogger a) =>
    a
    {- ^ /@logger@/: a 'GI.Soup.Objects.Logger.Logger' -}
    -> Soup.Callbacks.LoggerPrinter
    {- ^ /@printer@/: the callback for printing logging output -}
    -> m ()
loggerSetPrinter logger printer = liftIO $ do
    logger' <- unsafeManagedPtrCastPtr logger
    printer' <- Soup.Callbacks.mk_LoggerPrinter (Soup.Callbacks.wrap_LoggerPrinter Nothing (Soup.Callbacks.drop_closures_LoggerPrinter printer))
    let printerData = castFunPtrToPtr printer'
    let destroy = safeFreeFunPtrPtr
    soup_logger_set_printer logger' printer' printerData destroy
    touchManagedPtr logger
    return ()

data LoggerSetPrinterMethodInfo
instance (signature ~ (Soup.Callbacks.LoggerPrinter -> m ()), MonadIO m, IsLogger a) => O.MethodInfo LoggerSetPrinterMethodInfo a signature where
    overloadedMethod _ = loggerSetPrinter

-- method Logger::set_request_filter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "logger", argType = TInterface (Name {namespace = "Soup", name = "Logger"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupLogger", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "request_filter", argType = TInterface (Name {namespace = "Soup", name = "LoggerFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the callback for request debugging", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDestroyNotify to free @filter_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_logger_set_request_filter" soup_logger_set_request_filter :: 
    Ptr Logger ->                           -- logger : TInterface (Name {namespace = "Soup", name = "Logger"})
    FunPtr Soup.Callbacks.C_LoggerFilter -> -- request_filter : TInterface (Name {namespace = "Soup", name = "LoggerFilter"})
    Ptr () ->                               -- filter_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets up a filter to determine the log level for a given request.
For each HTTP request /@logger@/ will invoke /@requestFilter@/ to
determine how much (if any) of that request to log. (If you do not
set a request filter, /@logger@/ will just always log requests at the
level passed to 'GI.Soup.Objects.Logger.loggerNew'.)
-}
loggerSetRequestFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsLogger a) =>
    a
    {- ^ /@logger@/: a 'GI.Soup.Objects.Logger.Logger' -}
    -> Soup.Callbacks.LoggerFilter
    {- ^ /@requestFilter@/: the callback for request debugging -}
    -> m ()
loggerSetRequestFilter logger requestFilter = liftIO $ do
    logger' <- unsafeManagedPtrCastPtr logger
    requestFilter' <- Soup.Callbacks.mk_LoggerFilter (Soup.Callbacks.wrap_LoggerFilter Nothing (Soup.Callbacks.drop_closures_LoggerFilter requestFilter))
    let filterData = castFunPtrToPtr requestFilter'
    let destroy = safeFreeFunPtrPtr
    soup_logger_set_request_filter logger' requestFilter' filterData destroy
    touchManagedPtr logger
    return ()

data LoggerSetRequestFilterMethodInfo
instance (signature ~ (Soup.Callbacks.LoggerFilter -> m ()), MonadIO m, IsLogger a) => O.MethodInfo LoggerSetRequestFilterMethodInfo a signature where
    overloadedMethod _ = loggerSetRequestFilter

-- method Logger::set_response_filter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "logger", argType = TInterface (Name {namespace = "Soup", name = "Logger"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupLogger", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "response_filter", argType = TInterface (Name {namespace = "Soup", name = "LoggerFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the callback for response debugging", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDestroyNotify to free @filter_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_logger_set_response_filter" soup_logger_set_response_filter :: 
    Ptr Logger ->                           -- logger : TInterface (Name {namespace = "Soup", name = "Logger"})
    FunPtr Soup.Callbacks.C_LoggerFilter -> -- response_filter : TInterface (Name {namespace = "Soup", name = "LoggerFilter"})
    Ptr () ->                               -- filter_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets up a filter to determine the log level for a given response.
For each HTTP response /@logger@/ will invoke /@responseFilter@/ to
determine how much (if any) of that response to log. (If you do not
set a response filter, /@logger@/ will just always log responses at
the level passed to 'GI.Soup.Objects.Logger.loggerNew'.)
-}
loggerSetResponseFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsLogger a) =>
    a
    {- ^ /@logger@/: a 'GI.Soup.Objects.Logger.Logger' -}
    -> Soup.Callbacks.LoggerFilter
    {- ^ /@responseFilter@/: the callback for response debugging -}
    -> m ()
loggerSetResponseFilter logger responseFilter = liftIO $ do
    logger' <- unsafeManagedPtrCastPtr logger
    responseFilter' <- Soup.Callbacks.mk_LoggerFilter (Soup.Callbacks.wrap_LoggerFilter Nothing (Soup.Callbacks.drop_closures_LoggerFilter responseFilter))
    let filterData = castFunPtrToPtr responseFilter'
    let destroy = safeFreeFunPtrPtr
    soup_logger_set_response_filter logger' responseFilter' filterData destroy
    touchManagedPtr logger
    return ()

data LoggerSetResponseFilterMethodInfo
instance (signature ~ (Soup.Callbacks.LoggerFilter -> m ()), MonadIO m, IsLogger a) => O.MethodInfo LoggerSetResponseFilterMethodInfo a signature where
    overloadedMethod _ = loggerSetResponseFilter