#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Soup.Objects.Logger
(
Logger(..) ,
IsLogger ,
toLogger ,
noLogger ,
#if ENABLE_OVERLOADING
LoggerAttachMethodInfo ,
#endif
loggerAttach ,
#if ENABLE_OVERLOADING
LoggerDetachMethodInfo ,
#endif
loggerDetach ,
loggerNew ,
#if ENABLE_OVERLOADING
LoggerSetPrinterMethodInfo ,
#endif
loggerSetPrinter ,
#if ENABLE_OVERLOADING
LoggerSetRequestFilterMethodInfo ,
#endif
loggerSetRequestFilter ,
#if ENABLE_OVERLOADING
LoggerSetResponseFilterMethodInfo ,
#endif
loggerSetResponseFilter ,
#if ENABLE_OVERLOADING
LoggerLevelPropertyInfo ,
#endif
constructLoggerLevel ,
getLoggerLevel ,
#if ENABLE_OVERLOADING
loggerLevel ,
#endif
setLoggerLevel ,
#if ENABLE_OVERLOADING
LoggerMaxBodySizePropertyInfo ,
#endif
constructLoggerMaxBodySize ,
getLoggerMaxBodySize ,
#if 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.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, O.IsDescendantOf Logger o) => IsLogger o
instance (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 = liftIO . unsafeCastTo Logger
noLogger :: Maybe Logger
noLogger = Nothing
#if 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 (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
getLoggerLevel :: (MonadIO m, IsLogger o) => o -> m Soup.Enums.LoggerLogLevel
getLoggerLevel obj = liftIO $ B.Properties.getObjectPropertyEnum obj "level"
setLoggerLevel :: (MonadIO m, IsLogger o) => o -> Soup.Enums.LoggerLogLevel -> m ()
setLoggerLevel obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "level" val
constructLoggerLevel :: (IsLogger o) => Soup.Enums.LoggerLogLevel -> IO (GValueConstruct o)
constructLoggerLevel val = B.Properties.constructObjectPropertyEnum "level" val
#if ENABLE_OVERLOADING
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
#endif
getLoggerMaxBodySize :: (MonadIO m, IsLogger o) => o -> m Int32
getLoggerMaxBodySize obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "max-body-size"
setLoggerMaxBodySize :: (MonadIO m, IsLogger o) => o -> Int32 -> m ()
setLoggerMaxBodySize obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "max-body-size" val
constructLoggerMaxBodySize :: (IsLogger o) => Int32 -> IO (GValueConstruct o)
constructLoggerMaxBodySize val = B.Properties.constructObjectPropertyInt32 "max-body-size" val
#if ENABLE_OVERLOADING
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
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Logger
type instance O.AttributeList Logger = LoggerAttributeList
type LoggerAttributeList = ('[ '("level", LoggerLevelPropertyInfo), '("maxBodySize", LoggerMaxBodySizePropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
loggerLevel :: AttrLabelProxy "level"
loggerLevel = AttrLabelProxy
loggerMaxBodySize :: AttrLabelProxy "maxBodySize"
loggerMaxBodySize = AttrLabelProxy
#endif
#if 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 level maxBodySize = liftIO $ do
let level' = (fromIntegral . fromEnum) level
result <- soup_logger_new level' maxBodySize
checkUnexpectedReturnNULL "loggerNew" result
result' <- (wrapObject Logger) result
return result'
#if 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 logger session = liftIO $ do
logger' <- unsafeManagedPtrCastPtr logger
session' <- unsafeManagedPtrCastPtr session
soup_logger_attach logger' session'
touchManagedPtr logger
touchManagedPtr session
return ()
#if 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 logger session = liftIO $ do
logger' <- unsafeManagedPtrCastPtr logger
session' <- unsafeManagedPtrCastPtr session
soup_logger_detach logger' session'
touchManagedPtr logger
touchManagedPtr session
return ()
#if 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 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 ()
#if 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 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 ()
#if 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 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 ()
#if ENABLE_OVERLOADING
data LoggerSetResponseFilterMethodInfo
instance (signature ~ (Soup.Callbacks.LoggerFilter -> m ()), MonadIO m, IsLogger a) => O.MethodInfo LoggerSetResponseFilterMethodInfo a signature where
overloadedMethod _ = loggerSetResponseFilter
#endif