#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Callbacks
(
C_RepoCheckoutFilter ,
RepoCheckoutFilter ,
RepoCheckoutFilter_WithClosures ,
drop_closures_RepoCheckoutFilter ,
dynamic_RepoCheckoutFilter ,
genClosure_RepoCheckoutFilter ,
mk_RepoCheckoutFilter ,
noRepoCheckoutFilter ,
noRepoCheckoutFilter_WithClosures ,
wrap_RepoCheckoutFilter ,
C_RepoCommitFilter ,
RepoCommitFilter ,
RepoCommitFilter_WithClosures ,
drop_closures_RepoCommitFilter ,
dynamic_RepoCommitFilter ,
genClosure_RepoCommitFilter ,
mk_RepoCommitFilter ,
noRepoCommitFilter ,
noRepoCommitFilter_WithClosures ,
wrap_RepoCommitFilter ,
C_RepoCommitModifierXattrCallback ,
RepoCommitModifierXattrCallback ,
RepoCommitModifierXattrCallback_WithClosures,
drop_closures_RepoCommitModifierXattrCallback,
dynamic_RepoCommitModifierXattrCallback ,
genClosure_RepoCommitModifierXattrCallback,
mk_RepoCommitModifierXattrCallback ,
noRepoCommitModifierXattrCallback ,
noRepoCommitModifierXattrCallback_WithClosures,
wrap_RepoCommitModifierXattrCallback ,
C_RepoImportArchiveTranslatePathname ,
RepoImportArchiveTranslatePathname ,
RepoImportArchiveTranslatePathname_WithClosures,
drop_closures_RepoImportArchiveTranslatePathname,
dynamic_RepoImportArchiveTranslatePathname,
genClosure_RepoImportArchiveTranslatePathname,
mk_RepoImportArchiveTranslatePathname ,
noRepoImportArchiveTranslatePathname ,
noRepoImportArchiveTranslatePathname_WithClosures,
wrap_RepoImportArchiveTranslatePathname ,
) 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.Gio.Objects.FileInfo as Gio.FileInfo
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
type C_RepoImportArchiveTranslatePathname =
Ptr OSTree.Repo.Repo ->
Ptr () ->
CString ->
Ptr () ->
IO CString
foreign import ccall "dynamic" __dynamic_C_RepoImportArchiveTranslatePathname :: FunPtr C_RepoImportArchiveTranslatePathname -> C_RepoImportArchiveTranslatePathname
dynamic_RepoImportArchiveTranslatePathname ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
FunPtr C_RepoImportArchiveTranslatePathname
-> a
-> Ptr ()
-> T.Text
-> Ptr ()
-> m T.Text
dynamic_RepoImportArchiveTranslatePathname :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
FunPtr C_RepoImportArchiveTranslatePathname
-> a -> Ptr () -> Text -> Ptr () -> m Text
dynamic_RepoImportArchiveTranslatePathname FunPtr C_RepoImportArchiveTranslatePathname
__funPtr a
repo Ptr ()
stbuf Text
srcPath Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
CString
srcPath' <- Text -> IO CString
textToCString Text
srcPath
CString
result <- (FunPtr C_RepoImportArchiveTranslatePathname
-> C_RepoImportArchiveTranslatePathname
__dynamic_C_RepoImportArchiveTranslatePathname FunPtr C_RepoImportArchiveTranslatePathname
__funPtr) Ptr Repo
repo' Ptr ()
stbuf CString
srcPath' Ptr ()
userData
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoImportArchiveTranslatePathname" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
forall a. Ptr a -> IO ()
freeMem CString
srcPath'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "wrapper"
mk_RepoImportArchiveTranslatePathname :: C_RepoImportArchiveTranslatePathname -> IO (FunPtr C_RepoImportArchiveTranslatePathname)
type RepoImportArchiveTranslatePathname =
OSTree.Repo.Repo
-> Ptr ()
-> T.Text
-> IO T.Text
noRepoImportArchiveTranslatePathname :: Maybe RepoImportArchiveTranslatePathname
noRepoImportArchiveTranslatePathname :: Maybe RepoImportArchiveTranslatePathname
noRepoImportArchiveTranslatePathname = forall a. Maybe a
Nothing
type RepoImportArchiveTranslatePathname_WithClosures =
OSTree.Repo.Repo
-> Ptr ()
-> T.Text
-> Ptr ()
-> IO T.Text
noRepoImportArchiveTranslatePathname_WithClosures :: Maybe RepoImportArchiveTranslatePathname_WithClosures
noRepoImportArchiveTranslatePathname_WithClosures :: Maybe RepoImportArchiveTranslatePathname_WithClosures
noRepoImportArchiveTranslatePathname_WithClosures = forall a. Maybe a
Nothing
drop_closures_RepoImportArchiveTranslatePathname :: RepoImportArchiveTranslatePathname -> RepoImportArchiveTranslatePathname_WithClosures
drop_closures_RepoImportArchiveTranslatePathname :: RepoImportArchiveTranslatePathname
-> RepoImportArchiveTranslatePathname_WithClosures
drop_closures_RepoImportArchiveTranslatePathname RepoImportArchiveTranslatePathname
_f Repo
repo Ptr ()
stbuf Text
srcPath Ptr ()
_ = RepoImportArchiveTranslatePathname
_f Repo
repo Ptr ()
stbuf Text
srcPath
genClosure_RepoImportArchiveTranslatePathname :: MonadIO m => RepoImportArchiveTranslatePathname -> m (GClosure C_RepoImportArchiveTranslatePathname)
genClosure_RepoImportArchiveTranslatePathname :: forall (m :: * -> *).
MonadIO m =>
RepoImportArchiveTranslatePathname
-> m (GClosure C_RepoImportArchiveTranslatePathname)
genClosure_RepoImportArchiveTranslatePathname RepoImportArchiveTranslatePathname
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: RepoImportArchiveTranslatePathname_WithClosures
cb' = RepoImportArchiveTranslatePathname
-> RepoImportArchiveTranslatePathname_WithClosures
drop_closures_RepoImportArchiveTranslatePathname RepoImportArchiveTranslatePathname
cb
let cb'' :: C_RepoImportArchiveTranslatePathname
cb'' = Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
-> RepoImportArchiveTranslatePathname_WithClosures
-> C_RepoImportArchiveTranslatePathname
wrap_RepoImportArchiveTranslatePathname forall a. Maybe a
Nothing RepoImportArchiveTranslatePathname_WithClosures
cb'
C_RepoImportArchiveTranslatePathname
-> IO (FunPtr C_RepoImportArchiveTranslatePathname)
mk_RepoImportArchiveTranslatePathname C_RepoImportArchiveTranslatePathname
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RepoImportArchiveTranslatePathname ::
Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname)) ->
RepoImportArchiveTranslatePathname_WithClosures ->
C_RepoImportArchiveTranslatePathname
wrap_RepoImportArchiveTranslatePathname :: Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
-> RepoImportArchiveTranslatePathname_WithClosures
-> C_RepoImportArchiveTranslatePathname
wrap_RepoImportArchiveTranslatePathname Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
gi'funptrptr RepoImportArchiveTranslatePathname_WithClosures
gi'cb Ptr Repo
repo Ptr ()
stbuf CString
srcPath Ptr ()
userData = do
Repo
repo' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
Text
srcPath' <- HasCallStack => CString -> IO Text
cstringToText CString
srcPath
Text
result <- RepoImportArchiveTranslatePathname_WithClosures
gi'cb Repo
repo' Ptr ()
stbuf Text
srcPath' Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
gi'funptrptr
CString
result' <- Text -> IO CString
textToCString Text
result
forall (m :: * -> *) a. Monad m => a -> m a
return CString
result'
type C_RepoCommitModifierXattrCallback =
Ptr OSTree.Repo.Repo ->
CString ->
Ptr Gio.FileInfo.FileInfo ->
Ptr () ->
IO (Ptr GVariant)
foreign import ccall "dynamic" __dynamic_C_RepoCommitModifierXattrCallback :: FunPtr C_RepoCommitModifierXattrCallback -> C_RepoCommitModifierXattrCallback
dynamic_RepoCommitModifierXattrCallback ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) =>
FunPtr C_RepoCommitModifierXattrCallback
-> a
-> T.Text
-> b
-> Ptr ()
-> m GVariant
dynamic_RepoCommitModifierXattrCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsFileInfo b) =>
FunPtr C_RepoCommitModifierXattrCallback
-> a -> Text -> b -> Ptr () -> m GVariant
dynamic_RepoCommitModifierXattrCallback FunPtr C_RepoCommitModifierXattrCallback
__funPtr a
repo Text
path b
fileInfo Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
CString
path' <- Text -> IO CString
textToCString Text
path
Ptr FileInfo
fileInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
fileInfo
Ptr GVariant
result <- (FunPtr C_RepoCommitModifierXattrCallback
-> C_RepoCommitModifierXattrCallback
__dynamic_C_RepoCommitModifierXattrCallback FunPtr C_RepoCommitModifierXattrCallback
__funPtr) Ptr Repo
repo' CString
path' Ptr FileInfo
fileInfo' Ptr ()
userData
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoCommitModifierXattrCallback" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
fileInfo
forall a. Ptr a -> IO ()
freeMem CString
path'
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "wrapper"
mk_RepoCommitModifierXattrCallback :: C_RepoCommitModifierXattrCallback -> IO (FunPtr C_RepoCommitModifierXattrCallback)
type RepoCommitModifierXattrCallback =
OSTree.Repo.Repo
-> T.Text
-> Gio.FileInfo.FileInfo
-> IO GVariant
noRepoCommitModifierXattrCallback :: Maybe RepoCommitModifierXattrCallback
noRepoCommitModifierXattrCallback :: Maybe RepoCommitModifierXattrCallback
noRepoCommitModifierXattrCallback = forall a. Maybe a
Nothing
type RepoCommitModifierXattrCallback_WithClosures =
OSTree.Repo.Repo
-> T.Text
-> Gio.FileInfo.FileInfo
-> Ptr ()
-> IO GVariant
noRepoCommitModifierXattrCallback_WithClosures :: Maybe RepoCommitModifierXattrCallback_WithClosures
noRepoCommitModifierXattrCallback_WithClosures :: Maybe RepoCommitModifierXattrCallback_WithClosures
noRepoCommitModifierXattrCallback_WithClosures = forall a. Maybe a
Nothing
drop_closures_RepoCommitModifierXattrCallback :: RepoCommitModifierXattrCallback -> RepoCommitModifierXattrCallback_WithClosures
drop_closures_RepoCommitModifierXattrCallback :: RepoCommitModifierXattrCallback
-> RepoCommitModifierXattrCallback_WithClosures
drop_closures_RepoCommitModifierXattrCallback RepoCommitModifierXattrCallback
_f Repo
repo Text
path FileInfo
fileInfo Ptr ()
_ = RepoCommitModifierXattrCallback
_f Repo
repo Text
path FileInfo
fileInfo
genClosure_RepoCommitModifierXattrCallback :: MonadIO m => RepoCommitModifierXattrCallback -> m (GClosure C_RepoCommitModifierXattrCallback)
genClosure_RepoCommitModifierXattrCallback :: forall (m :: * -> *).
MonadIO m =>
RepoCommitModifierXattrCallback
-> m (GClosure C_RepoCommitModifierXattrCallback)
genClosure_RepoCommitModifierXattrCallback RepoCommitModifierXattrCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: RepoCommitModifierXattrCallback_WithClosures
cb' = RepoCommitModifierXattrCallback
-> RepoCommitModifierXattrCallback_WithClosures
drop_closures_RepoCommitModifierXattrCallback RepoCommitModifierXattrCallback
cb
let cb'' :: C_RepoCommitModifierXattrCallback
cb'' = Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
-> RepoCommitModifierXattrCallback_WithClosures
-> C_RepoCommitModifierXattrCallback
wrap_RepoCommitModifierXattrCallback forall a. Maybe a
Nothing RepoCommitModifierXattrCallback_WithClosures
cb'
C_RepoCommitModifierXattrCallback
-> IO (FunPtr C_RepoCommitModifierXattrCallback)
mk_RepoCommitModifierXattrCallback C_RepoCommitModifierXattrCallback
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RepoCommitModifierXattrCallback ::
Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback)) ->
RepoCommitModifierXattrCallback_WithClosures ->
C_RepoCommitModifierXattrCallback
wrap_RepoCommitModifierXattrCallback :: Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
-> RepoCommitModifierXattrCallback_WithClosures
-> C_RepoCommitModifierXattrCallback
wrap_RepoCommitModifierXattrCallback Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
gi'funptrptr RepoCommitModifierXattrCallback_WithClosures
gi'cb Ptr Repo
repo CString
path Ptr FileInfo
fileInfo Ptr ()
userData = do
Repo
repo' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
Text
path' <- HasCallStack => CString -> IO Text
cstringToText CString
path
FileInfo
fileInfo' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
fileInfo
GVariant
result <- RepoCommitModifierXattrCallback_WithClosures
gi'cb Repo
repo' Text
path' FileInfo
fileInfo' Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
gi'funptrptr
Ptr GVariant
result' <- GVariant -> IO (Ptr GVariant)
B.GVariant.disownGVariant GVariant
result
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
result'
type C_RepoCommitFilter =
Ptr OSTree.Repo.Repo ->
CString ->
Ptr Gio.FileInfo.FileInfo ->
Ptr () ->
IO CUInt
foreign import ccall "dynamic" __dynamic_C_RepoCommitFilter :: FunPtr C_RepoCommitFilter -> C_RepoCommitFilter
dynamic_RepoCommitFilter ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) =>
FunPtr C_RepoCommitFilter
-> a
-> T.Text
-> b
-> Ptr ()
-> m OSTree.Enums.RepoCommitFilterResult
dynamic_RepoCommitFilter :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsFileInfo b) =>
FunPtr C_RepoCommitFilter
-> a -> Text -> b -> Ptr () -> m RepoCommitFilterResult
dynamic_RepoCommitFilter FunPtr C_RepoCommitFilter
__funPtr a
repo Text
path b
fileInfo Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
CString
path' <- Text -> IO CString
textToCString Text
path
Ptr FileInfo
fileInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
fileInfo
CUInt
result <- (FunPtr C_RepoCommitFilter -> C_RepoCommitFilter
__dynamic_C_RepoCommitFilter FunPtr C_RepoCommitFilter
__funPtr) Ptr Repo
repo' CString
path' Ptr FileInfo
fileInfo' Ptr ()
userData
let result' :: RepoCommitFilterResult
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
fileInfo
forall a. Ptr a -> IO ()
freeMem CString
path'
forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitFilterResult
result'
foreign import ccall "wrapper"
mk_RepoCommitFilter :: C_RepoCommitFilter -> IO (FunPtr C_RepoCommitFilter)
type RepoCommitFilter =
OSTree.Repo.Repo
-> T.Text
-> Gio.FileInfo.FileInfo
-> IO OSTree.Enums.RepoCommitFilterResult
noRepoCommitFilter :: Maybe RepoCommitFilter
noRepoCommitFilter :: Maybe RepoCommitFilter
noRepoCommitFilter = forall a. Maybe a
Nothing
type RepoCommitFilter_WithClosures =
OSTree.Repo.Repo
-> T.Text
-> Gio.FileInfo.FileInfo
-> Ptr ()
-> IO OSTree.Enums.RepoCommitFilterResult
noRepoCommitFilter_WithClosures :: Maybe RepoCommitFilter_WithClosures
noRepoCommitFilter_WithClosures :: Maybe RepoCommitFilter_WithClosures
noRepoCommitFilter_WithClosures = forall a. Maybe a
Nothing
drop_closures_RepoCommitFilter :: RepoCommitFilter -> RepoCommitFilter_WithClosures
drop_closures_RepoCommitFilter :: RepoCommitFilter -> RepoCommitFilter_WithClosures
drop_closures_RepoCommitFilter RepoCommitFilter
_f Repo
repo Text
path FileInfo
fileInfo Ptr ()
_ = RepoCommitFilter
_f Repo
repo Text
path FileInfo
fileInfo
genClosure_RepoCommitFilter :: MonadIO m => RepoCommitFilter -> m (GClosure C_RepoCommitFilter)
genClosure_RepoCommitFilter :: forall (m :: * -> *).
MonadIO m =>
RepoCommitFilter -> m (GClosure C_RepoCommitFilter)
genClosure_RepoCommitFilter RepoCommitFilter
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: RepoCommitFilter_WithClosures
cb' = RepoCommitFilter -> RepoCommitFilter_WithClosures
drop_closures_RepoCommitFilter RepoCommitFilter
cb
let cb'' :: C_RepoCommitFilter
cb'' = Maybe (Ptr (FunPtr C_RepoCommitFilter))
-> RepoCommitFilter_WithClosures -> C_RepoCommitFilter
wrap_RepoCommitFilter forall a. Maybe a
Nothing RepoCommitFilter_WithClosures
cb'
C_RepoCommitFilter -> IO (FunPtr C_RepoCommitFilter)
mk_RepoCommitFilter C_RepoCommitFilter
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RepoCommitFilter ::
Maybe (Ptr (FunPtr C_RepoCommitFilter)) ->
RepoCommitFilter_WithClosures ->
C_RepoCommitFilter
wrap_RepoCommitFilter :: Maybe (Ptr (FunPtr C_RepoCommitFilter))
-> RepoCommitFilter_WithClosures -> C_RepoCommitFilter
wrap_RepoCommitFilter Maybe (Ptr (FunPtr C_RepoCommitFilter))
gi'funptrptr RepoCommitFilter_WithClosures
gi'cb Ptr Repo
repo CString
path Ptr FileInfo
fileInfo Ptr ()
userData = do
Repo
repo' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
Text
path' <- HasCallStack => CString -> IO Text
cstringToText CString
path
FileInfo
fileInfo' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
fileInfo
RepoCommitFilterResult
result <- RepoCommitFilter_WithClosures
gi'cb Repo
repo' Text
path' FileInfo
fileInfo' Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_RepoCommitFilter))
gi'funptrptr
let result' :: CUInt
result' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoCommitFilterResult
result
forall (m :: * -> *) a. Monad m => a -> m a
return CUInt
result'
type C_RepoCheckoutFilter =
Ptr OSTree.Repo.Repo ->
CString ->
Ptr () ->
Ptr () ->
IO CUInt
foreign import ccall "dynamic" __dynamic_C_RepoCheckoutFilter :: FunPtr C_RepoCheckoutFilter -> C_RepoCheckoutFilter
dynamic_RepoCheckoutFilter ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
FunPtr C_RepoCheckoutFilter
-> a
-> T.Text
-> Ptr ()
-> Ptr ()
-> m OSTree.Enums.RepoCheckoutFilterResult
dynamic_RepoCheckoutFilter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
FunPtr C_RepoCheckoutFilter
-> a -> Text -> Ptr () -> Ptr () -> m RepoCheckoutFilterResult
dynamic_RepoCheckoutFilter FunPtr C_RepoCheckoutFilter
__funPtr a
repo Text
path Ptr ()
stbuf Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
CString
path' <- Text -> IO CString
textToCString Text
path
CUInt
result <- (FunPtr C_RepoCheckoutFilter -> C_RepoCheckoutFilter
__dynamic_C_RepoCheckoutFilter FunPtr C_RepoCheckoutFilter
__funPtr) Ptr Repo
repo' CString
path' Ptr ()
stbuf Ptr ()
userData
let result' :: RepoCheckoutFilterResult
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
forall a. Ptr a -> IO ()
freeMem CString
path'
forall (m :: * -> *) a. Monad m => a -> m a
return RepoCheckoutFilterResult
result'
foreign import ccall "wrapper"
mk_RepoCheckoutFilter :: C_RepoCheckoutFilter -> IO (FunPtr C_RepoCheckoutFilter)
type RepoCheckoutFilter =
OSTree.Repo.Repo
-> T.Text
-> Ptr ()
-> IO OSTree.Enums.RepoCheckoutFilterResult
noRepoCheckoutFilter :: Maybe RepoCheckoutFilter
noRepoCheckoutFilter :: Maybe RepoCheckoutFilter
noRepoCheckoutFilter = forall a. Maybe a
Nothing
type RepoCheckoutFilter_WithClosures =
OSTree.Repo.Repo
-> T.Text
-> Ptr ()
-> Ptr ()
-> IO OSTree.Enums.RepoCheckoutFilterResult
noRepoCheckoutFilter_WithClosures :: Maybe RepoCheckoutFilter_WithClosures
noRepoCheckoutFilter_WithClosures :: Maybe RepoCheckoutFilter_WithClosures
noRepoCheckoutFilter_WithClosures = forall a. Maybe a
Nothing
drop_closures_RepoCheckoutFilter :: RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures
drop_closures_RepoCheckoutFilter :: RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures
drop_closures_RepoCheckoutFilter RepoCheckoutFilter
_f Repo
repo Text
path Ptr ()
stbuf Ptr ()
_ = RepoCheckoutFilter
_f Repo
repo Text
path Ptr ()
stbuf
genClosure_RepoCheckoutFilter :: MonadIO m => RepoCheckoutFilter -> m (GClosure C_RepoCheckoutFilter)
genClosure_RepoCheckoutFilter :: forall (m :: * -> *).
MonadIO m =>
RepoCheckoutFilter -> m (GClosure C_RepoCheckoutFilter)
genClosure_RepoCheckoutFilter RepoCheckoutFilter
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: RepoCheckoutFilter_WithClosures
cb' = RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures
drop_closures_RepoCheckoutFilter RepoCheckoutFilter
cb
let cb'' :: C_RepoCheckoutFilter
cb'' = Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
-> RepoCheckoutFilter_WithClosures -> C_RepoCheckoutFilter
wrap_RepoCheckoutFilter forall a. Maybe a
Nothing RepoCheckoutFilter_WithClosures
cb'
C_RepoCheckoutFilter -> IO (FunPtr C_RepoCheckoutFilter)
mk_RepoCheckoutFilter C_RepoCheckoutFilter
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RepoCheckoutFilter ::
Maybe (Ptr (FunPtr C_RepoCheckoutFilter)) ->
RepoCheckoutFilter_WithClosures ->
C_RepoCheckoutFilter
wrap_RepoCheckoutFilter :: Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
-> RepoCheckoutFilter_WithClosures -> C_RepoCheckoutFilter
wrap_RepoCheckoutFilter Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
gi'funptrptr RepoCheckoutFilter_WithClosures
gi'cb Ptr Repo
repo CString
path Ptr ()
stbuf Ptr ()
userData = do
Repo
repo' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
Text
path' <- HasCallStack => CString -> IO Text
cstringToText CString
path
RepoCheckoutFilterResult
result <- RepoCheckoutFilter_WithClosures
gi'cb Repo
repo' Text
path' Ptr ()
stbuf Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
gi'funptrptr
let result' :: CUInt
result' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoCheckoutFilterResult
result
forall (m :: * -> *) a. Monad m => a -> m a
return CUInt
result'