{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) /No description available in the introspection data./ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Soup.Objects.AuthDomain ( -- * Exported types AuthDomain(..) , IsAuthDomain , toAuthDomain , noAuthDomain , -- * Methods -- ** accepts #method:accepts# #if ENABLE_OVERLOADING AuthDomainAcceptsMethodInfo , #endif authDomainAccepts , -- ** addPath #method:addPath# #if ENABLE_OVERLOADING AuthDomainAddPathMethodInfo , #endif authDomainAddPath , -- ** challenge #method:challenge# #if ENABLE_OVERLOADING AuthDomainChallengeMethodInfo , #endif authDomainChallenge , -- ** checkPassword #method:checkPassword# #if ENABLE_OVERLOADING AuthDomainCheckPasswordMethodInfo , #endif authDomainCheckPassword , -- ** covers #method:covers# #if ENABLE_OVERLOADING AuthDomainCoversMethodInfo , #endif authDomainCovers , -- ** getRealm #method:getRealm# #if ENABLE_OVERLOADING AuthDomainGetRealmMethodInfo , #endif authDomainGetRealm , -- ** removePath #method:removePath# #if ENABLE_OVERLOADING AuthDomainRemovePathMethodInfo , #endif authDomainRemovePath , -- ** setFilter #method:setFilter# #if ENABLE_OVERLOADING AuthDomainSetFilterMethodInfo , #endif authDomainSetFilter , -- ** setGenericAuthCallback #method:setGenericAuthCallback# #if ENABLE_OVERLOADING AuthDomainSetGenericAuthCallbackMethodInfo, #endif authDomainSetGenericAuthCallback , -- ** tryGenericAuthCallback #method:tryGenericAuthCallback# #if ENABLE_OVERLOADING AuthDomainTryGenericAuthCallbackMethodInfo, #endif authDomainTryGenericAuthCallback , -- * Properties -- ** addPath #attr:addPath# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AuthDomainAddPathPropertyInfo , #endif clearAuthDomainAddPath , constructAuthDomainAddPath , setAuthDomainAddPath , -- ** filter #attr:filter# {- | The 'GI.Soup.Callbacks.AuthDomainFilter' for the domain -} #if ENABLE_OVERLOADING AuthDomainFilterPropertyInfo , #endif #if ENABLE_OVERLOADING authDomainFilter , #endif clearAuthDomainFilter , constructAuthDomainFilter , getAuthDomainFilter , setAuthDomainFilter , -- ** filterData #attr:filterData# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AuthDomainFilterDataPropertyInfo , #endif #if ENABLE_OVERLOADING authDomainFilterData , #endif constructAuthDomainFilterData , getAuthDomainFilterData , setAuthDomainFilterData , -- ** genericAuthCallback #attr:genericAuthCallback# {- | The 'GI.Soup.Callbacks.AuthDomainGenericAuthCallback' for the domain -} #if ENABLE_OVERLOADING AuthDomainGenericAuthCallbackPropertyInfo, #endif #if ENABLE_OVERLOADING authDomainGenericAuthCallback , #endif clearAuthDomainGenericAuthCallback , constructAuthDomainGenericAuthCallback , getAuthDomainGenericAuthCallback , setAuthDomainGenericAuthCallback , -- ** genericAuthData #attr:genericAuthData# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AuthDomainGenericAuthDataPropertyInfo , #endif #if ENABLE_OVERLOADING authDomainGenericAuthData , #endif constructAuthDomainGenericAuthData , getAuthDomainGenericAuthData , setAuthDomainGenericAuthData , -- ** proxy #attr:proxy# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AuthDomainProxyPropertyInfo , #endif #if ENABLE_OVERLOADING authDomainProxy , #endif constructAuthDomainProxy , getAuthDomainProxy , -- ** realm #attr:realm# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AuthDomainRealmPropertyInfo , #endif #if ENABLE_OVERLOADING authDomainRealm , #endif constructAuthDomainRealm , getAuthDomainRealm , -- ** removePath #attr:removePath# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING AuthDomainRemovePathPropertyInfo , #endif clearAuthDomainRemovePath , constructAuthDomainRemovePath , setAuthDomainRemovePath , ) 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.Objects.Message as Soup.Message -- | Memory-managed wrapper type. newtype AuthDomain = AuthDomain (ManagedPtr AuthDomain) foreign import ccall "soup_auth_domain_get_type" c_soup_auth_domain_get_type :: IO GType instance GObject AuthDomain where gobjectType = c_soup_auth_domain_get_type -- | Type class for types which can be safely cast to `AuthDomain`, for instance with `toAuthDomain`. class (GObject o, O.IsDescendantOf AuthDomain o) => IsAuthDomain o instance (GObject o, O.IsDescendantOf AuthDomain o) => IsAuthDomain o instance O.HasParentTypes AuthDomain type instance O.ParentTypes AuthDomain = '[GObject.Object.Object] -- | Cast to `AuthDomain`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toAuthDomain :: (MonadIO m, IsAuthDomain o) => o -> m AuthDomain toAuthDomain = liftIO . unsafeCastTo AuthDomain -- | A convenience alias for `Nothing` :: `Maybe` `AuthDomain`. noAuthDomain :: Maybe AuthDomain noAuthDomain = Nothing #if ENABLE_OVERLOADING type family ResolveAuthDomainMethod (t :: Symbol) (o :: *) :: * where ResolveAuthDomainMethod "accepts" o = AuthDomainAcceptsMethodInfo ResolveAuthDomainMethod "addPath" o = AuthDomainAddPathMethodInfo ResolveAuthDomainMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveAuthDomainMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveAuthDomainMethod "challenge" o = AuthDomainChallengeMethodInfo ResolveAuthDomainMethod "checkPassword" o = AuthDomainCheckPasswordMethodInfo ResolveAuthDomainMethod "covers" o = AuthDomainCoversMethodInfo ResolveAuthDomainMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveAuthDomainMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveAuthDomainMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveAuthDomainMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveAuthDomainMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveAuthDomainMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveAuthDomainMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveAuthDomainMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveAuthDomainMethod "removePath" o = AuthDomainRemovePathMethodInfo ResolveAuthDomainMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveAuthDomainMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveAuthDomainMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveAuthDomainMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveAuthDomainMethod "tryGenericAuthCallback" o = AuthDomainTryGenericAuthCallbackMethodInfo ResolveAuthDomainMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveAuthDomainMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveAuthDomainMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveAuthDomainMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveAuthDomainMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveAuthDomainMethod "getRealm" o = AuthDomainGetRealmMethodInfo ResolveAuthDomainMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveAuthDomainMethod "setFilter" o = AuthDomainSetFilterMethodInfo ResolveAuthDomainMethod "setGenericAuthCallback" o = AuthDomainSetGenericAuthCallbackMethodInfo ResolveAuthDomainMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveAuthDomainMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveAuthDomainMethod t AuthDomain, O.MethodInfo info AuthDomain p) => OL.IsLabel t (AuthDomain -> 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 -- VVV Prop "add-path" -- Type: TBasicType TUTF8 -- Flags: [PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Set the value of the “@add-path@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' authDomain [ #addPath 'Data.GI.Base.Attributes.:=' value ] @ -} setAuthDomainAddPath :: (MonadIO m, IsAuthDomain o) => o -> T.Text -> m () setAuthDomainAddPath obj val = liftIO $ B.Properties.setObjectPropertyString obj "add-path" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@add-path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainAddPath :: (IsAuthDomain o) => T.Text -> IO (GValueConstruct o) constructAuthDomainAddPath val = B.Properties.constructObjectPropertyString "add-path" (Just val) {- | Set the value of the “@add-path@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #addPath @ -} clearAuthDomainAddPath :: (MonadIO m, IsAuthDomain o) => o -> m () clearAuthDomainAddPath obj = liftIO $ B.Properties.setObjectPropertyString obj "add-path" (Nothing :: Maybe T.Text) #if ENABLE_OVERLOADING data AuthDomainAddPathPropertyInfo instance AttrInfo AuthDomainAddPathPropertyInfo where type AttrAllowedOps AuthDomainAddPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear] type AttrSetTypeConstraint AuthDomainAddPathPropertyInfo = (~) T.Text type AttrBaseTypeConstraint AuthDomainAddPathPropertyInfo = IsAuthDomain type AttrGetType AuthDomainAddPathPropertyInfo = () type AttrLabel AuthDomainAddPathPropertyInfo = "add-path" type AttrOrigin AuthDomainAddPathPropertyInfo = AuthDomain attrGet _ = undefined attrSet _ = setAuthDomainAddPath attrConstruct _ = constructAuthDomainAddPath attrClear _ = clearAuthDomainAddPath #endif -- VVV Prop "filter" -- Type: TInterface (Name {namespace = "Soup", name = "AuthDomainFilter"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@filter@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' authDomain #filter @ -} getAuthDomainFilter :: (MonadIO m, IsAuthDomain o) => o -> m (Maybe Soup.Callbacks.AuthDomainFilter_WithClosures) getAuthDomainFilter obj = liftIO $ B.Properties.getObjectPropertyCallback obj "filter" Soup.Callbacks.dynamic_AuthDomainFilter {- | Set the value of the “@filter@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' authDomain [ #filter 'Data.GI.Base.Attributes.:=' value ] @ -} setAuthDomainFilter :: (MonadIO m, IsAuthDomain o) => o -> FunPtr Soup.Callbacks.C_AuthDomainFilter -> m () setAuthDomainFilter obj val = liftIO $ B.Properties.setObjectPropertyCallback obj "filter" val {- | Construct a `GValueConstruct` with valid value for the “@filter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainFilter :: (IsAuthDomain o) => FunPtr Soup.Callbacks.C_AuthDomainFilter -> IO (GValueConstruct o) constructAuthDomainFilter val = B.Properties.constructObjectPropertyCallback "filter" val {- | Set the value of the “@filter@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #filter @ -} clearAuthDomainFilter :: (MonadIO m, IsAuthDomain o) => o -> m () clearAuthDomainFilter obj = liftIO $ B.Properties.setObjectPropertyCallback obj "filter" FP.nullFunPtr #if ENABLE_OVERLOADING data AuthDomainFilterPropertyInfo instance AttrInfo AuthDomainFilterPropertyInfo where type AttrAllowedOps AuthDomainFilterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint AuthDomainFilterPropertyInfo = (~) (FunPtr Soup.Callbacks.C_AuthDomainFilter) type AttrBaseTypeConstraint AuthDomainFilterPropertyInfo = IsAuthDomain type AttrGetType AuthDomainFilterPropertyInfo = (Maybe Soup.Callbacks.AuthDomainFilter_WithClosures) type AttrLabel AuthDomainFilterPropertyInfo = "filter" type AttrOrigin AuthDomainFilterPropertyInfo = AuthDomain attrGet _ = getAuthDomainFilter attrSet _ = setAuthDomainFilter attrConstruct _ = constructAuthDomainFilter attrClear _ = clearAuthDomainFilter #endif -- VVV Prop "filter-data" -- Type: TBasicType TPtr -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@filter-data@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' authDomain #filterData @ -} getAuthDomainFilterData :: (MonadIO m, IsAuthDomain o) => o -> m (Ptr ()) getAuthDomainFilterData obj = liftIO $ B.Properties.getObjectPropertyPtr obj "filter-data" {- | Set the value of the “@filter-data@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' authDomain [ #filterData 'Data.GI.Base.Attributes.:=' value ] @ -} setAuthDomainFilterData :: (MonadIO m, IsAuthDomain o) => o -> Ptr () -> m () setAuthDomainFilterData obj val = liftIO $ B.Properties.setObjectPropertyPtr obj "filter-data" val {- | Construct a `GValueConstruct` with valid value for the “@filter-data@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainFilterData :: (IsAuthDomain o) => Ptr () -> IO (GValueConstruct o) constructAuthDomainFilterData val = B.Properties.constructObjectPropertyPtr "filter-data" val #if ENABLE_OVERLOADING data AuthDomainFilterDataPropertyInfo instance AttrInfo AuthDomainFilterDataPropertyInfo where type AttrAllowedOps AuthDomainFilterDataPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint AuthDomainFilterDataPropertyInfo = (~) (Ptr ()) type AttrBaseTypeConstraint AuthDomainFilterDataPropertyInfo = IsAuthDomain type AttrGetType AuthDomainFilterDataPropertyInfo = (Ptr ()) type AttrLabel AuthDomainFilterDataPropertyInfo = "filter-data" type AttrOrigin AuthDomainFilterDataPropertyInfo = AuthDomain attrGet _ = getAuthDomainFilterData attrSet _ = setAuthDomainFilterData attrConstruct _ = constructAuthDomainFilterData attrClear _ = undefined #endif -- VVV Prop "generic-auth-callback" -- Type: TInterface (Name {namespace = "Soup", name = "AuthDomainGenericAuthCallback"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@generic-auth-callback@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' authDomain #genericAuthCallback @ -} getAuthDomainGenericAuthCallback :: (MonadIO m, IsAuthDomain o) => o -> m (Maybe Soup.Callbacks.AuthDomainGenericAuthCallback_WithClosures) getAuthDomainGenericAuthCallback obj = liftIO $ B.Properties.getObjectPropertyCallback obj "generic-auth-callback" Soup.Callbacks.dynamic_AuthDomainGenericAuthCallback {- | Set the value of the “@generic-auth-callback@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' authDomain [ #genericAuthCallback 'Data.GI.Base.Attributes.:=' value ] @ -} setAuthDomainGenericAuthCallback :: (MonadIO m, IsAuthDomain o) => o -> FunPtr Soup.Callbacks.C_AuthDomainGenericAuthCallback -> m () setAuthDomainGenericAuthCallback obj val = liftIO $ B.Properties.setObjectPropertyCallback obj "generic-auth-callback" val {- | Construct a `GValueConstruct` with valid value for the “@generic-auth-callback@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainGenericAuthCallback :: (IsAuthDomain o) => FunPtr Soup.Callbacks.C_AuthDomainGenericAuthCallback -> IO (GValueConstruct o) constructAuthDomainGenericAuthCallback val = B.Properties.constructObjectPropertyCallback "generic-auth-callback" val {- | Set the value of the “@generic-auth-callback@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #genericAuthCallback @ -} clearAuthDomainGenericAuthCallback :: (MonadIO m, IsAuthDomain o) => o -> m () clearAuthDomainGenericAuthCallback obj = liftIO $ B.Properties.setObjectPropertyCallback obj "generic-auth-callback" FP.nullFunPtr #if ENABLE_OVERLOADING data AuthDomainGenericAuthCallbackPropertyInfo instance AttrInfo AuthDomainGenericAuthCallbackPropertyInfo where type AttrAllowedOps AuthDomainGenericAuthCallbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint AuthDomainGenericAuthCallbackPropertyInfo = (~) (FunPtr Soup.Callbacks.C_AuthDomainGenericAuthCallback) type AttrBaseTypeConstraint AuthDomainGenericAuthCallbackPropertyInfo = IsAuthDomain type AttrGetType AuthDomainGenericAuthCallbackPropertyInfo = (Maybe Soup.Callbacks.AuthDomainGenericAuthCallback_WithClosures) type AttrLabel AuthDomainGenericAuthCallbackPropertyInfo = "generic-auth-callback" type AttrOrigin AuthDomainGenericAuthCallbackPropertyInfo = AuthDomain attrGet _ = getAuthDomainGenericAuthCallback attrSet _ = setAuthDomainGenericAuthCallback attrConstruct _ = constructAuthDomainGenericAuthCallback attrClear _ = clearAuthDomainGenericAuthCallback #endif -- VVV Prop "generic-auth-data" -- Type: TBasicType TPtr -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@generic-auth-data@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' authDomain #genericAuthData @ -} getAuthDomainGenericAuthData :: (MonadIO m, IsAuthDomain o) => o -> m (Ptr ()) getAuthDomainGenericAuthData obj = liftIO $ B.Properties.getObjectPropertyPtr obj "generic-auth-data" {- | Set the value of the “@generic-auth-data@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' authDomain [ #genericAuthData 'Data.GI.Base.Attributes.:=' value ] @ -} setAuthDomainGenericAuthData :: (MonadIO m, IsAuthDomain o) => o -> Ptr () -> m () setAuthDomainGenericAuthData obj val = liftIO $ B.Properties.setObjectPropertyPtr obj "generic-auth-data" val {- | Construct a `GValueConstruct` with valid value for the “@generic-auth-data@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainGenericAuthData :: (IsAuthDomain o) => Ptr () -> IO (GValueConstruct o) constructAuthDomainGenericAuthData val = B.Properties.constructObjectPropertyPtr "generic-auth-data" val #if ENABLE_OVERLOADING data AuthDomainGenericAuthDataPropertyInfo instance AttrInfo AuthDomainGenericAuthDataPropertyInfo where type AttrAllowedOps AuthDomainGenericAuthDataPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint AuthDomainGenericAuthDataPropertyInfo = (~) (Ptr ()) type AttrBaseTypeConstraint AuthDomainGenericAuthDataPropertyInfo = IsAuthDomain type AttrGetType AuthDomainGenericAuthDataPropertyInfo = (Ptr ()) type AttrLabel AuthDomainGenericAuthDataPropertyInfo = "generic-auth-data" type AttrOrigin AuthDomainGenericAuthDataPropertyInfo = AuthDomain attrGet _ = getAuthDomainGenericAuthData attrSet _ = setAuthDomainGenericAuthData attrConstruct _ = constructAuthDomainGenericAuthData attrClear _ = undefined #endif -- VVV Prop "proxy" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@proxy@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' authDomain #proxy @ -} getAuthDomainProxy :: (MonadIO m, IsAuthDomain o) => o -> m Bool getAuthDomainProxy obj = liftIO $ B.Properties.getObjectPropertyBool obj "proxy" {- | Construct a `GValueConstruct` with valid value for the “@proxy@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainProxy :: (IsAuthDomain o) => Bool -> IO (GValueConstruct o) constructAuthDomainProxy val = B.Properties.constructObjectPropertyBool "proxy" val #if ENABLE_OVERLOADING data AuthDomainProxyPropertyInfo instance AttrInfo AuthDomainProxyPropertyInfo where type AttrAllowedOps AuthDomainProxyPropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint AuthDomainProxyPropertyInfo = (~) Bool type AttrBaseTypeConstraint AuthDomainProxyPropertyInfo = IsAuthDomain type AttrGetType AuthDomainProxyPropertyInfo = Bool type AttrLabel AuthDomainProxyPropertyInfo = "proxy" type AttrOrigin AuthDomainProxyPropertyInfo = AuthDomain attrGet _ = getAuthDomainProxy attrSet _ = undefined attrConstruct _ = constructAuthDomainProxy attrClear _ = undefined #endif -- VVV Prop "realm" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@realm@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' authDomain #realm @ -} getAuthDomainRealm :: (MonadIO m, IsAuthDomain o) => o -> m T.Text getAuthDomainRealm obj = liftIO $ checkUnexpectedNothing "getAuthDomainRealm" $ B.Properties.getObjectPropertyString obj "realm" {- | Construct a `GValueConstruct` with valid value for the “@realm@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainRealm :: (IsAuthDomain o) => T.Text -> IO (GValueConstruct o) constructAuthDomainRealm val = B.Properties.constructObjectPropertyString "realm" (Just val) #if ENABLE_OVERLOADING data AuthDomainRealmPropertyInfo instance AttrInfo AuthDomainRealmPropertyInfo where type AttrAllowedOps AuthDomainRealmPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint AuthDomainRealmPropertyInfo = (~) T.Text type AttrBaseTypeConstraint AuthDomainRealmPropertyInfo = IsAuthDomain type AttrGetType AuthDomainRealmPropertyInfo = T.Text type AttrLabel AuthDomainRealmPropertyInfo = "realm" type AttrOrigin AuthDomainRealmPropertyInfo = AuthDomain attrGet _ = getAuthDomainRealm attrSet _ = undefined attrConstruct _ = constructAuthDomainRealm attrClear _ = undefined #endif -- VVV Prop "remove-path" -- Type: TBasicType TUTF8 -- Flags: [PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Set the value of the “@remove-path@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' authDomain [ #removePath 'Data.GI.Base.Attributes.:=' value ] @ -} setAuthDomainRemovePath :: (MonadIO m, IsAuthDomain o) => o -> T.Text -> m () setAuthDomainRemovePath obj val = liftIO $ B.Properties.setObjectPropertyString obj "remove-path" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@remove-path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructAuthDomainRemovePath :: (IsAuthDomain o) => T.Text -> IO (GValueConstruct o) constructAuthDomainRemovePath val = B.Properties.constructObjectPropertyString "remove-path" (Just val) {- | Set the value of the “@remove-path@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #removePath @ -} clearAuthDomainRemovePath :: (MonadIO m, IsAuthDomain o) => o -> m () clearAuthDomainRemovePath obj = liftIO $ B.Properties.setObjectPropertyString obj "remove-path" (Nothing :: Maybe T.Text) #if ENABLE_OVERLOADING data AuthDomainRemovePathPropertyInfo instance AttrInfo AuthDomainRemovePathPropertyInfo where type AttrAllowedOps AuthDomainRemovePathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear] type AttrSetTypeConstraint AuthDomainRemovePathPropertyInfo = (~) T.Text type AttrBaseTypeConstraint AuthDomainRemovePathPropertyInfo = IsAuthDomain type AttrGetType AuthDomainRemovePathPropertyInfo = () type AttrLabel AuthDomainRemovePathPropertyInfo = "remove-path" type AttrOrigin AuthDomainRemovePathPropertyInfo = AuthDomain attrGet _ = undefined attrSet _ = setAuthDomainRemovePath attrConstruct _ = constructAuthDomainRemovePath attrClear _ = clearAuthDomainRemovePath #endif #if ENABLE_OVERLOADING instance O.HasAttributeList AuthDomain type instance O.AttributeList AuthDomain = AuthDomainAttributeList type AuthDomainAttributeList = ('[ '("addPath", AuthDomainAddPathPropertyInfo), '("filter", AuthDomainFilterPropertyInfo), '("filterData", AuthDomainFilterDataPropertyInfo), '("genericAuthCallback", AuthDomainGenericAuthCallbackPropertyInfo), '("genericAuthData", AuthDomainGenericAuthDataPropertyInfo), '("proxy", AuthDomainProxyPropertyInfo), '("realm", AuthDomainRealmPropertyInfo), '("removePath", AuthDomainRemovePathPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING authDomainFilter :: AttrLabelProxy "filter" authDomainFilter = AttrLabelProxy authDomainFilterData :: AttrLabelProxy "filterData" authDomainFilterData = AttrLabelProxy authDomainGenericAuthCallback :: AttrLabelProxy "genericAuthCallback" authDomainGenericAuthCallback = AttrLabelProxy authDomainGenericAuthData :: AttrLabelProxy "genericAuthData" authDomainGenericAuthData = AttrLabelProxy authDomainProxy :: AttrLabelProxy "proxy" authDomainProxy = AttrLabelProxy authDomainRealm :: AttrLabelProxy "realm" authDomainRealm = AttrLabelProxy #endif #if ENABLE_OVERLOADING type instance O.SignalList AuthDomain = AuthDomainSignalList type AuthDomainSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method AuthDomain::accepts -- method type : OrdinaryMethod -- 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}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_accepts" soup_auth_domain_accepts :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) Ptr Soup.Message.Message -> -- msg : TInterface (Name {namespace = "Soup", name = "Message"}) IO CString {- | Checks if /@msg@/ contains appropriate authorization for /@domain@/ to accept it. Mirroring 'GI.Soup.Objects.AuthDomain.authDomainCovers', this does not check whether or not /@domain@/ \cares\<\/emphasis> if /@msg@/ is authorized. This is used by 'GI.Soup.Objects.Server.Server' internally and is probably of no use to anyone else. -} authDomainAccepts :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> b {- ^ /@msg@/: a 'GI.Soup.Objects.Message.Message' -} -> m (Maybe T.Text) {- ^ __Returns:__ the username that /@msg@/ has authenticated as, if in fact it has authenticated. 'Nothing' otherwise. -} authDomainAccepts domain msg = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain msg' <- unsafeManagedPtrCastPtr msg result <- soup_auth_domain_accepts domain' msg' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' freeMem result' return result'' touchManagedPtr domain touchManagedPtr msg return maybeResult #if ENABLE_OVERLOADING data AuthDomainAcceptsMethodInfo instance (signature ~ (b -> m (Maybe T.Text)), MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => O.MethodInfo AuthDomainAcceptsMethodInfo a signature where overloadedMethod _ = authDomainAccepts #endif -- method AuthDomain::add_path -- method type : OrdinaryMethod -- 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 = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path to add to @domain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_add_path" soup_auth_domain_add_path :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) CString -> -- path : TBasicType TUTF8 IO () {- | Adds /@path@/ to /@domain@/, such that requests under /@path@/ on /@domain@/\'s server will require authentication (unless overridden by 'GI.Soup.Objects.AuthDomain.authDomainRemovePath' or 'GI.Soup.Objects.AuthDomain.authDomainSetFilter'). You can also add paths by setting the 'GI.Soup.Constants.AUTH_DOMAIN_ADD_PATH' property, which can also be used to add one or more paths at construct time. -} authDomainAddPath :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> T.Text {- ^ /@path@/: the path to add to /@domain@/ -} -> m () authDomainAddPath domain path = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain path' <- textToCString path soup_auth_domain_add_path domain' path' touchManagedPtr domain freeMem path' return () #if ENABLE_OVERLOADING data AuthDomainAddPathMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsAuthDomain a) => O.MethodInfo AuthDomainAddPathMethodInfo a signature where overloadedMethod _ = authDomainAddPath #endif -- method AuthDomain::challenge -- method type : OrdinaryMethod -- 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}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_challenge" soup_auth_domain_challenge :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) Ptr Soup.Message.Message -> -- msg : TInterface (Name {namespace = "Soup", name = "Message"}) IO () {- | Adds a \"WWW-Authenticate\" or \"Proxy-Authenticate\" header to /@msg@/, requesting that the client authenticate, and sets /@msg@/\'s status accordingly. This is used by 'GI.Soup.Objects.Server.Server' internally and is probably of no use to anyone else. -} authDomainChallenge :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> b {- ^ /@msg@/: a 'GI.Soup.Objects.Message.Message' -} -> m () authDomainChallenge domain msg = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain msg' <- unsafeManagedPtrCastPtr msg soup_auth_domain_challenge domain' msg' touchManagedPtr domain touchManagedPtr msg return () #if ENABLE_OVERLOADING data AuthDomainChallengeMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => O.MethodInfo AuthDomainChallengeMethodInfo a signature where overloadedMethod _ = authDomainChallenge #endif -- method AuthDomain::check_password -- method type : OrdinaryMethod -- 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 = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a username", 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 "a password", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_check_password" soup_auth_domain_check_password :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) Ptr Soup.Message.Message -> -- msg : TInterface (Name {namespace = "Soup", name = "Message"}) CString -> -- username : TBasicType TUTF8 CString -> -- password : TBasicType TUTF8 IO CInt {- | Checks if /@msg@/ authenticates to /@domain@/ via /@username@/ and /@password@/. This would normally be called from a 'GI.Soup.Callbacks.AuthDomainGenericAuthCallback'. -} authDomainCheckPassword :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> b {- ^ /@msg@/: a 'GI.Soup.Objects.Message.Message' -} -> T.Text {- ^ /@username@/: a username -} -> T.Text {- ^ /@password@/: a password -} -> m Bool {- ^ __Returns:__ whether or not the message is authenticated -} authDomainCheckPassword domain msg username password = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain msg' <- unsafeManagedPtrCastPtr msg username' <- textToCString username password' <- textToCString password result <- soup_auth_domain_check_password domain' msg' username' password' let result' = (/= 0) result touchManagedPtr domain touchManagedPtr msg freeMem username' freeMem password' return result' #if ENABLE_OVERLOADING data AuthDomainCheckPasswordMethodInfo instance (signature ~ (b -> T.Text -> T.Text -> m Bool), MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => O.MethodInfo AuthDomainCheckPasswordMethodInfo a signature where overloadedMethod _ = authDomainCheckPassword #endif -- method AuthDomain::covers -- method type : OrdinaryMethod -- 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}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_covers" soup_auth_domain_covers :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) Ptr Soup.Message.Message -> -- msg : TInterface (Name {namespace = "Soup", name = "Message"}) IO CInt {- | Checks if /@domain@/ requires /@msg@/ to be authenticated (according to its paths and filter function). This does not actually look at whether /@msg@/ \is\<\/emphasis> authenticated, merely whether or not it needs to be. This is used by 'GI.Soup.Objects.Server.Server' internally and is probably of no use to anyone else. -} authDomainCovers :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> b {- ^ /@msg@/: a 'GI.Soup.Objects.Message.Message' -} -> m Bool {- ^ __Returns:__ 'True' if /@domain@/ requires /@msg@/ to be authenticated -} authDomainCovers domain msg = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain msg' <- unsafeManagedPtrCastPtr msg result <- soup_auth_domain_covers domain' msg' let result' = (/= 0) result touchManagedPtr domain touchManagedPtr msg return result' #if ENABLE_OVERLOADING data AuthDomainCoversMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => O.MethodInfo AuthDomainCoversMethodInfo a signature where overloadedMethod _ = authDomainCovers #endif -- method AuthDomain::get_realm -- method type : OrdinaryMethod -- 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}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_get_realm" soup_auth_domain_get_realm :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) IO CString {- | Gets the realm name associated with /@domain@/ -} authDomainGetRealm :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> m T.Text {- ^ __Returns:__ /@domain@/\'s realm -} authDomainGetRealm domain = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain result <- soup_auth_domain_get_realm domain' checkUnexpectedReturnNULL "authDomainGetRealm" result result' <- cstringToText result touchManagedPtr domain return result' #if ENABLE_OVERLOADING data AuthDomainGetRealmMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsAuthDomain a) => O.MethodInfo AuthDomainGetRealmMethodInfo a signature where overloadedMethod _ = authDomainGetRealm #endif -- method AuthDomain::remove_path -- method type : OrdinaryMethod -- 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 = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path to remove from @domain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_remove_path" soup_auth_domain_remove_path :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) CString -> -- path : TBasicType TUTF8 IO () {- | Removes /@path@/ from /@domain@/, such that requests under /@path@/ on /@domain@/\'s server will NOT require authentication. This is not simply an undo-er for 'GI.Soup.Objects.AuthDomain.authDomainAddPath'; it can be used to \"carve out\" a subtree that does not require authentication inside a hierarchy that does. Note also that unlike with 'GI.Soup.Objects.AuthDomain.authDomainAddPath', this cannot be overridden by adding a filter, as filters can only bypass authentication that would otherwise be required, not require it where it would otherwise be unnecessary. You can also remove paths by setting the 'GI.Soup.Constants.AUTH_DOMAIN_REMOVE_PATH' property, which can also be used to remove one or more paths at construct time. -} authDomainRemovePath :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> T.Text {- ^ /@path@/: the path to remove from /@domain@/ -} -> m () authDomainRemovePath domain path = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain path' <- textToCString path soup_auth_domain_remove_path domain' path' touchManagedPtr domain freeMem path' return () #if ENABLE_OVERLOADING data AuthDomainRemovePathMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsAuthDomain a) => O.MethodInfo AuthDomainRemovePathMethodInfo a signature where overloadedMethod _ = authDomainRemovePath #endif -- method AuthDomain::set_filter -- method type : OrdinaryMethod -- 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 = "filter", argType = TInterface (Name {namespace = "Soup", name = "AuthDomainFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the auth filter for @domain", 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 @filter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dnotify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "destroy notifier to free @filter_data when @domain\nis destroyed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_set_filter" soup_auth_domain_set_filter :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) FunPtr Soup.Callbacks.C_AuthDomainFilter -> -- filter : TInterface (Name {namespace = "Soup", name = "AuthDomainFilter"}) Ptr () -> -- filter_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- dnotify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Adds /@filter@/ as an authentication filter to /@domain@/. The filter gets a chance to bypass authentication for certain requests that would otherwise require it. Eg, it might check the message\'s path in some way that is too complicated to do via the other methods, or it might check the message\'s method, and allow GETs but not PUTs. The filter function returns 'True' if the request should still require authentication, or 'False' if authentication is unnecessary for this request. To help prevent security holes, your filter should return 'True' by default, and only return 'False' under specifically-tested circumstances, rather than the other way around. Eg, in the example above, where you want to authenticate PUTs but not GETs, you should check if the method is GET and return 'False' in that case, and then return 'True' for all other methods (rather than returning 'True' for PUT and 'False' for all other methods). This way if it turned out (now or later) that some paths supported additional methods besides GET and PUT, those methods would default to being NOT allowed for unauthenticated users. You can also set the filter by setting the 'GI.Soup.Constants.AUTH_DOMAIN_FILTER' and 'GI.Soup.Constants.AUTH_DOMAIN_FILTER_DATA' properties, which can also be used to set the filter at construct time. -} authDomainSetFilter :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> Soup.Callbacks.AuthDomainFilter {- ^ /@filter@/: the auth filter for /@domain@/ -} -> m () authDomainSetFilter domain filter = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain filter' <- Soup.Callbacks.mk_AuthDomainFilter (Soup.Callbacks.wrap_AuthDomainFilter Nothing (Soup.Callbacks.drop_closures_AuthDomainFilter filter)) let filterData = castFunPtrToPtr filter' let dnotify = safeFreeFunPtrPtr soup_auth_domain_set_filter domain' filter' filterData dnotify touchManagedPtr domain return () #if ENABLE_OVERLOADING data AuthDomainSetFilterMethodInfo instance (signature ~ (Soup.Callbacks.AuthDomainFilter -> m ()), MonadIO m, IsAuthDomain a) => O.MethodInfo AuthDomainSetFilterMethodInfo a signature where overloadedMethod _ = authDomainSetFilter #endif -- method AuthDomain::set_generic_auth_callback -- method type : OrdinaryMethod -- 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 = "auth_callback", argType = TInterface (Name {namespace = "Soup", name = "AuthDomainGenericAuthCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the auth callback", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "auth_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to @auth_callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dnotify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "destroy notifier to free @auth_data when @domain\nis destroyed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_set_generic_auth_callback" soup_auth_domain_set_generic_auth_callback :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) FunPtr Soup.Callbacks.C_AuthDomainGenericAuthCallback -> -- auth_callback : TInterface (Name {namespace = "Soup", name = "AuthDomainGenericAuthCallback"}) Ptr () -> -- auth_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- dnotify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets /@authCallback@/ as an authentication-handling callback for /@domain@/. Whenever a request comes in to /@domain@/ which cannot be authenticated via a domain-specific auth callback (eg, 'GI.Soup.Callbacks.AuthDomainDigestAuthCallback'), the generic auth callback will be invoked. See 'GI.Soup.Callbacks.AuthDomainGenericAuthCallback' for information on what the callback should do. -} authDomainSetGenericAuthCallback :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a) => a {- ^ /@domain@/: a 'GI.Soup.Objects.AuthDomain.AuthDomain' -} -> Soup.Callbacks.AuthDomainGenericAuthCallback {- ^ /@authCallback@/: the auth callback -} -> m () authDomainSetGenericAuthCallback domain authCallback = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain authCallback' <- Soup.Callbacks.mk_AuthDomainGenericAuthCallback (Soup.Callbacks.wrap_AuthDomainGenericAuthCallback Nothing (Soup.Callbacks.drop_closures_AuthDomainGenericAuthCallback authCallback)) let authData = castFunPtrToPtr authCallback' let dnotify = safeFreeFunPtrPtr soup_auth_domain_set_generic_auth_callback domain' authCallback' authData dnotify touchManagedPtr domain return () #if ENABLE_OVERLOADING data AuthDomainSetGenericAuthCallbackMethodInfo instance (signature ~ (Soup.Callbacks.AuthDomainGenericAuthCallback -> m ()), MonadIO m, IsAuthDomain a) => O.MethodInfo AuthDomainSetGenericAuthCallbackMethodInfo a signature where overloadedMethod _ = authDomainSetGenericAuthCallback #endif -- method AuthDomain::try_generic_auth_callback -- method type : OrdinaryMethod -- Args : [Arg {argCName = "domain", argType = TInterface (Name {namespace = "Soup", name = "AuthDomain"}), 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 = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "soup_auth_domain_try_generic_auth_callback" soup_auth_domain_try_generic_auth_callback :: Ptr AuthDomain -> -- domain : TInterface (Name {namespace = "Soup", name = "AuthDomain"}) Ptr Soup.Message.Message -> -- msg : TInterface (Name {namespace = "Soup", name = "Message"}) CString -> -- username : TBasicType TUTF8 IO CInt {- | /No description available in the introspection data./ -} authDomainTryGenericAuthCallback :: (B.CallStack.HasCallStack, MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => a -> b -> T.Text -> m Bool authDomainTryGenericAuthCallback domain msg username = liftIO $ do domain' <- unsafeManagedPtrCastPtr domain msg' <- unsafeManagedPtrCastPtr msg username' <- textToCString username result <- soup_auth_domain_try_generic_auth_callback domain' msg' username' let result' = (/= 0) result touchManagedPtr domain touchManagedPtr msg freeMem username' return result' #if ENABLE_OVERLOADING data AuthDomainTryGenericAuthCallbackMethodInfo instance (signature ~ (b -> T.Text -> m Bool), MonadIO m, IsAuthDomain a, Soup.Message.IsMessage b) => O.MethodInfo AuthDomainTryGenericAuthCallbackMethodInfo a signature where overloadedMethod _ = authDomainTryGenericAuthCallback #endif