{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Soup.Objects.HSTSEnforcerDB.HSTSEnforcerDB' is a t'GI.Soup.Objects.HSTSEnforcer.HSTSEnforcer' that uses a SQLite
-- database as a backend for persistency.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Soup.Objects.HSTSEnforcerDB
    ( 

-- * Exported types
    HSTSEnforcerDB(..)                      ,
    IsHSTSEnforcerDB                        ,
    toHSTSEnforcerDB                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addFeature]("GI.Soup.Interfaces.SessionFeature#g:method:addFeature"), [attach]("GI.Soup.Interfaces.SessionFeature#g:method:attach"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [detach]("GI.Soup.Interfaces.SessionFeature#g:method:detach"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasFeature]("GI.Soup.Interfaces.SessionFeature#g:method:hasFeature"), [hasValidPolicy]("GI.Soup.Objects.HSTSEnforcer#g:method:hasValidPolicy"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isPersistent]("GI.Soup.Objects.HSTSEnforcer#g:method:isPersistent"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeFeature]("GI.Soup.Interfaces.SessionFeature#g:method:removeFeature"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDomains]("GI.Soup.Objects.HSTSEnforcer#g:method:getDomains"), [getPolicies]("GI.Soup.Objects.HSTSEnforcer#g:method:getPolicies"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setPolicy]("GI.Soup.Objects.HSTSEnforcer#g:method:setPolicy"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSessionPolicy]("GI.Soup.Objects.HSTSEnforcer#g:method:setSessionPolicy").

#if defined(ENABLE_OVERLOADING)
    ResolveHSTSEnforcerDBMethod             ,
#endif

-- ** new #method:new#

    hSTSEnforcerDBNew                       ,




 -- * Properties


-- ** filename #attr:filename#
-- | The filename of the SQLite database where HSTS policies are stored.

#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

-- | Memory-managed wrapper type.
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

-- | Type class for types which can be safely cast to `HSTSEnforcerDB`, for instance with `toHSTSEnforcerDB`.
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]

-- | Cast to `HSTSEnforcerDB`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- | Convert 'HSTSEnforcerDB' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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

-- VVV Prop "filename"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@filename@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' hSTSEnforcerDB #filename
-- @
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"

-- | Construct a `GValueConstruct` with valid value for the “@filename@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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

-- method HSTSEnforcerDB::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "filename"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the filename of the database to read/write from."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "HSTSEnforcerDB" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_hsts_enforcer_db_new" soup_hsts_enforcer_db_new :: 
    CString ->                              -- filename : TBasicType TUTF8
    IO (Ptr HSTSEnforcerDB)

-- | Creates a t'GI.Soup.Objects.HSTSEnforcerDB.HSTSEnforcerDB'.
-- 
-- /@filename@/ will be read in during the initialization of a
-- t'GI.Soup.Objects.HSTSEnforcerDB.HSTSEnforcerDB', in order to create an initial set of HSTS
-- policies. If the file doesn\'t exist, a new database will be created
-- and initialized. Changes to the policies during the lifetime of a
-- t'GI.Soup.Objects.HSTSEnforcerDB.HSTSEnforcerDB' will be written to /@filename@/ when
-- [changed]("GI.Soup.Objects.HSTSEnforcer#g:signal:changed") is emitted.
-- 
-- /Since: 2.68/
hSTSEnforcerDBNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@filename@/: the filename of the database to read\/write from.
    -> m HSTSEnforcerDB
    -- ^ __Returns:__ the new t'GI.Soup.Objects.HSTSEnforcer.HSTSEnforcer'
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