{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [clear]("GI.OSTree.Structs.RepoCommitTraverseIter#g:method:clear"), [initCommit]("GI.OSTree.Structs.RepoCommitTraverseIter#g:method:initCommit"), [initDirtree]("GI.OSTree.Structs.RepoCommitTraverseIter#g:method:initDirtree"), [next]("GI.OSTree.Structs.RepoCommitTraverseIter#g:method:next").
-- 
-- ==== Getters
-- [getDir]("GI.OSTree.Structs.RepoCommitTraverseIter#g:method:getDir"), [getFile]("GI.OSTree.Structs.RepoCommitTraverseIter#g:method:getFile").
-- 
-- ==== Setters
-- /None/.

#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.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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.KeyFile as GLib.KeyFile
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GLib.Structs.VariantDict as GLib.VariantDict
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
import qualified GI.OSTree.Callbacks as OSTree.Callbacks
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags
import {-# SOURCE #-} qualified GI.OSTree.Interfaces.BlobReader as OSTree.BlobReader
import {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder
import {-# SOURCE #-} qualified GI.OSTree.Interfaces.Sign as OSTree.Sign
import {-# SOURCE #-} qualified GI.OSTree.Objects.AsyncProgress as OSTree.AsyncProgress
import {-# SOURCE #-} qualified GI.OSTree.Objects.ContentWriter as OSTree.ContentWriter
import {-# SOURCE #-} qualified GI.OSTree.Objects.GpgVerifyResult as OSTree.GpgVerifyResult
import {-# SOURCE #-} qualified GI.OSTree.Objects.MutableTree as OSTree.MutableTree
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
import {-# SOURCE #-} qualified GI.OSTree.Objects.RepoFile as OSTree.RepoFile
import {-# SOURCE #-} qualified GI.OSTree.Objects.SePolicy as OSTree.SePolicy
import {-# SOURCE #-} qualified GI.OSTree.Structs.CollectionRef as OSTree.CollectionRef
import {-# SOURCE #-} qualified GI.OSTree.Structs.Remote as OSTree.Remote
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCheckoutAtOptions as OSTree.RepoCheckoutAtOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCommitModifier as OSTree.RepoCommitModifier
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoDevInoCache as OSTree.RepoDevInoCache
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoFinderResult as OSTree.RepoFinderResult
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoPruneOptions as OSTree.RepoPruneOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoTransactionStats as OSTree.RepoTransactionStats

#else
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

#endif

-- | Memory-managed wrapper type.
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
$c== :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
== :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
$c/= :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
/= :: 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
176 (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
176


-- | Construct a t'RepoCommitTraverseIter' struct initialized to zero.
newZeroRepoCommitTraverseIter :: MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter :: forall (m :: * -> *). MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter = IO RepoCommitTraverseIter -> m RepoCommitTraverseIter
forall a. IO a -> m a
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 a b. IO a -> (a -> IO b) -> IO b
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 :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter)
-> [AttrOp RepoCommitTraverseIter tag] -> m RepoCommitTraverseIter
new ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter
_ [AttrOp RepoCommitTraverseIter tag]
attrs = do
        o <- m RepoCommitTraverseIter
forall (m :: * -> *). MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter
        GI.Attributes.set o attrs
        return o


-- | 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 :: forall (m :: * -> *). MonadIO m => RepoCommitTraverseIter -> m Bool
getRepoCommitTraverseIterInitialized RepoCommitTraverseIter
s = IO Bool -> m Bool
forall a. IO a -> m a
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
    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' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    return 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 :: forall (m :: * -> *).
MonadIO m =>
RepoCommitTraverseIter -> Bool -> m ()
setRepoCommitTraverseIterInitialized RepoCommitTraverseIter
s Bool
val = IO () -> m ()
forall a. IO a -> m a
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
P.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
P.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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitTraverseIter.initialized"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#g:attr:initialized"
        })

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, DK.Type)])
#endif

-- method RepoCommitTraverseIter::clear
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , argCType = Just "OstreeRepoCommitTraverseIter*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitTraverseIter -> m ()
repoCommitTraverseIterClear RepoCommitTraverseIter
iter = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    ostree_repo_commit_traverse_iter_clear iter'
    touchManagedPtr iter
    return ()

#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod RepoCommitTraverseIterClearMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod = repoCommitTraverseIterClear

instance O.OverloadedMethodInfo RepoCommitTraverseIterClearMethodInfo RepoCommitTraverseIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterClear",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#v:repoCommitTraverseIterClear"
        })


#endif

-- method RepoCommitTraverseIter::get_dir
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , argCType = Just "OstreeRepoCommitTraverseIter*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of current dir"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_content_checksum"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum of current content"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_meta_checksum"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum of current metadata"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitTraverseIter -> m (Text, Text, Text)
repoCommitTraverseIterGetDir RepoCommitTraverseIter
iter = IO (Text, Text, Text) -> m (Text, Text, Text)
forall a. IO a -> m a
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
    iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    outName <- callocMem :: IO (Ptr CString)
    outContentChecksum <- callocMem :: IO (Ptr CString)
    outMetaChecksum <- callocMem :: IO (Ptr CString)
    ostree_repo_commit_traverse_iter_get_dir iter' outName outContentChecksum outMetaChecksum
    outName' <- peek outName
    outName'' <- cstringToText outName'
    outContentChecksum' <- peek outContentChecksum
    outContentChecksum'' <- cstringToText outContentChecksum'
    outMetaChecksum' <- peek outMetaChecksum
    outMetaChecksum'' <- cstringToText outMetaChecksum'
    touchManagedPtr iter
    freeMem outName
    freeMem outContentChecksum
    freeMem outMetaChecksum
    return (outName'', outContentChecksum'', outMetaChecksum'')

#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterGetDirMethodInfo
instance (signature ~ (m ((T.Text, T.Text, T.Text))), MonadIO m) => O.OverloadedMethod RepoCommitTraverseIterGetDirMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod = repoCommitTraverseIterGetDir

instance O.OverloadedMethodInfo RepoCommitTraverseIterGetDirMethodInfo RepoCommitTraverseIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetDir",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#v:repoCommitTraverseIterGetDir"
        })


#endif

-- method RepoCommitTraverseIter::get_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , argCType = Just "OstreeRepoCommitTraverseIter*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of current file"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_checksum"
--           , argType = TBasicType TUTF8
--           , argCType = Just "char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum of current file"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitTraverseIter -> m (Text, Text)
repoCommitTraverseIterGetFile RepoCommitTraverseIter
iter = IO (Text, Text) -> m (Text, Text)
forall a. IO a -> m a
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
    iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    outName <- callocMem :: IO (Ptr CString)
    outChecksum <- callocMem :: IO (Ptr CString)
    ostree_repo_commit_traverse_iter_get_file iter' outName outChecksum
    outName' <- peek outName
    outName'' <- cstringToText outName'
    outChecksum' <- peek outChecksum
    outChecksum'' <- cstringToText outChecksum'
    touchManagedPtr iter
    freeMem outName
    freeMem outChecksum
    return (outName'', outChecksum'')

#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterGetFileMethodInfo
instance (signature ~ (m ((T.Text, T.Text))), MonadIO m) => O.OverloadedMethod RepoCommitTraverseIterGetFileMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod = repoCommitTraverseIterGetFile

instance O.OverloadedMethodInfo RepoCommitTraverseIterGetFileMethodInfo RepoCommitTraverseIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetFile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#v:repoCommitTraverseIterGetFile"
        })


#endif

-- method RepoCommitTraverseIter::init_commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , argCType = Just "OstreeRepoCommitTraverseIter*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit"
--           , argType = TVariant
--           , argCType = Just "GVariant*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseFlags" }
--           , argCType = Just "OstreeRepoCommitTraverseFlags"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Flags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitCommit RepoCommitTraverseIter
iter a
repo GVariant
commit [RepoCommitTraverseFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    repo' <- unsafeManagedPtrCastPtr repo
    commit' <- unsafeManagedPtrGetPtr commit
    let flags' = [RepoCommitTraverseFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
    onException (do
        _ <- propagateGError $ ostree_repo_commit_traverse_iter_init_commit iter' repo' commit' flags'
        touchManagedPtr iter
        touchManagedPtr repo
        touchManagedPtr commit
        return ()
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterInitCommitMethodInfo
instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.OverloadedMethod RepoCommitTraverseIterInitCommitMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod = repoCommitTraverseIterInitCommit

instance O.OverloadedMethodInfo RepoCommitTraverseIterInitCommitMethodInfo RepoCommitTraverseIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterInitCommit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#v:repoCommitTraverseIterInitCommit"
        })


#endif

-- method RepoCommitTraverseIter::init_dirtree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , argCType = Just "OstreeRepoCommitTraverseIter*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dirtree"
--           , argType = TVariant
--           , argCType = Just "GVariant*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseFlags" }
--           , argCType = Just "OstreeRepoCommitTraverseFlags"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Flags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitDirtree RepoCommitTraverseIter
iter a
repo GVariant
dirtree [RepoCommitTraverseFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    repo' <- unsafeManagedPtrCastPtr repo
    dirtree' <- unsafeManagedPtrGetPtr dirtree
    let flags' = [RepoCommitTraverseFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
    onException (do
        _ <- propagateGError $ ostree_repo_commit_traverse_iter_init_dirtree iter' repo' dirtree' flags'
        touchManagedPtr iter
        touchManagedPtr repo
        touchManagedPtr dirtree
        return ()
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterInitDirtreeMethodInfo
instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.OverloadedMethod RepoCommitTraverseIterInitDirtreeMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod = repoCommitTraverseIterInitDirtree

instance O.OverloadedMethodInfo RepoCommitTraverseIterInitDirtreeMethodInfo RepoCommitTraverseIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterInitDirtree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#v:repoCommitTraverseIterInitDirtree"
        })


#endif

-- method RepoCommitTraverseIter::next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitTraverseIter" }
--           , argCType = Just "OstreeRepoCommitTraverseIter*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An iter" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , argCType = Just "GCancellable*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Cancellable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
RepoCommitTraverseIter -> Maybe a -> m RepoCommitIterResult
repoCommitTraverseIterNext RepoCommitTraverseIter
iter Maybe a
cancellable = IO RepoCommitIterResult -> m RepoCommitIterResult
forall a. IO a -> m a
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
    iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    maybeCancellable <- case cancellable of
        Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just a
jCancellable -> do
            jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ ostree_repo_commit_traverse_iter_next iter' maybeCancellable
        let 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
        touchManagedPtr iter
        whenJust cancellable touchManagedPtr
        return result'
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterNextMethodInfo
instance (signature ~ (Maybe (a) -> m OSTree.Enums.RepoCommitIterResult), MonadIO m, Gio.Cancellable.IsCancellable a) => O.OverloadedMethod RepoCommitTraverseIterNextMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod = repoCommitTraverseIterNext

instance O.OverloadedMethodInfo RepoCommitTraverseIterNextMethodInfo RepoCommitTraverseIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterNext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#v:repoCommitTraverseIterNext"
        })


#endif

-- method RepoCommitTraverseIter::cleanup
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "p"
--           , argType = TBasicType TPtr
--           , argCType = Just "void*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m ()
repoCommitTraverseIterCleanup Ptr ()
p = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveRepoCommitTraverseIterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveRepoCommitTraverseIterMethod t RepoCommitTraverseIter, O.OverloadedMethod info RepoCommitTraverseIter p, R.HasField t RepoCommitTraverseIter p) => R.HasField t RepoCommitTraverseIter p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveRepoCommitTraverseIterMethod t RepoCommitTraverseIter, O.OverloadedMethodInfo info RepoCommitTraverseIter) => OL.IsLabel t (O.MethodProxy info RepoCommitTraverseIter) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif