{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Objects.HSTSEnforcerDB
(
HSTSEnforcerDB(..) ,
IsHSTSEnforcerDB ,
toHSTSEnforcerDB ,
#if defined(ENABLE_OVERLOADING)
ResolveHSTSEnforcerDBMethod ,
#endif
hSTSEnforcerDBNew ,
#if defined(ENABLE_OVERLOADING)
HSTSEnforcerDBFilenamePropertyInfo ,
#endif
constructHSTSEnforcerDBFilename ,
getHSTSEnforcerDBFilename ,
#if defined(ENABLE_OVERLOADING)
hSTSEnforcerDBFilename ,
#endif
) 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.GArray as B.GArray
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 GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
import {-# SOURCE #-} qualified GI.Soup.Objects.HSTSEnforcer as Soup.HSTSEnforcer
newtype HSTSEnforcerDB = HSTSEnforcerDB (SP.ManagedPtr HSTSEnforcerDB)
deriving (HSTSEnforcerDB -> HSTSEnforcerDB -> Bool
(HSTSEnforcerDB -> HSTSEnforcerDB -> Bool)
-> (HSTSEnforcerDB -> HSTSEnforcerDB -> Bool) -> Eq HSTSEnforcerDB
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HSTSEnforcerDB -> HSTSEnforcerDB -> Bool
$c/= :: HSTSEnforcerDB -> HSTSEnforcerDB -> Bool
== :: HSTSEnforcerDB -> HSTSEnforcerDB -> Bool
$c== :: HSTSEnforcerDB -> HSTSEnforcerDB -> Bool
Eq)
instance SP.ManagedPtrNewtype HSTSEnforcerDB where
toManagedPtr :: HSTSEnforcerDB -> ManagedPtr HSTSEnforcerDB
toManagedPtr (HSTSEnforcerDB ManagedPtr HSTSEnforcerDB
p) = ManagedPtr HSTSEnforcerDB
p
foreign import ccall "soup_hsts_enforcer_db_get_type"
c_soup_hsts_enforcer_db_get_type :: IO B.Types.GType
instance B.Types.TypedObject HSTSEnforcerDB where
glibType :: IO GType
glibType = IO GType
c_soup_hsts_enforcer_db_get_type
instance B.Types.GObject HSTSEnforcerDB
class (SP.GObject o, O.IsDescendantOf HSTSEnforcerDB o) => IsHSTSEnforcerDB o
instance (SP.GObject o, O.IsDescendantOf HSTSEnforcerDB o) => IsHSTSEnforcerDB o
instance O.HasParentTypes HSTSEnforcerDB
type instance O.ParentTypes HSTSEnforcerDB = '[Soup.HSTSEnforcer.HSTSEnforcer, GObject.Object.Object, Soup.SessionFeature.SessionFeature]
toHSTSEnforcerDB :: (MIO.MonadIO m, IsHSTSEnforcerDB o) => o -> m HSTSEnforcerDB
toHSTSEnforcerDB :: forall (m :: * -> *) o.
(MonadIO m, IsHSTSEnforcerDB o) =>
o -> m HSTSEnforcerDB
toHSTSEnforcerDB = IO HSTSEnforcerDB -> m HSTSEnforcerDB
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO HSTSEnforcerDB -> m HSTSEnforcerDB)
-> (o -> IO HSTSEnforcerDB) -> o -> m HSTSEnforcerDB
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr HSTSEnforcerDB -> HSTSEnforcerDB)
-> o -> IO HSTSEnforcerDB
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr HSTSEnforcerDB -> HSTSEnforcerDB
HSTSEnforcerDB
instance B.GValue.IsGValue (Maybe HSTSEnforcerDB) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_hsts_enforcer_db_get_type
gvalueSet_ :: Ptr GValue -> Maybe HSTSEnforcerDB -> IO ()
gvalueSet_ Ptr GValue
gv Maybe HSTSEnforcerDB
P.Nothing = Ptr GValue -> Ptr HSTSEnforcerDB -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr HSTSEnforcerDB
forall a. Ptr a
FP.nullPtr :: FP.Ptr HSTSEnforcerDB)
gvalueSet_ Ptr GValue
gv (P.Just HSTSEnforcerDB
obj) = HSTSEnforcerDB -> (Ptr HSTSEnforcerDB -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr HSTSEnforcerDB
obj (Ptr GValue -> Ptr HSTSEnforcerDB -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe HSTSEnforcerDB)
gvalueGet_ Ptr GValue
gv = do
Ptr HSTSEnforcerDB
ptr <- Ptr GValue -> IO (Ptr HSTSEnforcerDB)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr HSTSEnforcerDB)
if Ptr HSTSEnforcerDB
ptr Ptr HSTSEnforcerDB -> Ptr HSTSEnforcerDB -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr HSTSEnforcerDB
forall a. Ptr a
FP.nullPtr
then HSTSEnforcerDB -> Maybe HSTSEnforcerDB
forall a. a -> Maybe a
P.Just (HSTSEnforcerDB -> Maybe HSTSEnforcerDB)
-> IO HSTSEnforcerDB -> IO (Maybe HSTSEnforcerDB)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr HSTSEnforcerDB -> HSTSEnforcerDB)
-> Ptr HSTSEnforcerDB -> IO HSTSEnforcerDB
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr HSTSEnforcerDB -> HSTSEnforcerDB
HSTSEnforcerDB Ptr HSTSEnforcerDB
ptr
else Maybe HSTSEnforcerDB -> IO (Maybe HSTSEnforcerDB)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe HSTSEnforcerDB
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveHSTSEnforcerDBMethod (t :: Symbol) (o :: *) :: * where
ResolveHSTSEnforcerDBMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
ResolveHSTSEnforcerDBMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo
ResolveHSTSEnforcerDBMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveHSTSEnforcerDBMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveHSTSEnforcerDBMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo
ResolveHSTSEnforcerDBMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveHSTSEnforcerDBMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveHSTSEnforcerDBMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveHSTSEnforcerDBMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
ResolveHSTSEnforcerDBMethod "hasValidPolicy" o = Soup.HSTSEnforcer.HSTSEnforcerHasValidPolicyMethodInfo
ResolveHSTSEnforcerDBMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveHSTSEnforcerDBMethod "isPersistent" o = Soup.HSTSEnforcer.HSTSEnforcerIsPersistentMethodInfo
ResolveHSTSEnforcerDBMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveHSTSEnforcerDBMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveHSTSEnforcerDBMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveHSTSEnforcerDBMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveHSTSEnforcerDBMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
ResolveHSTSEnforcerDBMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveHSTSEnforcerDBMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveHSTSEnforcerDBMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveHSTSEnforcerDBMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveHSTSEnforcerDBMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveHSTSEnforcerDBMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveHSTSEnforcerDBMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveHSTSEnforcerDBMethod "getDomains" o = Soup.HSTSEnforcer.HSTSEnforcerGetDomainsMethodInfo
ResolveHSTSEnforcerDBMethod "getPolicies" o = Soup.HSTSEnforcer.HSTSEnforcerGetPoliciesMethodInfo
ResolveHSTSEnforcerDBMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveHSTSEnforcerDBMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveHSTSEnforcerDBMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveHSTSEnforcerDBMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveHSTSEnforcerDBMethod "setPolicy" o = Soup.HSTSEnforcer.HSTSEnforcerSetPolicyMethodInfo
ResolveHSTSEnforcerDBMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveHSTSEnforcerDBMethod "setSessionPolicy" o = Soup.HSTSEnforcer.HSTSEnforcerSetSessionPolicyMethodInfo
ResolveHSTSEnforcerDBMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveHSTSEnforcerDBMethod t HSTSEnforcerDB, O.OverloadedMethod info HSTSEnforcerDB p) => OL.IsLabel t (HSTSEnforcerDB -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveHSTSEnforcerDBMethod t HSTSEnforcerDB, O.OverloadedMethod info HSTSEnforcerDB p, R.HasField t HSTSEnforcerDB p) => R.HasField t HSTSEnforcerDB p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveHSTSEnforcerDBMethod t HSTSEnforcerDB, O.OverloadedMethodInfo info HSTSEnforcerDB) => OL.IsLabel t (O.MethodProxy info HSTSEnforcerDB) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getHSTSEnforcerDBFilename :: (MonadIO m, IsHSTSEnforcerDB o) => o -> m (Maybe T.Text)
getHSTSEnforcerDBFilename :: forall (m :: * -> *) o.
(MonadIO m, IsHSTSEnforcerDB o) =>
o -> m (Maybe Text)
getHSTSEnforcerDBFilename o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"filename"
constructHSTSEnforcerDBFilename :: (IsHSTSEnforcerDB o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructHSTSEnforcerDBFilename :: forall o (m :: * -> *).
(IsHSTSEnforcerDB o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructHSTSEnforcerDBFilename Text
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
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"filename" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data HSTSEnforcerDBFilenamePropertyInfo
instance AttrInfo HSTSEnforcerDBFilenamePropertyInfo where
type AttrAllowedOps HSTSEnforcerDBFilenamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint HSTSEnforcerDBFilenamePropertyInfo = IsHSTSEnforcerDB
type AttrSetTypeConstraint HSTSEnforcerDBFilenamePropertyInfo = (~) T.Text
type AttrTransferTypeConstraint HSTSEnforcerDBFilenamePropertyInfo = (~) T.Text
type AttrTransferType HSTSEnforcerDBFilenamePropertyInfo = T.Text
type AttrGetType HSTSEnforcerDBFilenamePropertyInfo = (Maybe T.Text)
type AttrLabel HSTSEnforcerDBFilenamePropertyInfo = "filename"
type AttrOrigin HSTSEnforcerDBFilenamePropertyInfo = HSTSEnforcerDB
attrGet = getHSTSEnforcerDBFilename
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructHSTSEnforcerDBFilename
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList HSTSEnforcerDB
type instance O.AttributeList HSTSEnforcerDB = HSTSEnforcerDBAttributeList
type HSTSEnforcerDBAttributeList = ('[ '("filename", HSTSEnforcerDBFilenamePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
hSTSEnforcerDBFilename :: AttrLabelProxy "filename"
hSTSEnforcerDBFilename = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList HSTSEnforcerDB = HSTSEnforcerDBSignalList
type HSTSEnforcerDBSignalList = ('[ '("changed", Soup.HSTSEnforcer.HSTSEnforcerChangedSignalInfo), '("hstsEnforced", Soup.HSTSEnforcer.HSTSEnforcerHstsEnforcedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_hsts_enforcer_db_new" soup_hsts_enforcer_db_new ::
CString ->
IO (Ptr HSTSEnforcerDB)
hSTSEnforcerDBNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m HSTSEnforcerDB
hSTSEnforcerDBNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m HSTSEnforcerDB
hSTSEnforcerDBNew Text
filename = IO HSTSEnforcerDB -> m HSTSEnforcerDB
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HSTSEnforcerDB -> m HSTSEnforcerDB)
-> IO HSTSEnforcerDB -> m HSTSEnforcerDB
forall a b. (a -> b) -> a -> b
$ do
CString
filename' <- Text -> IO CString
textToCString Text
filename
Ptr HSTSEnforcerDB
result <- CString -> IO (Ptr HSTSEnforcerDB)
soup_hsts_enforcer_db_new CString
filename'
Text -> Ptr HSTSEnforcerDB -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hSTSEnforcerDBNew" Ptr HSTSEnforcerDB
result
HSTSEnforcerDB
result' <- ((ManagedPtr HSTSEnforcerDB -> HSTSEnforcerDB)
-> Ptr HSTSEnforcerDB -> IO HSTSEnforcerDB
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr HSTSEnforcerDB -> HSTSEnforcerDB
HSTSEnforcerDB) Ptr HSTSEnforcerDB
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
HSTSEnforcerDB -> IO HSTSEnforcerDB
forall (m :: * -> *) a. Monad m => a -> m a
return HSTSEnforcerDB
result'
#if defined(ENABLE_OVERLOADING)
#endif