{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Structs.RepoCommitTraverseIter
(
RepoCommitTraverseIter(..) ,
newZeroRepoCommitTraverseIter ,
#if defined(ENABLE_OVERLOADING)
ResolveRepoCommitTraverseIterMethod ,
#endif
repoCommitTraverseIterCleanup ,
#if defined(ENABLE_OVERLOADING)
RepoCommitTraverseIterClearMethodInfo ,
#endif
repoCommitTraverseIterClear ,
#if defined(ENABLE_OVERLOADING)
RepoCommitTraverseIterGetDirMethodInfo ,
#endif
repoCommitTraverseIterGetDir ,
#if defined(ENABLE_OVERLOADING)
RepoCommitTraverseIterGetFileMethodInfo ,
#endif
repoCommitTraverseIterGetFile ,
#if defined(ENABLE_OVERLOADING)
RepoCommitTraverseIterInitCommitMethodInfo,
#endif
repoCommitTraverseIterInitCommit ,
#if defined(ENABLE_OVERLOADING)
RepoCommitTraverseIterInitDirtreeMethodInfo,
#endif
repoCommitTraverseIterInitDirtree ,
#if defined(ENABLE_OVERLOADING)
RepoCommitTraverseIterNextMethodInfo ,
#endif
repoCommitTraverseIterNext ,
getRepoCommitTraverseIterInitialized ,
#if defined(ENABLE_OVERLOADING)
repoCommitTraverseIter_initialized ,
#endif
setRepoCommitTraverseIterInitialized ,
) 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.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
newtype RepoCommitTraverseIter = RepoCommitTraverseIter (SP.ManagedPtr RepoCommitTraverseIter)
deriving (RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
(RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool)
-> (RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool)
-> Eq RepoCommitTraverseIter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
$c/= :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
== :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
$c== :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
Eq)
instance SP.ManagedPtrNewtype RepoCommitTraverseIter where
toManagedPtr :: RepoCommitTraverseIter -> ManagedPtr RepoCommitTraverseIter
toManagedPtr (RepoCommitTraverseIter ManagedPtr RepoCommitTraverseIter
p) = ManagedPtr RepoCommitTraverseIter
p
instance BoxedPtr RepoCommitTraverseIter where
boxedPtrCopy :: RepoCommitTraverseIter -> IO RepoCommitTraverseIter
boxedPtrCopy = \RepoCommitTraverseIter
p -> RepoCommitTraverseIter
-> (Ptr RepoCommitTraverseIter -> IO RepoCommitTraverseIter)
-> IO RepoCommitTraverseIter
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RepoCommitTraverseIter
p (Int
-> Ptr RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
224 (Ptr RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter))
-> (Ptr RepoCommitTraverseIter -> IO RepoCommitTraverseIter)
-> Ptr RepoCommitTraverseIter
-> IO RepoCommitTraverseIter
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter)
-> Ptr RepoCommitTraverseIter -> IO RepoCommitTraverseIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter
RepoCommitTraverseIter)
boxedPtrFree :: RepoCommitTraverseIter -> IO ()
boxedPtrFree = \RepoCommitTraverseIter
x -> RepoCommitTraverseIter
-> (Ptr RepoCommitTraverseIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr RepoCommitTraverseIter
x Ptr RepoCommitTraverseIter -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr RepoCommitTraverseIter where
boxedPtrCalloc :: IO (Ptr RepoCommitTraverseIter)
boxedPtrCalloc = Int -> IO (Ptr RepoCommitTraverseIter)
forall a. Int -> IO (Ptr a)
callocBytes Int
224
newZeroRepoCommitTraverseIter :: MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter :: m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter = IO RepoCommitTraverseIter -> m RepoCommitTraverseIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RepoCommitTraverseIter -> m RepoCommitTraverseIter)
-> IO RepoCommitTraverseIter -> m RepoCommitTraverseIter
forall a b. (a -> b) -> a -> b
$ IO (Ptr RepoCommitTraverseIter)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr RepoCommitTraverseIter)
-> (Ptr RepoCommitTraverseIter -> IO RepoCommitTraverseIter)
-> IO RepoCommitTraverseIter
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter)
-> Ptr RepoCommitTraverseIter -> IO RepoCommitTraverseIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter
RepoCommitTraverseIter
instance tag ~ 'AttrSet => Constructible RepoCommitTraverseIter tag where
new :: (ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter)
-> [AttrOp RepoCommitTraverseIter tag] -> m RepoCommitTraverseIter
new ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter
_ [AttrOp RepoCommitTraverseIter tag]
attrs = do
RepoCommitTraverseIter
o <- m RepoCommitTraverseIter
forall (m :: * -> *). MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter
RepoCommitTraverseIter
-> [AttrOp RepoCommitTraverseIter 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set RepoCommitTraverseIter
o [AttrOp RepoCommitTraverseIter tag]
[AttrOp RepoCommitTraverseIter 'AttrSet]
attrs
RepoCommitTraverseIter -> m RepoCommitTraverseIter
forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitTraverseIter
o
getRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> m Bool
getRepoCommitTraverseIterInitialized :: RepoCommitTraverseIter -> m Bool
getRepoCommitTraverseIterInitialized RepoCommitTraverseIter
s = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ RepoCommitTraverseIter
-> (Ptr RepoCommitTraverseIter -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RepoCommitTraverseIter
s ((Ptr RepoCommitTraverseIter -> IO Bool) -> IO Bool)
-> (Ptr RepoCommitTraverseIter -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr RepoCommitTraverseIter
ptr -> do
CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr RepoCommitTraverseIter
ptr Ptr RepoCommitTraverseIter -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CInt
let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'
setRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> Bool -> m ()
setRepoCommitTraverseIterInitialized :: RepoCommitTraverseIter -> Bool -> m ()
setRepoCommitTraverseIterInitialized RepoCommitTraverseIter
s Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RepoCommitTraverseIter
-> (Ptr RepoCommitTraverseIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RepoCommitTraverseIter
s ((Ptr RepoCommitTraverseIter -> IO ()) -> IO ())
-> (Ptr RepoCommitTraverseIter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RepoCommitTraverseIter
ptr -> do
let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RepoCommitTraverseIter
ptr Ptr RepoCommitTraverseIter -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterInitializedFieldInfo
instance AttrInfo RepoCommitTraverseIterInitializedFieldInfo where
type AttrBaseTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) RepoCommitTraverseIter
type AttrAllowedOps RepoCommitTraverseIterInitializedFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) Bool
type AttrTransferTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~)Bool
type AttrTransferType RepoCommitTraverseIterInitializedFieldInfo = Bool
type AttrGetType RepoCommitTraverseIterInitializedFieldInfo = Bool
type AttrLabel RepoCommitTraverseIterInitializedFieldInfo = "initialized"
type AttrOrigin RepoCommitTraverseIterInitializedFieldInfo = RepoCommitTraverseIter
attrGet = getRepoCommitTraverseIterInitialized
attrSet = setRepoCommitTraverseIterInitialized
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
repoCommitTraverseIter_initialized :: AttrLabelProxy "initialized"
repoCommitTraverseIter_initialized = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RepoCommitTraverseIter
type instance O.AttributeList RepoCommitTraverseIter = RepoCommitTraverseIterAttributeList
type RepoCommitTraverseIterAttributeList = ('[ '("initialized", RepoCommitTraverseIterInitializedFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ostree_repo_commit_traverse_iter_clear" ostree_repo_commit_traverse_iter_clear ::
Ptr RepoCommitTraverseIter ->
IO ()
repoCommitTraverseIterClear ::
(B.CallStack.HasCallStack, MonadIO m) =>
RepoCommitTraverseIter
-> m ()
repoCommitTraverseIterClear :: RepoCommitTraverseIter -> m ()
repoCommitTraverseIterClear RepoCommitTraverseIter
iter = 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 RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
Ptr RepoCommitTraverseIter -> IO ()
ostree_repo_commit_traverse_iter_clear Ptr RepoCommitTraverseIter
iter'
RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RepoCommitTraverseIterClearMethodInfo RepoCommitTraverseIter signature where
overloadedMethod = repoCommitTraverseIterClear
#endif
foreign import ccall "ostree_repo_commit_traverse_iter_get_dir" ostree_repo_commit_traverse_iter_get_dir ::
Ptr RepoCommitTraverseIter ->
Ptr CString ->
Ptr CString ->
Ptr CString ->
IO ()
repoCommitTraverseIterGetDir ::
(B.CallStack.HasCallStack, MonadIO m) =>
RepoCommitTraverseIter
-> m ((T.Text, T.Text, T.Text))
repoCommitTraverseIterGetDir :: RepoCommitTraverseIter -> m (Text, Text, Text)
repoCommitTraverseIterGetDir RepoCommitTraverseIter
iter = IO (Text, Text, Text) -> m (Text, Text, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Text, Text) -> m (Text, Text, Text))
-> IO (Text, Text, Text) -> m (Text, Text, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
Ptr CString
outName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
outContentChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
outMetaChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr RepoCommitTraverseIter
-> Ptr CString -> Ptr CString -> Ptr CString -> IO ()
ostree_repo_commit_traverse_iter_get_dir Ptr RepoCommitTraverseIter
iter' Ptr CString
outName Ptr CString
outContentChecksum Ptr CString
outMetaChecksum
CString
outName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outName
Text
outName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outName'
CString
outContentChecksum' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outContentChecksum
Text
outContentChecksum'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outContentChecksum'
CString
outMetaChecksum' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outMetaChecksum
Text
outMetaChecksum'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outMetaChecksum'
RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outName
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outContentChecksum
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outMetaChecksum
(Text, Text, Text) -> IO (Text, Text, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
outName'', Text
outContentChecksum'', Text
outMetaChecksum'')
#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterGetDirMethodInfo
instance (signature ~ (m ((T.Text, T.Text, T.Text))), MonadIO m) => O.MethodInfo RepoCommitTraverseIterGetDirMethodInfo RepoCommitTraverseIter signature where
overloadedMethod = repoCommitTraverseIterGetDir
#endif
foreign import ccall "ostree_repo_commit_traverse_iter_get_file" ostree_repo_commit_traverse_iter_get_file ::
Ptr RepoCommitTraverseIter ->
Ptr CString ->
Ptr CString ->
IO ()
repoCommitTraverseIterGetFile ::
(B.CallStack.HasCallStack, MonadIO m) =>
RepoCommitTraverseIter
-> m ((T.Text, T.Text))
repoCommitTraverseIterGetFile :: RepoCommitTraverseIter -> m (Text, Text)
repoCommitTraverseIterGetFile RepoCommitTraverseIter
iter = IO (Text, Text) -> m (Text, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Text) -> m (Text, Text))
-> IO (Text, Text) -> m (Text, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
Ptr CString
outName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
outChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr RepoCommitTraverseIter -> Ptr CString -> Ptr CString -> IO ()
ostree_repo_commit_traverse_iter_get_file Ptr RepoCommitTraverseIter
iter' Ptr CString
outName Ptr CString
outChecksum
CString
outName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outName
Text
outName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outName'
CString
outChecksum' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outChecksum
Text
outChecksum'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outChecksum'
RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outName
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outChecksum
(Text, Text) -> IO (Text, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
outName'', Text
outChecksum'')
#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterGetFileMethodInfo
instance (signature ~ (m ((T.Text, T.Text))), MonadIO m) => O.MethodInfo RepoCommitTraverseIterGetFileMethodInfo RepoCommitTraverseIter signature where
overloadedMethod = repoCommitTraverseIterGetFile
#endif
foreign import ccall "ostree_repo_commit_traverse_iter_init_commit" ostree_repo_commit_traverse_iter_init_commit ::
Ptr RepoCommitTraverseIter ->
Ptr OSTree.Repo.Repo ->
Ptr GVariant ->
CUInt ->
Ptr (Ptr GError) ->
IO CInt
repoCommitTraverseIterInitCommit ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
RepoCommitTraverseIter
-> a
-> GVariant
-> [OSTree.Flags.RepoCommitTraverseFlags]
-> m ()
repoCommitTraverseIterInitCommit :: RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitCommit RepoCommitTraverseIter
iter a
repo GVariant
commit [RepoCommitTraverseFlags]
flags = 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 RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
Ptr Repo
repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
Ptr GVariant
commit' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commit
let flags' :: CUInt
flags' = [RepoCommitTraverseFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr RepoCommitTraverseIter
-> Ptr Repo -> Ptr GVariant -> CUInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_commit_traverse_iter_init_commit Ptr RepoCommitTraverseIter
iter' Ptr Repo
repo' Ptr GVariant
commit' CUInt
flags'
RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commit
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterInitCommitMethodInfo
instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.MethodInfo RepoCommitTraverseIterInitCommitMethodInfo RepoCommitTraverseIter signature where
overloadedMethod = repoCommitTraverseIterInitCommit
#endif
foreign import ccall "ostree_repo_commit_traverse_iter_init_dirtree" ostree_repo_commit_traverse_iter_init_dirtree ::
Ptr RepoCommitTraverseIter ->
Ptr OSTree.Repo.Repo ->
Ptr GVariant ->
CUInt ->
Ptr (Ptr GError) ->
IO CInt
repoCommitTraverseIterInitDirtree ::
(B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
RepoCommitTraverseIter
-> a
-> GVariant
-> [OSTree.Flags.RepoCommitTraverseFlags]
-> m ()
repoCommitTraverseIterInitDirtree :: RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitDirtree RepoCommitTraverseIter
iter a
repo GVariant
dirtree [RepoCommitTraverseFlags]
flags = 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 RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
Ptr Repo
repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
Ptr GVariant
dirtree' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
dirtree
let flags' :: CUInt
flags' = [RepoCommitTraverseFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr RepoCommitTraverseIter
-> Ptr Repo -> Ptr GVariant -> CUInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_commit_traverse_iter_init_dirtree Ptr RepoCommitTraverseIter
iter' Ptr Repo
repo' Ptr GVariant
dirtree' CUInt
flags'
RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
dirtree
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterInitDirtreeMethodInfo
instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.MethodInfo RepoCommitTraverseIterInitDirtreeMethodInfo RepoCommitTraverseIter signature where
overloadedMethod = repoCommitTraverseIterInitDirtree
#endif
foreign import ccall "ostree_repo_commit_traverse_iter_next" ostree_repo_commit_traverse_iter_next ::
Ptr RepoCommitTraverseIter ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CUInt
repoCommitTraverseIterNext ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
RepoCommitTraverseIter
-> Maybe (a)
-> m OSTree.Enums.RepoCommitIterResult
repoCommitTraverseIterNext :: RepoCommitTraverseIter -> Maybe a -> m RepoCommitIterResult
repoCommitTraverseIterNext RepoCommitTraverseIter
iter Maybe a
cancellable = IO RepoCommitIterResult -> m RepoCommitIterResult
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RepoCommitIterResult -> m RepoCommitIterResult)
-> IO RepoCommitIterResult -> m RepoCommitIterResult
forall a b. (a -> b) -> a -> b
$ do
Ptr RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
IO RepoCommitIterResult -> IO () -> IO RepoCommitIterResult
forall a b. IO a -> IO b -> IO a
onException (do
CUInt
result <- (Ptr (Ptr GError) -> IO CUInt) -> IO CUInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CUInt) -> IO CUInt)
-> (Ptr (Ptr GError) -> IO CUInt) -> IO CUInt
forall a b. (a -> b) -> a -> b
$ Ptr RepoCommitTraverseIter
-> Ptr Cancellable -> Ptr (Ptr GError) -> IO CUInt
ostree_repo_commit_traverse_iter_next Ptr RepoCommitTraverseIter
iter' Ptr Cancellable
maybeCancellable
let result' :: RepoCommitIterResult
result' = (Int -> RepoCommitIterResult
forall a. Enum a => Int -> a
toEnum (Int -> RepoCommitIterResult)
-> (CUInt -> Int) -> CUInt -> RepoCommitIterResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
RepoCommitIterResult -> IO RepoCommitIterResult
forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitIterResult
result'
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterNextMethodInfo
instance (signature ~ (Maybe (a) -> m OSTree.Enums.RepoCommitIterResult), MonadIO m, Gio.Cancellable.IsCancellable a) => O.MethodInfo RepoCommitTraverseIterNextMethodInfo RepoCommitTraverseIter signature where
overloadedMethod = repoCommitTraverseIterNext
#endif
foreign import ccall "ostree_repo_commit_traverse_iter_cleanup" ostree_repo_commit_traverse_iter_cleanup ::
Ptr () ->
IO ()
repoCommitTraverseIterCleanup ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m ()
repoCommitTraverseIterCleanup :: Ptr () -> m ()
repoCommitTraverseIterCleanup Ptr ()
p = 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 () -> IO ()
ostree_repo_commit_traverse_iter_cleanup Ptr ()
p
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveRepoCommitTraverseIterMethod (t :: Symbol) (o :: *) :: * where
ResolveRepoCommitTraverseIterMethod "clear" o = RepoCommitTraverseIterClearMethodInfo
ResolveRepoCommitTraverseIterMethod "initCommit" o = RepoCommitTraverseIterInitCommitMethodInfo
ResolveRepoCommitTraverseIterMethod "initDirtree" o = RepoCommitTraverseIterInitDirtreeMethodInfo
ResolveRepoCommitTraverseIterMethod "next" o = RepoCommitTraverseIterNextMethodInfo
ResolveRepoCommitTraverseIterMethod "getDir" o = RepoCommitTraverseIterGetDirMethodInfo
ResolveRepoCommitTraverseIterMethod "getFile" o = RepoCommitTraverseIterGetFileMethodInfo
ResolveRepoCommitTraverseIterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRepoCommitTraverseIterMethod t RepoCommitTraverseIter, O.MethodInfo info RepoCommitTraverseIter p) => OL.IsLabel t (RepoCommitTraverseIter -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif