{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Objects.Logger
(
Logger(..) ,
IsLogger ,
toLogger ,
#if defined(ENABLE_OVERLOADING)
ResolveLoggerMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
LoggerAttachMethodInfo ,
#endif
loggerAttach ,
#if defined(ENABLE_OVERLOADING)
LoggerDetachMethodInfo ,
#endif
loggerDetach ,
loggerNew ,
#if defined(ENABLE_OVERLOADING)
LoggerSetPrinterMethodInfo ,
#endif
loggerSetPrinter ,
#if defined(ENABLE_OVERLOADING)
LoggerSetRequestFilterMethodInfo ,
#endif
loggerSetRequestFilter ,
#if defined(ENABLE_OVERLOADING)
LoggerSetResponseFilterMethodInfo ,
#endif
loggerSetResponseFilter ,
#if defined(ENABLE_OVERLOADING)
LoggerLevelPropertyInfo ,
#endif
constructLoggerLevel ,
getLoggerLevel ,
#if defined(ENABLE_OVERLOADING)
loggerLevel ,
#endif
setLoggerLevel ,
#if defined(ENABLE_OVERLOADING)
LoggerMaxBodySizePropertyInfo ,
#endif
constructLoggerMaxBodySize ,
getLoggerMaxBodySize ,
#if defined(ENABLE_OVERLOADING)
loggerMaxBodySize ,
#endif
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.BasicTypes as B.Types
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 Control.Monad.IO.Class as MIO
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.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 (SP.ManagedPtr Logger)
deriving (Logger -> Logger -> Bool
(Logger -> Logger -> Bool)
-> (Logger -> Logger -> Bool) -> Eq Logger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Logger -> Logger -> Bool
$c/= :: Logger -> Logger -> Bool
== :: Logger -> Logger -> Bool
$c== :: Logger -> Logger -> Bool
Eq)
instance SP.ManagedPtrNewtype Logger where
toManagedPtr :: Logger -> ManagedPtr Logger
toManagedPtr (Logger ManagedPtr Logger
p) = ManagedPtr Logger
p
foreign import ccall "soup_logger_get_type"
c_soup_logger_get_type :: IO B.Types.GType
instance B.Types.TypedObject Logger where
glibType :: IO GType
glibType = IO GType
c_soup_logger_get_type
instance B.Types.GObject Logger
instance B.GValue.IsGValue Logger where
toGValue :: Logger -> IO GValue
toGValue Logger
o = do
GType
gtype <- IO GType
c_soup_logger_get_type
Logger -> (Ptr Logger -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Logger
o (GType -> (GValue -> Ptr Logger -> IO ()) -> Ptr Logger -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Logger -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Logger
fromGValue GValue
gv = do
Ptr Logger
ptr <- GValue -> IO (Ptr Logger)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Logger)
(ManagedPtr Logger -> Logger) -> Ptr Logger -> IO Logger
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Logger -> Logger
Logger Ptr Logger
ptr
class (SP.GObject o, O.IsDescendantOf Logger o) => IsLogger o
instance (SP.GObject o, O.IsDescendantOf Logger o) => IsLogger o
instance O.HasParentTypes Logger
type instance O.ParentTypes Logger = '[GObject.Object.Object, Soup.SessionFeature.SessionFeature]
toLogger :: (MonadIO m, IsLogger o) => o -> m Logger
toLogger :: o -> m Logger
toLogger = IO Logger -> m Logger
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Logger -> m Logger) -> (o -> IO Logger) -> o -> m Logger
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Logger -> Logger) -> o -> IO Logger
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Logger -> Logger
Logger
#if defined(ENABLE_OVERLOADING)
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
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 "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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
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) => OL.IsLabel t (Logger -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
getLoggerLevel :: (MonadIO m, IsLogger o) => o -> m Soup.Enums.LoggerLogLevel
getLoggerLevel :: o -> m LoggerLogLevel
getLoggerLevel o
obj = 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
$ o -> String -> IO LoggerLogLevel
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"level"
setLoggerLevel :: (MonadIO m, IsLogger o) => o -> Soup.Enums.LoggerLogLevel -> m ()
setLoggerLevel :: o -> LoggerLogLevel -> m ()
setLoggerLevel o
obj LoggerLogLevel
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> LoggerLogLevel -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"level" LoggerLogLevel
val
constructLoggerLevel :: (IsLogger o, MIO.MonadIO m) => Soup.Enums.LoggerLogLevel -> m (GValueConstruct o)
constructLoggerLevel :: LoggerLogLevel -> m (GValueConstruct o)
constructLoggerLevel LoggerLogLevel
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> LoggerLogLevel -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"level" LoggerLogLevel
val
#if defined(ENABLE_OVERLOADING)
data LoggerLevelPropertyInfo
instance AttrInfo LoggerLevelPropertyInfo where
type AttrAllowedOps LoggerLevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint LoggerLevelPropertyInfo = IsLogger
type AttrSetTypeConstraint LoggerLevelPropertyInfo = (~) Soup.Enums.LoggerLogLevel
type AttrTransferTypeConstraint LoggerLevelPropertyInfo = (~) Soup.Enums.LoggerLogLevel
type AttrTransferType LoggerLevelPropertyInfo = Soup.Enums.LoggerLogLevel
type AttrGetType LoggerLevelPropertyInfo = Soup.Enums.LoggerLogLevel
type AttrLabel LoggerLevelPropertyInfo = "level"
type AttrOrigin LoggerLevelPropertyInfo = Logger
attrGet = getLoggerLevel
attrSet = setLoggerLevel
attrTransfer _ v = do
return v
attrConstruct = constructLoggerLevel
attrClear = undefined
#endif
getLoggerMaxBodySize :: (MonadIO m, IsLogger o) => o -> m Int32
getLoggerMaxBodySize :: o -> m Int32
getLoggerMaxBodySize o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"max-body-size"
setLoggerMaxBodySize :: (MonadIO m, IsLogger o) => o -> Int32 -> m ()
setLoggerMaxBodySize :: o -> Int32 -> m ()
setLoggerMaxBodySize o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"max-body-size" Int32
val
constructLoggerMaxBodySize :: (IsLogger o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructLoggerMaxBodySize :: Int32 -> m (GValueConstruct o)
constructLoggerMaxBodySize Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"max-body-size" Int32
val
#if defined(ENABLE_OVERLOADING)
data LoggerMaxBodySizePropertyInfo
instance AttrInfo LoggerMaxBodySizePropertyInfo where
type AttrAllowedOps LoggerMaxBodySizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint LoggerMaxBodySizePropertyInfo = IsLogger
type AttrSetTypeConstraint LoggerMaxBodySizePropertyInfo = (~) Int32
type AttrTransferTypeConstraint LoggerMaxBodySizePropertyInfo = (~) Int32
type AttrTransferType LoggerMaxBodySizePropertyInfo = Int32
type AttrGetType LoggerMaxBodySizePropertyInfo = Int32
type AttrLabel LoggerMaxBodySizePropertyInfo = "max-body-size"
type AttrOrigin LoggerMaxBodySizePropertyInfo = Logger
attrGet = getLoggerMaxBodySize
attrSet = setLoggerMaxBodySize
attrTransfer _ v = do
return v
attrConstruct = constructLoggerMaxBodySize
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Logger
type instance O.AttributeList Logger = LoggerAttributeList
type LoggerAttributeList = ('[ '("level", LoggerLevelPropertyInfo), '("maxBodySize", LoggerMaxBodySizePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
loggerLevel :: AttrLabelProxy "level"
loggerLevel = AttrLabelProxy
loggerMaxBodySize :: AttrLabelProxy "maxBodySize"
loggerMaxBodySize = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Logger = LoggerSignalList
type LoggerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_logger_new" soup_logger_new ::
CUInt ->
Int32 ->
IO (Ptr Logger)
loggerNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Soup.Enums.LoggerLogLevel
-> Int32
-> m Logger
loggerNew :: LoggerLogLevel -> Int32 -> m Logger
loggerNew LoggerLogLevel
level Int32
maxBodySize = IO Logger -> m Logger
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Logger -> m Logger) -> IO Logger -> m Logger
forall a b. (a -> b) -> a -> b
$ do
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
Ptr Logger
result <- CUInt -> Int32 -> IO (Ptr Logger)
soup_logger_new CUInt
level' Int32
maxBodySize
Text -> Ptr Logger -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"loggerNew" Ptr Logger
result
Logger
result' <- ((ManagedPtr Logger -> Logger) -> Ptr Logger -> IO Logger
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Logger -> Logger
Logger) Ptr Logger
result
Logger -> IO Logger
forall (m :: * -> *) a. Monad m => a -> m a
return Logger
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_logger_attach" soup_logger_attach ::
Ptr Logger ->
Ptr Soup.Session.Session ->
IO ()
{-# DEPRECATED loggerAttach ["Use 'GI.Soup.Objects.Session.sessionAddFeature' instead."] #-}
loggerAttach ::
(B.CallStack.HasCallStack, MonadIO m, IsLogger a, Soup.Session.IsSession b) =>
a
-> b
-> m ()
loggerAttach :: a -> b -> m ()
loggerAttach a
logger b
session = 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
Ptr Session
session' <- b -> IO (Ptr Session)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
session
Ptr Logger -> Ptr Session -> IO ()
soup_logger_attach Ptr Logger
logger' Ptr Session
session'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
logger
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
session
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LoggerAttachMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsLogger a, Soup.Session.IsSession b) => O.MethodInfo LoggerAttachMethodInfo a signature where
overloadedMethod = loggerAttach
#endif
foreign import ccall "soup_logger_detach" soup_logger_detach ::
Ptr Logger ->
Ptr Soup.Session.Session ->
IO ()
{-# DEPRECATED loggerDetach ["Use 'GI.Soup.Objects.Session.sessionRemoveFeature' instead."] #-}
loggerDetach ::
(B.CallStack.HasCallStack, MonadIO m, IsLogger a, Soup.Session.IsSession b) =>
a
-> b
-> m ()
loggerDetach :: a -> b -> m ()
loggerDetach a
logger b
session = 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
Ptr Session
session' <- b -> IO (Ptr Session)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
session
Ptr Logger -> Ptr Session -> IO ()
soup_logger_detach Ptr Logger
logger' Ptr Session
session'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
logger
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
session
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LoggerDetachMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsLogger a, Soup.Session.IsSession b) => O.MethodInfo LoggerDetachMethodInfo a signature where
overloadedMethod = loggerDetach
#endif
foreign import ccall "soup_logger_set_printer" soup_logger_set_printer ::
Ptr Logger ->
FunPtr Soup.Callbacks.C_LoggerPrinter ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
loggerSetPrinter ::
(B.CallStack.HasCallStack, MonadIO m, IsLogger a) =>
a
-> Soup.Callbacks.LoggerPrinter
-> m ()
loggerSetPrinter :: a -> LoggerPrinter -> m ()
loggerSetPrinter a
logger LoggerPrinter
printer = 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
FunPtr C_LoggerPrinter
printer' <- C_LoggerPrinter -> IO (FunPtr C_LoggerPrinter)
Soup.Callbacks.mk_LoggerPrinter (Maybe (Ptr (FunPtr C_LoggerPrinter))
-> LoggerPrinter_WithClosures -> C_LoggerPrinter
Soup.Callbacks.wrap_LoggerPrinter Maybe (Ptr (FunPtr C_LoggerPrinter))
forall a. Maybe a
Nothing (LoggerPrinter -> LoggerPrinter_WithClosures
Soup.Callbacks.drop_closures_LoggerPrinter LoggerPrinter
printer))
let printerData :: Ptr ()
printerData = FunPtr C_LoggerPrinter -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_LoggerPrinter
printer'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Logger
-> FunPtr C_LoggerPrinter
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
soup_logger_set_printer Ptr Logger
logger' FunPtr C_LoggerPrinter
printer' Ptr ()
printerData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroy
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
logger
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LoggerSetPrinterMethodInfo
instance (signature ~ (Soup.Callbacks.LoggerPrinter -> m ()), MonadIO m, IsLogger a) => O.MethodInfo LoggerSetPrinterMethodInfo a signature where
overloadedMethod = loggerSetPrinter
#endif
foreign import ccall "soup_logger_set_request_filter" soup_logger_set_request_filter ::
Ptr Logger ->
FunPtr Soup.Callbacks.C_LoggerFilter ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
loggerSetRequestFilter ::
(B.CallStack.HasCallStack, MonadIO m, IsLogger a) =>
a
-> Soup.Callbacks.LoggerFilter
-> m ()
loggerSetRequestFilter :: a -> LoggerFilter -> m ()
loggerSetRequestFilter a
logger LoggerFilter
requestFilter = 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
FunPtr C_LoggerFilter
requestFilter' <- C_LoggerFilter -> IO (FunPtr C_LoggerFilter)
Soup.Callbacks.mk_LoggerFilter (Maybe (Ptr (FunPtr C_LoggerFilter))
-> LoggerFilter_WithClosures -> C_LoggerFilter
Soup.Callbacks.wrap_LoggerFilter Maybe (Ptr (FunPtr C_LoggerFilter))
forall a. Maybe a
Nothing (LoggerFilter -> LoggerFilter_WithClosures
Soup.Callbacks.drop_closures_LoggerFilter LoggerFilter
requestFilter))
let filterData :: Ptr ()
filterData = FunPtr C_LoggerFilter -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_LoggerFilter
requestFilter'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Logger
-> FunPtr C_LoggerFilter
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
soup_logger_set_request_filter Ptr Logger
logger' FunPtr C_LoggerFilter
requestFilter' Ptr ()
filterData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroy
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
logger
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LoggerSetRequestFilterMethodInfo
instance (signature ~ (Soup.Callbacks.LoggerFilter -> m ()), MonadIO m, IsLogger a) => O.MethodInfo LoggerSetRequestFilterMethodInfo a signature where
overloadedMethod = loggerSetRequestFilter
#endif
foreign import ccall "soup_logger_set_response_filter" soup_logger_set_response_filter ::
Ptr Logger ->
FunPtr Soup.Callbacks.C_LoggerFilter ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
loggerSetResponseFilter ::
(B.CallStack.HasCallStack, MonadIO m, IsLogger a) =>
a
-> Soup.Callbacks.LoggerFilter
-> m ()
loggerSetResponseFilter :: a -> LoggerFilter -> m ()
loggerSetResponseFilter a
logger LoggerFilter
responseFilter = 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
FunPtr C_LoggerFilter
responseFilter' <- C_LoggerFilter -> IO (FunPtr C_LoggerFilter)
Soup.Callbacks.mk_LoggerFilter (Maybe (Ptr (FunPtr C_LoggerFilter))
-> LoggerFilter_WithClosures -> C_LoggerFilter
Soup.Callbacks.wrap_LoggerFilter Maybe (Ptr (FunPtr C_LoggerFilter))
forall a. Maybe a
Nothing (LoggerFilter -> LoggerFilter_WithClosures
Soup.Callbacks.drop_closures_LoggerFilter LoggerFilter
responseFilter))
let filterData :: Ptr ()
filterData = FunPtr C_LoggerFilter -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_LoggerFilter
responseFilter'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Logger
-> FunPtr C_LoggerFilter
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
soup_logger_set_response_filter Ptr Logger
logger' FunPtr C_LoggerFilter
responseFilter' Ptr ()
filterData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroy
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
logger
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LoggerSetResponseFilterMethodInfo
instance (signature ~ (Soup.Callbacks.LoggerFilter -> m ()), MonadIO m, IsLogger a) => O.MethodInfo LoggerSetResponseFilterMethodInfo a signature where
overloadedMethod = loggerSetResponseFilter
#endif