RepoCommitTraverseIter.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.OSTree.Structs.RepoCommitTraverseIter
    ( 

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


 -- * Methods
-- ** cleanup #method:cleanup#

    repoCommitTraverseIterCleanup           ,


-- ** clear #method:clear#

#if ENABLE_OVERLOADING
    RepoCommitTraverseIterClearMethodInfo   ,
#endif
    repoCommitTraverseIterClear             ,


-- ** getDir #method:getDir#

#if ENABLE_OVERLOADING
    RepoCommitTraverseIterGetDirMethodInfo  ,
#endif
    repoCommitTraverseIterGetDir            ,


-- ** getFile #method:getFile#

#if ENABLE_OVERLOADING
    RepoCommitTraverseIterGetFileMethodInfo ,
#endif
    repoCommitTraverseIterGetFile           ,


-- ** initCommit #method:initCommit#

#if ENABLE_OVERLOADING
    RepoCommitTraverseIterInitCommitMethodInfo,
#endif
    repoCommitTraverseIterInitCommit        ,


-- ** initDirtree #method:initDirtree#

#if ENABLE_OVERLOADING
    RepoCommitTraverseIterInitDirtreeMethodInfo,
#endif
    repoCommitTraverseIterInitDirtree       ,


-- ** next #method:next#

#if ENABLE_OVERLOADING
    RepoCommitTraverseIterNextMethodInfo    ,
#endif
    repoCommitTraverseIterNext              ,




 -- * Properties
-- ** initialized #attr:initialized#
{- | /No description available in the introspection data./
-}
    getRepoCommitTraverseIterInitialized    ,
#if ENABLE_OVERLOADING
    repoCommitTraverseIter_initialized      ,
#endif
    setRepoCommitTraverseIterInitialized    ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo

-- | Memory-managed wrapper type.
newtype RepoCommitTraverseIter = RepoCommitTraverseIter (ManagedPtr RepoCommitTraverseIter)
instance WrappedPtr RepoCommitTraverseIter where
    wrappedPtrCalloc = callocBytes 224
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 224 >=> wrapPtr RepoCommitTraverseIter)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `RepoCommitTraverseIter` struct initialized to zero.
newZeroRepoCommitTraverseIter :: MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter = liftIO $ wrappedPtrCalloc >>= wrapPtr RepoCommitTraverseIter

instance tag ~ 'AttrSet => Constructible RepoCommitTraverseIter tag where
    new _ attrs = do
        o <- newZeroRepoCommitTraverseIter
        GI.Attributes.set o attrs
        return o


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

{- |
Get the value of the “@initialized@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' repoCommitTraverseIter #initialized
@
-}
getRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> m Bool
getRepoCommitTraverseIterInitialized s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CInt
    let val' = (/= 0) 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 0) (val' :: CInt)

#if ENABLE_OVERLOADING
data RepoCommitTraverseIterInitializedFieldInfo
instance AttrInfo RepoCommitTraverseIterInitializedFieldInfo where
    type AttrAllowedOps RepoCommitTraverseIterInitializedFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) Bool
    type AttrBaseTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) RepoCommitTraverseIter
    type AttrGetType RepoCommitTraverseIterInitializedFieldInfo = Bool
    type AttrLabel RepoCommitTraverseIterInitializedFieldInfo = "initialized"
    type AttrOrigin RepoCommitTraverseIterInitializedFieldInfo = RepoCommitTraverseIter
    attrGet _ = getRepoCommitTraverseIterInitialized
    attrSet _ = setRepoCommitTraverseIterInitialized
    attrConstruct = undefined
    attrClear _ = undefined

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 ENABLE_OVERLOADING
instance O.HasAttributeList RepoCommitTraverseIter
type instance O.AttributeList RepoCommitTraverseIter = RepoCommitTraverseIterAttributeList
type RepoCommitTraverseIterAttributeList = ('[ '("initialized", RepoCommitTraverseIterInitializedFieldInfo)] :: [(Symbol, *)])
#endif

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

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

{- |
/No description available in the introspection data./
-}
repoCommitTraverseIterClear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RepoCommitTraverseIter
    -> m ()
repoCommitTraverseIterClear iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    ostree_repo_commit_traverse_iter_clear iter'
    touchManagedPtr iter
    return ()

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

#endif

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

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

{- |
Return information on the current directory.  This function may
only be called if 'GI.OSTree.Enums.RepoCommitIterResultDir' was returned
from 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterNext'.
-}
repoCommitTraverseIterGetDir ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RepoCommitTraverseIter
    {- ^ /@iter@/: An iter -}
    -> m ((T.Text, T.Text, T.Text))
repoCommitTraverseIterGetDir iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    outName <- allocMem :: IO (Ptr CString)
    outContentChecksum <- allocMem :: IO (Ptr CString)
    outMetaChecksum <- allocMem :: 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 ENABLE_OVERLOADING
data RepoCommitTraverseIterGetDirMethodInfo
instance (signature ~ (m ((T.Text, T.Text, T.Text))), MonadIO m) => O.MethodInfo RepoCommitTraverseIterGetDirMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod _ = repoCommitTraverseIterGetDir

#endif

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

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

{- |
Return information on the current file.  This function may only be
called if 'GI.OSTree.Enums.RepoCommitIterResultFile' was returned from
'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterNext'.
-}
repoCommitTraverseIterGetFile ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RepoCommitTraverseIter
    {- ^ /@iter@/: An iter -}
    -> m ((T.Text, T.Text))
repoCommitTraverseIterGetFile iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    outName <- allocMem :: IO (Ptr CString)
    outChecksum <- allocMem :: 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 ENABLE_OVERLOADING
data RepoCommitTraverseIterGetFileMethodInfo
instance (signature ~ (m ((T.Text, T.Text))), MonadIO m) => O.MethodInfo RepoCommitTraverseIterGetFileMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod _ = repoCommitTraverseIterGetFile

#endif

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

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

{- |
Initialize (in place) an iterator over the root of a commit object.
-}
repoCommitTraverseIterInitCommit ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    RepoCommitTraverseIter
    {- ^ /@iter@/: An iter -}
    -> a
    {- ^ /@repo@/: A repo -}
    -> GVariant
    {- ^ /@commit@/: Variant of type 'GI.OSTree.Enums.ObjectTypeCommit' -}
    -> [OSTree.Flags.RepoCommitTraverseFlags]
    {- ^ /@flags@/: Flags -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
repoCommitTraverseIterInitCommit iter repo commit flags = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    repo' <- unsafeManagedPtrCastPtr repo
    commit' <- unsafeManagedPtrGetPtr commit
    let flags' = gflagsToWord 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 ENABLE_OVERLOADING
data RepoCommitTraverseIterInitCommitMethodInfo
instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.MethodInfo RepoCommitTraverseIterInitCommitMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod _ = repoCommitTraverseIterInitCommit

#endif

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

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

{- |
Initialize (in place) an iterator over a directory tree.
-}
repoCommitTraverseIterInitDirtree ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    RepoCommitTraverseIter
    {- ^ /@iter@/: An iter -}
    -> a
    {- ^ /@repo@/: A repo -}
    -> GVariant
    {- ^ /@dirtree@/: Variant of type 'GI.OSTree.Enums.ObjectTypeDirTree' -}
    -> [OSTree.Flags.RepoCommitTraverseFlags]
    {- ^ /@flags@/: Flags -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
repoCommitTraverseIterInitDirtree iter repo dirtree flags = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    repo' <- unsafeManagedPtrCastPtr repo
    dirtree' <- unsafeManagedPtrGetPtr dirtree
    let flags' = gflagsToWord 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 ENABLE_OVERLOADING
data RepoCommitTraverseIterInitDirtreeMethodInfo
instance (signature ~ (a -> GVariant -> [OSTree.Flags.RepoCommitTraverseFlags] -> m ()), MonadIO m, OSTree.Repo.IsRepo a) => O.MethodInfo RepoCommitTraverseIterInitDirtreeMethodInfo RepoCommitTraverseIter signature where
    overloadedMethod _ = repoCommitTraverseIterInitDirtree

#endif

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

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

{- |
Step the interator to the next item.  Files will be returned first,
then subdirectories.  Call this in a loop; upon encountering
'GI.OSTree.Enums.RepoCommitIterResultEnd', there will be no more files or
directories.  If 'GI.OSTree.Enums.RepoCommitIterResultDir' is returned,
then call 'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetDir' to retrieve
data for that directory.  Similarly, if
'GI.OSTree.Enums.RepoCommitIterResultFile' is returned, call
'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterGetFile'.

If 'GI.OSTree.Enums.RepoCommitIterResultError' is returned, it is a
program error to call any further API on /@iter@/ except for
'GI.OSTree.Structs.RepoCommitTraverseIter.repoCommitTraverseIterClear'.
-}
repoCommitTraverseIterNext ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    RepoCommitTraverseIter
    {- ^ /@iter@/: An iter -}
    -> Maybe (a)
    {- ^ /@cancellable@/: Cancellable -}
    -> m OSTree.Enums.RepoCommitIterResult
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
repoCommitTraverseIterNext iter cancellable = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ ostree_repo_commit_traverse_iter_next iter' maybeCancellable
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr iter
        whenJust cancellable touchManagedPtr
        return result'
     ) (do
        return ()
     )

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

#endif

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

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

{- |
/No description available in the introspection data./
-}
repoCommitTraverseIterCleanup ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -> m ()
repoCommitTraverseIterCleanup p = liftIO $ do
    ostree_repo_commit_traverse_iter_cleanup p
    return ()

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
type family ResolveRepoCommitTraverseIterMethod (t :: Symbol) (o :: *) :: * where
    ResolveRepoCommitTraverseIterMethod "clear" o = RepoCommitTraverseIterClearMethodInfo
    ResolveRepoCommitTraverseIterMethod "initCommit" o = RepoCommitTraverseIterInitCommitMethodInfo
    ResolveRepoCommitTraverseIterMethod "initDirtree" o = RepoCommitTraverseIterInitDirtreeMethodInfo
    ResolveRepoCommitTraverseIterMethod "next" o = RepoCommitTraverseIterNextMethodInfo
    ResolveRepoCommitTraverseIterMethod "getDir" o = RepoCommitTraverseIterGetDirMethodInfo
    ResolveRepoCommitTraverseIterMethod "getFile" o = RepoCommitTraverseIterGetFileMethodInfo
    ResolveRepoCommitTraverseIterMethod l o = O.MethodResolutionFailed l o

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

#endif