{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Structs.RepoCommitModifier
(
RepoCommitModifier(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveRepoCommitModifierMethod ,
#endif
repoCommitModifierNew ,
#if defined(ENABLE_OVERLOADING)
RepoCommitModifierRefMethodInfo ,
#endif
repoCommitModifierRef ,
#if defined(ENABLE_OVERLOADING)
RepoCommitModifierSetDevinoCacheMethodInfo,
#endif
repoCommitModifierSetDevinoCache ,
#if defined(ENABLE_OVERLOADING)
RepoCommitModifierSetSepolicyMethodInfo ,
#endif
repoCommitModifierSetSepolicy ,
#if defined(ENABLE_OVERLOADING)
RepoCommitModifierSetSepolicyFromCommitMethodInfo,
#endif
repoCommitModifierSetSepolicyFromCommit ,
#if defined(ENABLE_OVERLOADING)
RepoCommitModifierSetXattrCallbackMethodInfo,
#endif
repoCommitModifierSetXattrCallback ,
#if defined(ENABLE_OVERLOADING)
RepoCommitModifierUnrefMethodInfo ,
#endif
repoCommitModifierUnref ,
) 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.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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.GLib.Callbacks as GLib.Callbacks
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.OSTree.Callbacks as OSTree.Callbacks
import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
import {-# SOURCE #-} qualified GI.OSTree.Objects.SePolicy as OSTree.SePolicy
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoDevInoCache as OSTree.RepoDevInoCache
newtype RepoCommitModifier = RepoCommitModifier (SP.ManagedPtr RepoCommitModifier)
deriving (RepoCommitModifier -> RepoCommitModifier -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitModifier -> RepoCommitModifier -> Bool
$c/= :: RepoCommitModifier -> RepoCommitModifier -> Bool
== :: RepoCommitModifier -> RepoCommitModifier -> Bool
$c== :: RepoCommitModifier -> RepoCommitModifier -> Bool
Eq)
instance SP.ManagedPtrNewtype RepoCommitModifier where
toManagedPtr :: RepoCommitModifier -> ManagedPtr RepoCommitModifier
toManagedPtr (RepoCommitModifier ManagedPtr RepoCommitModifier
p) = ManagedPtr RepoCommitModifier
p
foreign import ccall "ostree_repo_commit_modifier_get_type" c_ostree_repo_commit_modifier_get_type ::
IO GType
type instance O.ParentTypes RepoCommitModifier = '[]
instance O.HasParentTypes RepoCommitModifier
instance B.Types.TypedObject RepoCommitModifier where
glibType :: IO GType
glibType = IO GType
c_ostree_repo_commit_modifier_get_type
instance B.Types.GBoxed RepoCommitModifier
instance B.GValue.IsGValue (Maybe RepoCommitModifier) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_repo_commit_modifier_get_type
gvalueSet_ :: Ptr GValue -> Maybe RepoCommitModifier -> IO ()
gvalueSet_ Ptr GValue
gv Maybe RepoCommitModifier
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr RepoCommitModifier)
gvalueSet_ Ptr GValue
gv (P.Just RepoCommitModifier
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RepoCommitModifier
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe RepoCommitModifier)
gvalueGet_ Ptr GValue
gv = do
Ptr RepoCommitModifier
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr RepoCommitModifier)
if Ptr RepoCommitModifier
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr RepoCommitModifier -> RepoCommitModifier
RepoCommitModifier Ptr RepoCommitModifier
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RepoCommitModifier
type instance O.AttributeList RepoCommitModifier = RepoCommitModifierAttributeList
type RepoCommitModifierAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "ostree_repo_commit_modifier_new" ostree_repo_commit_modifier_new ::
CUInt ->
FunPtr OSTree.Callbacks.C_RepoCommitFilter ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr RepoCommitModifier)
repoCommitModifierNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
[OSTree.Flags.RepoCommitModifierFlags]
-> Maybe (OSTree.Callbacks.RepoCommitFilter)
-> m RepoCommitModifier
repoCommitModifierNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[RepoCommitModifierFlags]
-> Maybe RepoCommitFilter -> m RepoCommitModifier
repoCommitModifierNew [RepoCommitModifierFlags]
flags Maybe RepoCommitFilter
commitFilter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitModifierFlags]
flags
FunPtr C_RepoCommitFilter
maybeCommitFilter <- case Maybe RepoCommitFilter
commitFilter of
Maybe RepoCommitFilter
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just RepoCommitFilter
jCommitFilter -> do
FunPtr C_RepoCommitFilter
jCommitFilter' <- C_RepoCommitFilter -> IO (FunPtr C_RepoCommitFilter)
OSTree.Callbacks.mk_RepoCommitFilter (Maybe (Ptr (FunPtr C_RepoCommitFilter))
-> RepoCommitFilter_WithClosures -> C_RepoCommitFilter
OSTree.Callbacks.wrap_RepoCommitFilter forall a. Maybe a
Nothing (RepoCommitFilter -> RepoCommitFilter_WithClosures
OSTree.Callbacks.drop_closures_RepoCommitFilter RepoCommitFilter
jCommitFilter))
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_RepoCommitFilter
jCommitFilter'
let userData :: Ptr ()
userData = forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_RepoCommitFilter
maybeCommitFilter
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr RepoCommitModifier
result <- CUInt
-> FunPtr C_RepoCommitFilter
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO (Ptr RepoCommitModifier)
ostree_repo_commit_modifier_new CUInt
flags' FunPtr C_RepoCommitFilter
maybeCommitFilter Ptr ()
userData forall a. FunPtr (Ptr a -> IO ())
destroyNotify
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoCommitModifierNew" Ptr RepoCommitModifier
result
RepoCommitModifier
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RepoCommitModifier -> RepoCommitModifier
RepoCommitModifier) Ptr RepoCommitModifier
result
forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitModifier
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ostree_repo_commit_modifier_ref" ostree_repo_commit_modifier_ref ::
Ptr RepoCommitModifier ->
IO (Ptr RepoCommitModifier)
repoCommitModifierRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
RepoCommitModifier
-> m RepoCommitModifier
repoCommitModifierRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitModifier -> m RepoCommitModifier
repoCommitModifierRef RepoCommitModifier
modifier = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitModifier
modifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
modifier
Ptr RepoCommitModifier
result <- Ptr RepoCommitModifier -> IO (Ptr RepoCommitModifier)
ostree_repo_commit_modifier_ref Ptr RepoCommitModifier
modifier'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoCommitModifierRef" Ptr RepoCommitModifier
result
RepoCommitModifier
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RepoCommitModifier -> RepoCommitModifier
RepoCommitModifier) Ptr RepoCommitModifier
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitModifier
modifier
forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitModifier
result'
#if defined(ENABLE_OVERLOADING)
data RepoCommitModifierRefMethodInfo
instance (signature ~ (m RepoCommitModifier), MonadIO m) => O.OverloadedMethod RepoCommitModifierRefMethodInfo RepoCommitModifier signature where
overloadedMethod = repoCommitModifierRef
instance O.OverloadedMethodInfo RepoCommitModifierRefMethodInfo RepoCommitModifier where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitModifier.repoCommitModifierRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-RepoCommitModifier.html#v:repoCommitModifierRef"
})
#endif
foreign import ccall "ostree_repo_commit_modifier_set_devino_cache" ostree_repo_commit_modifier_set_devino_cache ::
Ptr RepoCommitModifier ->
Ptr OSTree.RepoDevInoCache.RepoDevInoCache ->
IO ()
repoCommitModifierSetDevinoCache ::
(B.CallStack.HasCallStack, MonadIO m) =>
RepoCommitModifier
-> OSTree.RepoDevInoCache.RepoDevInoCache
-> m ()
repoCommitModifierSetDevinoCache :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitModifier -> RepoDevInoCache -> m ()
repoCommitModifierSetDevinoCache RepoCommitModifier
modifier RepoDevInoCache
cache = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitModifier
modifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
modifier
Ptr RepoDevInoCache
cache' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoDevInoCache
cache
Ptr RepoCommitModifier -> Ptr RepoDevInoCache -> IO ()
ostree_repo_commit_modifier_set_devino_cache Ptr RepoCommitModifier
modifier' Ptr RepoDevInoCache
cache'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitModifier
modifier
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoDevInoCache
cache
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RepoCommitModifierSetDevinoCacheMethodInfo
instance (signature ~ (OSTree.RepoDevInoCache.RepoDevInoCache -> m ()), MonadIO m) => O.OverloadedMethod RepoCommitModifierSetDevinoCacheMethodInfo RepoCommitModifier signature where
overloadedMethod = repoCommitModifierSetDevinoCache
instance O.OverloadedMethodInfo RepoCommitModifierSetDevinoCacheMethodInfo RepoCommitModifier where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitModifier.repoCommitModifierSetDevinoCache",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-RepoCommitModifier.html#v:repoCommitModifierSetDevinoCache"
})
#endif
foreign import ccall "ostree_repo_commit_modifier_set_sepolicy" ostree_repo_commit_modifier_set_sepolicy ::
Ptr RepoCommitModifier ->
Ptr OSTree.SePolicy.SePolicy ->
IO ()
repoCommitModifierSetSepolicy ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.SePolicy.IsSePolicy a) =>
RepoCommitModifier
-> Maybe (a)
-> m ()
repoCommitModifierSetSepolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSePolicy a) =>
RepoCommitModifier -> Maybe a -> m ()
repoCommitModifierSetSepolicy RepoCommitModifier
modifier Maybe a
sepolicy = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitModifier
modifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
modifier
Ptr SePolicy
maybeSepolicy <- case Maybe a
sepolicy of
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just a
jSepolicy -> do
Ptr SePolicy
jSepolicy' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSepolicy
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr SePolicy
jSepolicy'
Ptr RepoCommitModifier -> Ptr SePolicy -> IO ()
ostree_repo_commit_modifier_set_sepolicy Ptr RepoCommitModifier
modifier' Ptr SePolicy
maybeSepolicy
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitModifier
modifier
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
sepolicy forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RepoCommitModifierSetSepolicyMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, OSTree.SePolicy.IsSePolicy a) => O.OverloadedMethod RepoCommitModifierSetSepolicyMethodInfo RepoCommitModifier signature where
overloadedMethod = repoCommitModifierSetSepolicy
instance O.OverloadedMethodInfo RepoCommitModifierSetSepolicyMethodInfo RepoCommitModifier where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitModifier.repoCommitModifierSetSepolicy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-RepoCommitModifier.html#v:repoCommitModifierSetSepolicy"
})
#endif
foreign import ccall "ostree_repo_commit_modifier_set_sepolicy_from_commit" ostree_repo_commit_modifier_set_sepolicy_from_commit ::
Ptr RepoCommitModifier ->
Ptr OSTree.Repo.Repo ->
CString ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
repoCommitModifierSetSepolicyFromCommit ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) =>
RepoCommitModifier
-> a
-> T.Text
-> Maybe (b)
-> m ()
repoCommitModifierSetSepolicyFromCommit :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
RepoCommitModifier -> a -> Text -> Maybe b -> m ()
repoCommitModifierSetSepolicyFromCommit RepoCommitModifier
modifier a
repo Text
rev Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitModifier
modifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
modifier
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
CString
rev' <- Text -> IO CString
textToCString Text
rev
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr RepoCommitModifier
-> Ptr Repo
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_commit_modifier_set_sepolicy_from_commit Ptr RepoCommitModifier
modifier' Ptr Repo
repo' CString
rev' Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitModifier
modifier
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem CString
rev'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall a. Ptr a -> IO ()
freeMem CString
rev'
)
#if defined(ENABLE_OVERLOADING)
data RepoCommitModifierSetSepolicyFromCommitMethodInfo
instance (signature ~ (a -> T.Text -> Maybe (b) -> m ()), MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoCommitModifierSetSepolicyFromCommitMethodInfo RepoCommitModifier signature where
overloadedMethod = repoCommitModifierSetSepolicyFromCommit
instance O.OverloadedMethodInfo RepoCommitModifierSetSepolicyFromCommitMethodInfo RepoCommitModifier where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitModifier.repoCommitModifierSetSepolicyFromCommit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-RepoCommitModifier.html#v:repoCommitModifierSetSepolicyFromCommit"
})
#endif
foreign import ccall "ostree_repo_commit_modifier_set_xattr_callback" ostree_repo_commit_modifier_set_xattr_callback ::
Ptr RepoCommitModifier ->
FunPtr OSTree.Callbacks.C_RepoCommitModifierXattrCallback ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
Ptr () ->
IO ()
repoCommitModifierSetXattrCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
RepoCommitModifier
-> OSTree.Callbacks.RepoCommitModifierXattrCallback
-> m ()
repoCommitModifierSetXattrCallback :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitModifier -> RepoCommitModifierXattrCallback -> m ()
repoCommitModifierSetXattrCallback RepoCommitModifier
modifier RepoCommitModifierXattrCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitModifier
modifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
modifier
FunPtr C_RepoCommitModifierXattrCallback
callback' <- C_RepoCommitModifierXattrCallback
-> IO (FunPtr C_RepoCommitModifierXattrCallback)
OSTree.Callbacks.mk_RepoCommitModifierXattrCallback (Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
-> RepoCommitModifierXattrCallback_WithClosures
-> C_RepoCommitModifierXattrCallback
OSTree.Callbacks.wrap_RepoCommitModifierXattrCallback forall a. Maybe a
Nothing (RepoCommitModifierXattrCallback
-> RepoCommitModifierXattrCallback_WithClosures
OSTree.Callbacks.drop_closures_RepoCommitModifierXattrCallback RepoCommitModifierXattrCallback
callback))
let userData :: Ptr ()
userData = forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_RepoCommitModifierXattrCallback
callback'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr RepoCommitModifier
-> FunPtr C_RepoCommitModifierXattrCallback
-> FunPtr C_DestroyNotify
-> C_DestroyNotify
ostree_repo_commit_modifier_set_xattr_callback Ptr RepoCommitModifier
modifier' FunPtr C_RepoCommitModifierXattrCallback
callback' forall a. FunPtr (Ptr a -> IO ())
destroy Ptr ()
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitModifier
modifier
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RepoCommitModifierSetXattrCallbackMethodInfo
instance (signature ~ (OSTree.Callbacks.RepoCommitModifierXattrCallback -> m ()), MonadIO m) => O.OverloadedMethod RepoCommitModifierSetXattrCallbackMethodInfo RepoCommitModifier signature where
overloadedMethod = repoCommitModifierSetXattrCallback
instance O.OverloadedMethodInfo RepoCommitModifierSetXattrCallbackMethodInfo RepoCommitModifier where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitModifier.repoCommitModifierSetXattrCallback",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-RepoCommitModifier.html#v:repoCommitModifierSetXattrCallback"
})
#endif
foreign import ccall "ostree_repo_commit_modifier_unref" ostree_repo_commit_modifier_unref ::
Ptr RepoCommitModifier ->
IO ()
repoCommitModifierUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
RepoCommitModifier
-> m ()
repoCommitModifierUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitModifier -> m ()
repoCommitModifierUnref RepoCommitModifier
modifier = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitModifier
modifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
modifier
Ptr RepoCommitModifier -> IO ()
ostree_repo_commit_modifier_unref Ptr RepoCommitModifier
modifier'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitModifier
modifier
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RepoCommitModifierUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod RepoCommitModifierUnrefMethodInfo RepoCommitModifier signature where
overloadedMethod = repoCommitModifierUnref
instance O.OverloadedMethodInfo RepoCommitModifierUnrefMethodInfo RepoCommitModifier where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitModifier.repoCommitModifierUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-RepoCommitModifier.html#v:repoCommitModifierUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveRepoCommitModifierMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveRepoCommitModifierMethod "ref" o = RepoCommitModifierRefMethodInfo
ResolveRepoCommitModifierMethod "unref" o = RepoCommitModifierUnrefMethodInfo
ResolveRepoCommitModifierMethod "setDevinoCache" o = RepoCommitModifierSetDevinoCacheMethodInfo
ResolveRepoCommitModifierMethod "setSepolicy" o = RepoCommitModifierSetSepolicyMethodInfo
ResolveRepoCommitModifierMethod "setSepolicyFromCommit" o = RepoCommitModifierSetSepolicyFromCommitMethodInfo
ResolveRepoCommitModifierMethod "setXattrCallback" o = RepoCommitModifierSetXattrCallbackMethodInfo
ResolveRepoCommitModifierMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRepoCommitModifierMethod t RepoCommitModifier, O.OverloadedMethod info RepoCommitModifier p) => OL.IsLabel t (RepoCommitModifier -> 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 ~ ResolveRepoCommitModifierMethod t RepoCommitModifier, O.OverloadedMethod info RepoCommitModifier p, R.HasField t RepoCommitModifier p) => R.HasField t RepoCommitModifier p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRepoCommitModifierMethod t RepoCommitModifier, O.OverloadedMethodInfo info RepoCommitModifier) => OL.IsLabel t (O.MethodProxy info RepoCommitModifier) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif