{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.OSTree.Structs.RepoCommitTraverseIter
    ( 

-- * Exported types
    RepoCommitTraverseIter(..)              ,
    newZeroRepoCommitTraverseIter           ,
    noRepoCommitTraverseIter                ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveRepoCommitTraverseIterMethod     ,
#endif


-- ** cleanup #method:cleanup#

    repoCommitTraverseIterCleanup           ,


-- ** clear #method:clear#

#if defined(ENABLE_OVERLOADING)
    RepoCommitTraverseIterClearMethodInfo   ,
#endif
    repoCommitTraverseIterClear             ,


-- ** getDir #method:getDir#

#if defined(ENABLE_OVERLOADING)
    RepoCommitTraverseIterGetDirMethodInfo  ,
#endif
    repoCommitTraverseIterGetDir            ,


-- ** getFile #method:getFile#

#if defined(ENABLE_OVERLOADING)
    RepoCommitTraverseIterGetFileMethodInfo ,
#endif
    repoCommitTraverseIterGetFile           ,


-- ** initCommit #method:initCommit#

#if defined(ENABLE_OVERLOADING)
    RepoCommitTraverseIterInitCommitMethodInfo,
#endif
    repoCommitTraverseIterInitCommit        ,


-- ** initDirtree #method:initDirtree#

#if defined(ENABLE_OVERLOADING)
    RepoCommitTraverseIterInitDirtreeMethodInfo,
#endif
    repoCommitTraverseIterInitDirtree       ,


-- ** next #method:next#

#if defined(ENABLE_OVERLOADING)
    RepoCommitTraverseIterNextMethodInfo    ,
#endif
    repoCommitTraverseIterNext              ,




 -- * Properties
-- ** initialized #attr:initialized#
-- | /No description available in the introspection data./

    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.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 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

-- | Memory-managed wrapper type.
newtype RepoCommitTraverseIter = RepoCommitTraverseIter (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 WrappedPtr RepoCommitTraverseIter where
    wrappedPtrCalloc :: IO (Ptr RepoCommitTraverseIter)
wrappedPtrCalloc = Int -> IO (Ptr RepoCommitTraverseIter)
forall a. Int -> IO (Ptr a)
callocBytes 224
    wrappedPtrCopy :: RepoCommitTraverseIter -> IO RepoCommitTraverseIter
wrappedPtrCopy = \p :: RepoCommitTraverseIter
p -> RepoCommitTraverseIter
-> (Ptr RepoCommitTraverseIter -> IO RepoCommitTraverseIter)
-> IO RepoCommitTraverseIter
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RepoCommitTraverseIter
p (Int
-> Ptr RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter
RepoCommitTraverseIter)
    wrappedPtrFree :: Maybe (GDestroyNotify RepoCommitTraverseIter)
wrappedPtrFree = GDestroyNotify RepoCommitTraverseIter
-> Maybe (GDestroyNotify RepoCommitTraverseIter)
forall a. a -> Maybe a
Just GDestroyNotify RepoCommitTraverseIter
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `RepoCommitTraverseIter` struct initialized to zero.
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. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc 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, WrappedPtr 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 _ attrs :: [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


-- | A convenience alias for `Nothing` :: `Maybe` `RepoCommitTraverseIter`.
noRepoCommitTraverseIter :: Maybe RepoCommitTraverseIter
noRepoCommitTraverseIter :: Maybe RepoCommitTraverseIter
noRepoCommitTraverseIter = Maybe RepoCommitTraverseIter
forall a. Maybe a
Nothing

-- | Get the value of the “@initialized@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' repoCommitTraverseIter #initialized
-- @
getRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> m Bool
getRepoCommitTraverseIterInitialized :: RepoCommitTraverseIter -> m Bool
getRepoCommitTraverseIterInitialized s :: 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 :: 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` 0) :: IO CInt
    let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
val
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'

-- | Set the value of the “@initialized@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' repoCommitTraverseIter [ #initialized 'Data.GI.Base.Attributes.:=' value ]
-- @
setRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> Bool -> m ()
setRepoCommitTraverseIterInitialized :: RepoCommitTraverseIter -> Bool -> m ()
setRepoCommitTraverseIterInitialized s :: RepoCommitTraverseIter
s val :: 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 :: 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` 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


-- XXX Skipped attribute for "RepoCommitTraverseIter:dummy" :: Not implemented: "Don't know how to unpack C array of type TCArray False 10 (-1) (TBasicType TPtr)"
-- XXX Skipped attribute for "RepoCommitTraverseIter:dummy_checksum_data" :: Not implemented: "Don't know how to unpack C array of type TCArray False 130 (-1) (TBasicType TInt8)"

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RepoCommitTraverseIter
type instance O.AttributeList RepoCommitTraverseIter = RepoCommitTraverseIterAttributeList
type RepoCommitTraverseIterAttributeList = ('[ '("initialized", RepoCommitTraverseIterInitializedFieldInfo)] :: [(Symbol, *)])
#endif

-- method RepoCommitTraverseIter::clear
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_commit_traverse_iter_clear" ostree_repo_commit_traverse_iter_clear :: 
    Ptr RepoCommitTraverseIter ->           -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"})
    IO ()

-- | /No description available in the introspection data./
repoCommitTraverseIterClear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RepoCommitTraverseIter
    -> m ()
repoCommitTraverseIterClear :: RepoCommitTraverseIter -> m ()
repoCommitTraverseIterClear iter :: 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

-- method RepoCommitTraverseIter::get_dir
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of current dir"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_content_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum of current content"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_meta_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum of current metadata"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_commit_traverse_iter_get_dir" ostree_repo_commit_traverse_iter_get_dir :: 
    Ptr RepoCommitTraverseIter ->           -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"})
    Ptr CString ->                          -- out_name : TBasicType TUTF8
    Ptr CString ->                          -- out_content_checksum : TBasicType TUTF8
    Ptr CString ->                          -- out_meta_checksum : TBasicType TUTF8
    IO ()

-- | Return information on the current directory.  This function may
-- only be called if 'GI.OSTree.Enums.RepoCommitIterResultDir' was returned
-- from 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterNext'.
repoCommitTraverseIterGetDir ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RepoCommitTraverseIter
    -- ^ /@iter@/: An iter
    -> m ((T.Text, T.Text, T.Text))
repoCommitTraverseIterGetDir :: RepoCommitTraverseIter -> m (Text, Text, Text)
repoCommitTraverseIterGetDir iter :: 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)
allocMem :: IO (Ptr CString)
    Ptr CString
outContentChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CString)
    Ptr CString
outMetaChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
allocMem :: 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

-- method RepoCommitTraverseIter::get_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of current file"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum of current file"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_commit_traverse_iter_get_file" ostree_repo_commit_traverse_iter_get_file :: 
    Ptr RepoCommitTraverseIter ->           -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"})
    Ptr CString ->                          -- out_name : TBasicType TUTF8
    Ptr CString ->                          -- out_checksum : TBasicType TUTF8
    IO ()

-- | Return information on the current file.  This function may only be
-- called if 'GI.OSTree.Enums.RepoCommitIterResultFile' was returned from
-- 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterNext'.
repoCommitTraverseIterGetFile ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RepoCommitTraverseIter
    -- ^ /@iter@/: An iter
    -> m ((T.Text, T.Text))
repoCommitTraverseIterGetFile :: RepoCommitTraverseIter -> m (Text, Text)
repoCommitTraverseIterGetFile iter :: 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)
allocMem :: IO (Ptr CString)
    Ptr CString
outChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
allocMem :: 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

-- method RepoCommitTraverseIter::init_commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Variant of type %OSTREE_OBJECT_TYPE_COMMIT"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Flags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_commit_traverse_iter_init_commit" ostree_repo_commit_traverse_iter_init_commit :: 
    Ptr RepoCommitTraverseIter ->           -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"})
    Ptr OSTree.Repo.Repo ->                 -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr GVariant ->                         -- commit : TVariant
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseFlags"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Initialize (in place) an iterator over the root of a commit object.
repoCommitTraverseIterInitCommit ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    RepoCommitTraverseIter
    -- ^ /@iter@/: An iter
    -> a
    -- ^ /@repo@/: A repo
    -> GVariant
    -- ^ /@commit@/: Variant of type 'GI.OSTree.Enums.ObjectTypeCommit'
    -> [OSTree.Flags.RepoCommitTraverseFlags]
    -- ^ /@flags@/: Flags
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCommitTraverseIterInitCommit :: RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitCommit iter :: RepoCommitTraverseIter
iter repo :: a
repo commit :: GVariant
commit flags :: [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

-- method RepoCommitTraverseIter::init_dirtree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dirtree"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Variant of type %OSTREE_OBJECT_TYPE_DIR_TREE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Flags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_commit_traverse_iter_init_dirtree" ostree_repo_commit_traverse_iter_init_dirtree :: 
    Ptr RepoCommitTraverseIter ->           -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"})
    Ptr OSTree.Repo.Repo ->                 -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr GVariant ->                         -- dirtree : TVariant
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseFlags"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Initialize (in place) an iterator over a directory tree.
repoCommitTraverseIterInitDirtree ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    RepoCommitTraverseIter
    -- ^ /@iter@/: An iter
    -> a
    -- ^ /@repo@/: A repo
    -> GVariant
    -- ^ /@dirtree@/: Variant of type 'GI.OSTree.Enums.ObjectTypeDirTree'
    -> [OSTree.Flags.RepoCommitTraverseFlags]
    -- ^ /@flags@/: Flags
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCommitTraverseIterInitDirtree :: RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitDirtree iter :: RepoCommitTraverseIter
iter repo :: a
repo dirtree :: GVariant
dirtree flags :: [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

-- method RepoCommitTraverseIter::next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Cancellable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "OSTree" , name = "RepoCommitIterResult" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_commit_traverse_iter_next" ostree_repo_commit_traverse_iter_next :: 
    Ptr RepoCommitTraverseIter ->           -- iter : TInterface (Name {namespace = "OSTree", name = "RepoCommitTraverseIter"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CUInt

-- | Step the interator to the next item.  Files will be returned first,
-- then subdirectories.  Call this in a loop; upon encountering
-- 'GI.OSTree.Enums.RepoCommitIterResultEnd', there will be no more files or
-- directories.  If 'GI.OSTree.Enums.RepoCommitIterResultDir' is returned,
-- then call 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetDir' to retrieve
-- data for that directory.  Similarly, if
-- 'GI.OSTree.Enums.RepoCommitIterResultFile' is returned, call
-- 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetFile'.
-- 
-- If 'GI.OSTree.Enums.RepoCommitIterResultError' is returned, it is a
-- program error to call any further API on /@iter@/ except for
-- 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterClear'.
repoCommitTraverseIterNext ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    RepoCommitTraverseIter
    -- ^ /@iter@/: An iter
    -> Maybe (a)
    -- ^ /@cancellable@/: Cancellable
    -> m OSTree.Enums.RepoCommitIterResult
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCommitTraverseIterNext :: RepoCommitTraverseIter -> Maybe a -> m RepoCommitIterResult
repoCommitTraverseIterNext iter :: RepoCommitTraverseIter
iter cancellable :: 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
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: 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

-- method RepoCommitTraverseIter::cleanup
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "p"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_commit_traverse_iter_cleanup" ostree_repo_commit_traverse_iter_cleanup :: 
    Ptr () ->                               -- p : TBasicType TPtr
    IO ()

-- | /No description available in the introspection data./
repoCommitTraverseIterCleanup ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -> m ()
repoCommitTraverseIterCleanup :: Ptr () -> m ()
repoCommitTraverseIterCleanup p :: 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