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


-- | Construct a `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
        RepoCommitTraverseIter
o <- m RepoCommitTraverseIter
forall (m :: * -> *). MonadIO m => m RepoCommitTraverseIter
newZeroRepoCommitTraverseIter
        RepoCommitTraverseIter
-> [AttrOp RepoCommitTraverseIter 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set RepoCommitTraverseIter
o [AttrOp RepoCommitTraverseIter tag]
[AttrOp RepoCommitTraverseIter 'AttrSet]
attrs
        RepoCommitTraverseIter -> m RepoCommitTraverseIter
forall a. a -> m a
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 = 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
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr RepoCommitTraverseIter
ptr Ptr RepoCommitTraverseIter -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CInt
    let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    Bool -> IO Bool
forall a. a -> IO a
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 = 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
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RepoCommitTraverseIter
ptr Ptr RepoCommitTraverseIter -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data RepoCommitTraverseIterInitializedFieldInfo
instance AttrInfo RepoCommitTraverseIterInitializedFieldInfo where
    type AttrBaseTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) RepoCommitTraverseIter
    type AttrAllowedOps RepoCommitTraverseIterInitializedFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~) Bool
    type AttrTransferTypeConstraint RepoCommitTraverseIterInitializedFieldInfo = (~)Bool
    type AttrTransferType RepoCommitTraverseIterInitializedFieldInfo = Bool
    type AttrGetType RepoCommitTraverseIterInitializedFieldInfo = Bool
    type AttrLabel RepoCommitTraverseIterInitializedFieldInfo = "initialized"
    type AttrOrigin RepoCommitTraverseIterInitializedFieldInfo = RepoCommitTraverseIter
    attrGet = getRepoCommitTraverseIterInitialized
    attrSet = setRepoCommitTraverseIterInitialized
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    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, *)])
#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 = 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 RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr RepoCommitTraverseIter -> IO ()
ostree_repo_commit_traverse_iter_clear Ptr RepoCommitTraverseIter
iter'
    RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
    () -> IO ()
forall a. a -> IO a
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 = 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
    Ptr RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr CString
outName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CString
outContentChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CString
outMetaChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr RepoCommitTraverseIter
-> Ptr CString -> Ptr CString -> Ptr CString -> IO ()
ostree_repo_commit_traverse_iter_get_dir Ptr RepoCommitTraverseIter
iter' Ptr CString
outName Ptr CString
outContentChecksum Ptr CString
outMetaChecksum
    CString
outName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outName
    Text
outName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outName'
    CString
outContentChecksum' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outContentChecksum
    Text
outContentChecksum'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outContentChecksum'
    CString
outMetaChecksum' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outMetaChecksum
    Text
outMetaChecksum'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outMetaChecksum'
    RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outName
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outContentChecksum
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outMetaChecksum
    (Text, Text, Text) -> IO (Text, Text, Text)
forall a. a -> IO a
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 = 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
    Ptr RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr CString
outName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CString
outChecksum <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr RepoCommitTraverseIter -> Ptr CString -> Ptr CString -> IO ()
ostree_repo_commit_traverse_iter_get_file Ptr RepoCommitTraverseIter
iter' Ptr CString
outName Ptr CString
outChecksum
    CString
outName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outName
    Text
outName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outName'
    CString
outChecksum' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outChecksum
    Text
outChecksum'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
outChecksum'
    RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outName
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
outChecksum
    (Text, Text) -> IO (Text, Text)
forall a. a -> IO a
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 = 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 RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr Repo
repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    Ptr GVariant
commit' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
commit
    let flags' :: CUInt
flags' = [RepoCommitTraverseFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr RepoCommitTraverseIter
-> Ptr Repo -> Ptr GVariant -> CUInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_commit_traverse_iter_init_commit Ptr RepoCommitTraverseIter
iter' Ptr Repo
repo' Ptr GVariant
commit' CUInt
flags'
        RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
        GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
commit
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
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 = 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 RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr Repo
repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    Ptr GVariant
dirtree' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
dirtree
    let flags' :: CUInt
flags' = [RepoCommitTraverseFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitTraverseFlags]
flags
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr RepoCommitTraverseIter
-> Ptr Repo -> Ptr GVariant -> CUInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_commit_traverse_iter_init_dirtree Ptr RepoCommitTraverseIter
iter' Ptr Repo
repo' Ptr GVariant
dirtree' CUInt
flags'
        RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
        GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
dirtree
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
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 = 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
    Ptr RepoCommitTraverseIter
iter' <- RepoCommitTraverseIter -> IO (Ptr RepoCommitTraverseIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitTraverseIter
iter
    Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
        Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just a
jCancellable -> do
            Ptr Cancellable
jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO RepoCommitIterResult -> IO () -> IO RepoCommitIterResult
forall a b. IO a -> IO b -> IO a
onException (do
        CUInt
result <- (Ptr (Ptr GError) -> IO CUInt) -> IO CUInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CUInt) -> IO CUInt)
-> (Ptr (Ptr GError) -> IO CUInt) -> IO CUInt
forall a b. (a -> b) -> a -> b
$ Ptr RepoCommitTraverseIter
-> Ptr Cancellable -> Ptr (Ptr GError) -> IO CUInt
ostree_repo_commit_traverse_iter_next Ptr RepoCommitTraverseIter
iter' Ptr Cancellable
maybeCancellable
        let result' :: RepoCommitIterResult
result' = (Int -> RepoCommitIterResult
forall a. Enum a => Int -> a
toEnum (Int -> RepoCommitIterResult)
-> (CUInt -> Int) -> CUInt -> RepoCommitIterResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
        RepoCommitTraverseIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoCommitTraverseIter
iter
        Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        RepoCommitIterResult -> IO RepoCommitIterResult
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RepoCommitIterResult
result'
     ) (do
        () -> IO ()
forall a. a -> IO a
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 = 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 :: *) :: * 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