{-# 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 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 (SP.ManagedPtr RepoCommitTraverseIter)
    deriving (RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
$c/= :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
== :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
$c== :: RepoCommitTraverseIter -> RepoCommitTraverseIter -> Bool
Eq)

instance SP.ManagedPtrNewtype RepoCommitTraverseIter where
    toManagedPtr :: RepoCommitTraverseIter -> ManagedPtr RepoCommitTraverseIter
toManagedPtr (RepoCommitTraverseIter ManagedPtr RepoCommitTraverseIter
p) = ManagedPtr RepoCommitTraverseIter
p

instance BoxedPtr RepoCommitTraverseIter where
    boxedPtrCopy :: RepoCommitTraverseIter -> IO RepoCommitTraverseIter
boxedPtrCopy = \RepoCommitTraverseIter
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RepoCommitTraverseIter
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
224 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> 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 -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr RepoCommitTraverseIter
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr RepoCommitTraverseIter where
    boxedPtrCalloc :: IO (Ptr RepoCommitTraverseIter)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
224


-- | Construct a `RepoCommitTraverseIter` struct initialized to zero.
newZeroRepoCommitTraverseIter :: MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter :: forall (m :: * -> *). MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 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
        RepoCommitTraverseIter
o <- forall (m :: * -> *). MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter
        forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set RepoCommitTraverseIter
o [AttrOp RepoCommitTraverseIter tag]
attrs
        forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitTraverseIter
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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RepoCommitTraverseIter
s forall a b. (a -> b) -> a -> b
$ \Ptr RepoCommitTraverseIter
ptr -> do
    CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr RepoCommitTraverseIter
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CInt
    let val' :: Bool
val' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    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 :: forall (m :: * -> *).
MonadIO m =>
RepoCommitTraverseIter -> Bool -> m ()
setRepoCommitTraverseIterInitialized RepoCommitTraverseIter
s Bool
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RepoCommitTraverseIter
s forall a b. (a -> b) -> a -> b
$ \Ptr RepoCommitTraverseIter
ptr -> do
    let val' :: CInt
val' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RepoCommitTraverseIter
ptr 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.16/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" }
--           , 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitTraverseIter -> m ()
repoCommitTraverseIterClear RepoCommitTraverseIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr RepoCommitTraverseIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr RepoCommitTraverseIter -> IO ()
ostree_repo_commit_traverse_iter_clear Ptr RepoCommitTraverseIter
iter'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
    forall (m :: * -> *) a. Monad m => a -> m a
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.16/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" }
--           , 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitTraverseIter -> m (Text, Text, Text)
repoCommitTraverseIterGetDir RepoCommitTraverseIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr RepoCommitTraverseIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr CString
outName <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CString
outContentChecksum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CString
outMetaChecksum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr RepoCommitTraverseIter
-> Ptr CString -> Ptr CString -> Ptr CString -> IO ()
ostree_repo_commit_traverse_iter_get_dir Ptr RepoCommitTraverseIter
iter' Ptr CString
outName Ptr CString
outContentChecksum Ptr CString
outMetaChecksum
    CString
outName' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outName
    Text
outName'' <- HasCallStack => CString -> IO Text
cstringToText CString
outName'
    CString
outContentChecksum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outContentChecksum
    Text
outContentChecksum'' <- HasCallStack => CString -> IO Text
cstringToText CString
outContentChecksum'
    CString
outMetaChecksum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outMetaChecksum
    Text
outMetaChecksum'' <- HasCallStack => CString -> IO Text
cstringToText CString
outMetaChecksum'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
    forall a. Ptr a -> IO ()
freeMem Ptr CString
outName
    forall a. Ptr a -> IO ()
freeMem Ptr CString
outContentChecksum
    forall a. Ptr a -> IO ()
freeMem Ptr CString
outMetaChecksum
    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.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.16/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" }
--           , 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RepoCommitTraverseIter -> m (Text, Text)
repoCommitTraverseIterGetFile RepoCommitTraverseIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr RepoCommitTraverseIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr CString
outName <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CString
outChecksum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr RepoCommitTraverseIter -> Ptr CString -> Ptr CString -> IO ()
ostree_repo_commit_traverse_iter_get_file Ptr RepoCommitTraverseIter
iter' Ptr CString
outName Ptr CString
outChecksum
    CString
outName' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outName
    Text
outName'' <- HasCallStack => CString -> IO Text
cstringToText CString
outName'
    CString
outChecksum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outChecksum
    Text
outChecksum'' <- HasCallStack => CString -> IO Text
cstringToText CString
outChecksum'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
    forall a. Ptr a -> IO ()
freeMem Ptr CString
outName
    forall a. Ptr a -> IO ()
freeMem Ptr CString
outChecksum
    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.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.16/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" }
--           , 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitCommit RepoCommitTraverseIter
iter a
repo GVariant
commit [RepoCommitTraverseFlags]
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr RepoCommitTraverseIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    Ptr GVariant
commit' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commit
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr 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'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commit
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        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.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.16/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" }
--           , 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
RepoCommitTraverseIter
-> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()
repoCommitTraverseIterInitDirtree RepoCommitTraverseIter
iter a
repo GVariant
dirtree [RepoCommitTraverseFlags]
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr RepoCommitTraverseIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    Ptr GVariant
dirtree' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
dirtree
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr 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'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
dirtree
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        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.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.16/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" }
--           , 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
RepoCommitTraverseIter -> Maybe a -> m RepoCommitIterResult
repoCommitTraverseIterNext RepoCommitTraverseIter
iter Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr RepoCommitTraverseIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
        Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just a
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CUInt
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError 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' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitIterResult
result'
     ) (do
        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.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.16/docs/GI-OSTree-Structs-RepoCommitTraverseIter.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m ()
repoCommitTraverseIterCleanup Ptr ()
p = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr () -> IO ()
ostree_repo_commit_traverse_iter_cleanup Ptr ()
p
    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