{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Objects.Cache
(
Cache(..) ,
IsCache ,
toCache ,
#if defined(ENABLE_OVERLOADING)
ResolveCacheMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
CacheClearMethodInfo ,
#endif
cacheClear ,
#if defined(ENABLE_OVERLOADING)
CacheDumpMethodInfo ,
#endif
cacheDump ,
#if defined(ENABLE_OVERLOADING)
CacheFlushMethodInfo ,
#endif
cacheFlush ,
#if defined(ENABLE_OVERLOADING)
CacheGetMaxSizeMethodInfo ,
#endif
cacheGetMaxSize ,
#if defined(ENABLE_OVERLOADING)
CacheLoadMethodInfo ,
#endif
cacheLoad ,
cacheNew ,
#if defined(ENABLE_OVERLOADING)
CacheSetMaxSizeMethodInfo ,
#endif
cacheSetMaxSize ,
#if defined(ENABLE_OVERLOADING)
CacheCacheDirPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
cacheCacheDir ,
#endif
constructCacheCacheDir ,
getCacheCacheDir ,
#if defined(ENABLE_OVERLOADING)
CacheCacheTypePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
cacheCacheType ,
#endif
constructCacheCacheType ,
getCacheCacheType ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
newtype Cache = Cache (SP.ManagedPtr Cache)
deriving (Cache -> Cache -> Bool
(Cache -> Cache -> Bool) -> (Cache -> Cache -> Bool) -> Eq Cache
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cache -> Cache -> Bool
$c/= :: Cache -> Cache -> Bool
== :: Cache -> Cache -> Bool
$c== :: Cache -> Cache -> Bool
Eq)
instance SP.ManagedPtrNewtype Cache where
toManagedPtr :: Cache -> ManagedPtr Cache
toManagedPtr (Cache ManagedPtr Cache
p) = ManagedPtr Cache
p
foreign import ccall "soup_cache_get_type"
c_soup_cache_get_type :: IO B.Types.GType
instance B.Types.TypedObject Cache where
glibType :: IO GType
glibType = IO GType
c_soup_cache_get_type
instance B.Types.GObject Cache
instance B.GValue.IsGValue Cache where
toGValue :: Cache -> IO GValue
toGValue Cache
o = do
GType
gtype <- IO GType
c_soup_cache_get_type
Cache -> (Ptr Cache -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Cache
o (GType -> (GValue -> Ptr Cache -> IO ()) -> Ptr Cache -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Cache -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Cache
fromGValue GValue
gv = do
Ptr Cache
ptr <- GValue -> IO (Ptr Cache)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Cache)
(ManagedPtr Cache -> Cache) -> Ptr Cache -> IO Cache
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Cache -> Cache
Cache Ptr Cache
ptr
class (SP.GObject o, O.IsDescendantOf Cache o) => IsCache o
instance (SP.GObject o, O.IsDescendantOf Cache o) => IsCache o
instance O.HasParentTypes Cache
type instance O.ParentTypes Cache = '[GObject.Object.Object, Soup.SessionFeature.SessionFeature]
toCache :: (MonadIO m, IsCache o) => o -> m Cache
toCache :: o -> m Cache
toCache = IO Cache -> m Cache
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Cache -> m Cache) -> (o -> IO Cache) -> o -> m Cache
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Cache -> Cache) -> o -> IO Cache
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Cache -> Cache
Cache
#if defined(ENABLE_OVERLOADING)
type family ResolveCacheMethod (t :: Symbol) (o :: *) :: * where
ResolveCacheMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
ResolveCacheMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo
ResolveCacheMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveCacheMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveCacheMethod "clear" o = CacheClearMethodInfo
ResolveCacheMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo
ResolveCacheMethod "dump" o = CacheDumpMethodInfo
ResolveCacheMethod "flush" o = CacheFlushMethodInfo
ResolveCacheMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveCacheMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveCacheMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveCacheMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
ResolveCacheMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveCacheMethod "load" o = CacheLoadMethodInfo
ResolveCacheMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveCacheMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveCacheMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveCacheMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveCacheMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
ResolveCacheMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveCacheMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveCacheMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveCacheMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveCacheMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveCacheMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveCacheMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveCacheMethod "getMaxSize" o = CacheGetMaxSizeMethodInfo
ResolveCacheMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveCacheMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveCacheMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveCacheMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveCacheMethod "setMaxSize" o = CacheSetMaxSizeMethodInfo
ResolveCacheMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCacheMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCacheMethod t Cache, O.MethodInfo info Cache p) => OL.IsLabel t (Cache -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
getCacheCacheDir :: (MonadIO m, IsCache o) => o -> m (Maybe T.Text)
getCacheCacheDir :: o -> m (Maybe Text)
getCacheCacheDir o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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
"cache-dir"
constructCacheCacheDir :: (IsCache o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructCacheCacheDir :: Text -> m (GValueConstruct o)
constructCacheCacheDir 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
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"cache-dir" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data CacheCacheDirPropertyInfo
instance AttrInfo CacheCacheDirPropertyInfo where
type AttrAllowedOps CacheCacheDirPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint CacheCacheDirPropertyInfo = IsCache
type AttrSetTypeConstraint CacheCacheDirPropertyInfo = (~) T.Text
type AttrTransferTypeConstraint CacheCacheDirPropertyInfo = (~) T.Text
type AttrTransferType CacheCacheDirPropertyInfo = T.Text
type AttrGetType CacheCacheDirPropertyInfo = (Maybe T.Text)
type AttrLabel CacheCacheDirPropertyInfo = "cache-dir"
type AttrOrigin CacheCacheDirPropertyInfo = Cache
attrGet = getCacheCacheDir
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructCacheCacheDir
attrClear = undefined
#endif
getCacheCacheType :: (MonadIO m, IsCache o) => o -> m Soup.Enums.CacheType
getCacheCacheType :: o -> m CacheType
getCacheCacheType o
obj = IO CacheType -> m CacheType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CacheType -> m CacheType) -> IO CacheType -> m CacheType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO CacheType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"cache-type"
constructCacheCacheType :: (IsCache o, MIO.MonadIO m) => Soup.Enums.CacheType -> m (GValueConstruct o)
constructCacheCacheType :: CacheType -> m (GValueConstruct o)
constructCacheCacheType CacheType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> CacheType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"cache-type" CacheType
val
#if defined(ENABLE_OVERLOADING)
data CacheCacheTypePropertyInfo
instance AttrInfo CacheCacheTypePropertyInfo where
type AttrAllowedOps CacheCacheTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint CacheCacheTypePropertyInfo = IsCache
type AttrSetTypeConstraint CacheCacheTypePropertyInfo = (~) Soup.Enums.CacheType
type AttrTransferTypeConstraint CacheCacheTypePropertyInfo = (~) Soup.Enums.CacheType
type AttrTransferType CacheCacheTypePropertyInfo = Soup.Enums.CacheType
type AttrGetType CacheCacheTypePropertyInfo = Soup.Enums.CacheType
type AttrLabel CacheCacheTypePropertyInfo = "cache-type"
type AttrOrigin CacheCacheTypePropertyInfo = Cache
attrGet = getCacheCacheType
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructCacheCacheType
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Cache
type instance O.AttributeList Cache = CacheAttributeList
type CacheAttributeList = ('[ '("cacheDir", CacheCacheDirPropertyInfo), '("cacheType", CacheCacheTypePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
cacheCacheDir :: AttrLabelProxy "cacheDir"
cacheCacheDir = AttrLabelProxy
cacheCacheType :: AttrLabelProxy "cacheType"
cacheCacheType = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Cache = CacheSignalList
type CacheSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_cache_new" soup_cache_new ::
CString ->
CUInt ->
IO (Ptr Cache)
cacheNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> Soup.Enums.CacheType
-> m Cache
cacheNew :: Maybe Text -> CacheType -> m Cache
cacheNew Maybe Text
cacheDir CacheType
cacheType = IO Cache -> m Cache
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Cache -> m Cache) -> IO Cache -> m Cache
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeCacheDir <- case Maybe Text
cacheDir of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jCacheDir -> do
Ptr CChar
jCacheDir' <- Text -> IO (Ptr CChar)
textToCString Text
jCacheDir
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jCacheDir'
let cacheType' :: CUInt
cacheType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (CacheType -> Int) -> CacheType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CacheType -> Int
forall a. Enum a => a -> Int
fromEnum) CacheType
cacheType
Ptr Cache
result <- Ptr CChar -> CUInt -> IO (Ptr Cache)
soup_cache_new Ptr CChar
maybeCacheDir CUInt
cacheType'
Text -> Ptr Cache -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"cacheNew" Ptr Cache
result
Cache
result' <- ((ManagedPtr Cache -> Cache) -> Ptr Cache -> IO Cache
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Cache -> Cache
Cache) Ptr Cache
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeCacheDir
Cache -> IO Cache
forall (m :: * -> *) a. Monad m => a -> m a
return Cache
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_cache_clear" soup_cache_clear ::
Ptr Cache ->
IO ()
cacheClear ::
(B.CallStack.HasCallStack, MonadIO m, IsCache a) =>
a
-> m ()
cacheClear :: a -> m ()
cacheClear a
cache = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cache
cache' <- a -> IO (Ptr Cache)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cache
Ptr Cache -> IO ()
soup_cache_clear Ptr Cache
cache'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cache
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CacheClearMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCache a) => O.MethodInfo CacheClearMethodInfo a signature where
overloadedMethod = cacheClear
#endif
foreign import ccall "soup_cache_dump" soup_cache_dump ::
Ptr Cache ->
IO ()
cacheDump ::
(B.CallStack.HasCallStack, MonadIO m, IsCache a) =>
a
-> m ()
cacheDump :: a -> m ()
cacheDump a
cache = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cache
cache' <- a -> IO (Ptr Cache)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cache
Ptr Cache -> IO ()
soup_cache_dump Ptr Cache
cache'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cache
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CacheDumpMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCache a) => O.MethodInfo CacheDumpMethodInfo a signature where
overloadedMethod = cacheDump
#endif
foreign import ccall "soup_cache_flush" soup_cache_flush ::
Ptr Cache ->
IO ()
cacheFlush ::
(B.CallStack.HasCallStack, MonadIO m, IsCache a) =>
a
-> m ()
cacheFlush :: a -> m ()
cacheFlush a
cache = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cache
cache' <- a -> IO (Ptr Cache)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cache
Ptr Cache -> IO ()
soup_cache_flush Ptr Cache
cache'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cache
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CacheFlushMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCache a) => O.MethodInfo CacheFlushMethodInfo a signature where
overloadedMethod = cacheFlush
#endif
foreign import ccall "soup_cache_get_max_size" soup_cache_get_max_size ::
Ptr Cache ->
IO Word32
cacheGetMaxSize ::
(B.CallStack.HasCallStack, MonadIO m, IsCache a) =>
a
-> m Word32
cacheGetMaxSize :: a -> m Word32
cacheGetMaxSize a
cache = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Cache
cache' <- a -> IO (Ptr Cache)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cache
Word32
result <- Ptr Cache -> IO Word32
soup_cache_get_max_size Ptr Cache
cache'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cache
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data CacheGetMaxSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCache a) => O.MethodInfo CacheGetMaxSizeMethodInfo a signature where
overloadedMethod = cacheGetMaxSize
#endif
foreign import ccall "soup_cache_load" soup_cache_load ::
Ptr Cache ->
IO ()
cacheLoad ::
(B.CallStack.HasCallStack, MonadIO m, IsCache a) =>
a
-> m ()
cacheLoad :: a -> m ()
cacheLoad a
cache = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cache
cache' <- a -> IO (Ptr Cache)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cache
Ptr Cache -> IO ()
soup_cache_load Ptr Cache
cache'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cache
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CacheLoadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCache a) => O.MethodInfo CacheLoadMethodInfo a signature where
overloadedMethod = cacheLoad
#endif
foreign import ccall "soup_cache_set_max_size" soup_cache_set_max_size ::
Ptr Cache ->
Word32 ->
IO ()
cacheSetMaxSize ::
(B.CallStack.HasCallStack, MonadIO m, IsCache a) =>
a
-> Word32
-> m ()
cacheSetMaxSize :: a -> Word32 -> m ()
cacheSetMaxSize a
cache Word32
maxSize = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Cache
cache' <- a -> IO (Ptr Cache)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
cache
Ptr Cache -> Word32 -> IO ()
soup_cache_set_max_size Ptr Cache
cache' Word32
maxSize
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
cache
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CacheSetMaxSizeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsCache a) => O.MethodInfo CacheSetMaxSizeMethodInfo a signature where
overloadedMethod = cacheSetMaxSize
#endif