{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a tree object.

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

module GI.Ggit.Objects.TreeBuilder
    ( 

-- * Exported types
    TreeBuilder(..)                         ,
    IsTreeBuilder                           ,
    toTreeBuilder                           ,
    noTreeBuilder                           ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveTreeBuilderMethod                ,
#endif


-- ** clear #method:clear#

#if defined(ENABLE_OVERLOADING)
    TreeBuilderClearMethodInfo              ,
#endif
    treeBuilderClear                        ,


-- ** getEntry #method:getEntry#

#if defined(ENABLE_OVERLOADING)
    TreeBuilderGetEntryMethodInfo           ,
#endif
    treeBuilderGetEntry                     ,


-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    TreeBuilderInsertMethodInfo             ,
#endif
    treeBuilderInsert                       ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    TreeBuilderRemoveMethodInfo             ,
#endif
    treeBuilderRemove                       ,


-- ** write #method:write#

#if defined(ENABLE_OVERLOADING)
    TreeBuilderWriteMethodInfo              ,
#endif
    treeBuilderWrite                        ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.TreeEntry as Ggit.TreeEntry

-- | Memory-managed wrapper type.
newtype TreeBuilder = TreeBuilder (ManagedPtr TreeBuilder)
    deriving (TreeBuilder -> TreeBuilder -> Bool
(TreeBuilder -> TreeBuilder -> Bool)
-> (TreeBuilder -> TreeBuilder -> Bool) -> Eq TreeBuilder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeBuilder -> TreeBuilder -> Bool
$c/= :: TreeBuilder -> TreeBuilder -> Bool
== :: TreeBuilder -> TreeBuilder -> Bool
$c== :: TreeBuilder -> TreeBuilder -> Bool
Eq)
foreign import ccall "ggit_tree_builder_get_type"
    c_ggit_tree_builder_get_type :: IO GType

instance GObject TreeBuilder where
    gobjectType :: IO GType
gobjectType = IO GType
c_ggit_tree_builder_get_type
    

-- | Convert 'TreeBuilder' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue TreeBuilder where
    toGValue :: TreeBuilder -> IO GValue
toGValue o :: TreeBuilder
o = do
        GType
gtype <- IO GType
c_ggit_tree_builder_get_type
        TreeBuilder -> (Ptr TreeBuilder -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeBuilder
o (GType
-> (GValue -> Ptr TreeBuilder -> IO ())
-> Ptr TreeBuilder
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TreeBuilder -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO TreeBuilder
fromGValue gv :: GValue
gv = do
        Ptr TreeBuilder
ptr <- GValue -> IO (Ptr TreeBuilder)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr TreeBuilder)
        (ManagedPtr TreeBuilder -> TreeBuilder)
-> Ptr TreeBuilder -> IO TreeBuilder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TreeBuilder -> TreeBuilder
TreeBuilder Ptr TreeBuilder
ptr
        
    

-- | Type class for types which can be safely cast to `TreeBuilder`, for instance with `toTreeBuilder`.
class (GObject o, O.IsDescendantOf TreeBuilder o) => IsTreeBuilder o
instance (GObject o, O.IsDescendantOf TreeBuilder o) => IsTreeBuilder o

instance O.HasParentTypes TreeBuilder
type instance O.ParentTypes TreeBuilder = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]

-- | Cast to `TreeBuilder`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTreeBuilder :: (MonadIO m, IsTreeBuilder o) => o -> m TreeBuilder
toTreeBuilder :: o -> m TreeBuilder
toTreeBuilder = IO TreeBuilder -> m TreeBuilder
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeBuilder -> m TreeBuilder)
-> (o -> IO TreeBuilder) -> o -> m TreeBuilder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TreeBuilder -> TreeBuilder) -> o -> IO TreeBuilder
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr TreeBuilder -> TreeBuilder
TreeBuilder

-- | A convenience alias for `Nothing` :: `Maybe` `TreeBuilder`.
noTreeBuilder :: Maybe TreeBuilder
noTreeBuilder :: Maybe TreeBuilder
noTreeBuilder = Maybe TreeBuilder
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveTreeBuilderMethod (t :: Symbol) (o :: *) :: * where
    ResolveTreeBuilderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTreeBuilderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTreeBuilderMethod "clear" o = TreeBuilderClearMethodInfo
    ResolveTreeBuilderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTreeBuilderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTreeBuilderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTreeBuilderMethod "insert" o = TreeBuilderInsertMethodInfo
    ResolveTreeBuilderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTreeBuilderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTreeBuilderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTreeBuilderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTreeBuilderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTreeBuilderMethod "remove" o = TreeBuilderRemoveMethodInfo
    ResolveTreeBuilderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTreeBuilderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTreeBuilderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTreeBuilderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTreeBuilderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTreeBuilderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTreeBuilderMethod "write" o = TreeBuilderWriteMethodInfo
    ResolveTreeBuilderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTreeBuilderMethod "getEntry" o = TreeBuilderGetEntryMethodInfo
    ResolveTreeBuilderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTreeBuilderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTreeBuilderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTreeBuilderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTreeBuilderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTreeBuilderMethod l o = O.MethodResolutionFailed l o

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

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TreeBuilder
type instance O.AttributeList TreeBuilder = TreeBuilderAttributeList
type TreeBuilderAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TreeBuilder = TreeBuilderSignalList
type TreeBuilderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method TreeBuilder::clear
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "TreeBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTreeBuilder."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_tree_builder_clear" ggit_tree_builder_clear :: 
    Ptr TreeBuilder ->                      -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"})
    IO ()

-- | Clear all entries in the tree builder.
treeBuilderClear ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
    a
    -- ^ /@builder@/: a t'GI.Ggit.Objects.TreeBuilder.TreeBuilder'.
    -> m ()
treeBuilderClear :: a -> m ()
treeBuilderClear builder :: a
builder = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr TreeBuilder -> IO ()
ggit_tree_builder_clear Ptr TreeBuilder
builder'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeBuilderClearMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderClearMethodInfo a signature where
    overloadedMethod = treeBuilderClear

#endif

-- method TreeBuilder::get_entry
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "TreeBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTreeBuilder."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path to remove."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Ggit" , name = "TreeEntry" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_tree_builder_get_entry" ggit_tree_builder_get_entry :: 
    Ptr TreeBuilder ->                      -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"})
    CString ->                              -- path : TBasicType TUTF8
    IO (Ptr Ggit.TreeEntry.TreeEntry)

-- | Get an entry by path.
treeBuilderGetEntry ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
    a
    -- ^ /@builder@/: a t'GI.Ggit.Objects.TreeBuilder.TreeBuilder'.
    -> T.Text
    -- ^ /@path@/: the path to remove.
    -> m (Maybe Ggit.TreeEntry.TreeEntry)
    -- ^ __Returns:__ the @/GGitTreeEntry/@ or 'P.Nothing' if no such entry exists.
treeBuilderGetEntry :: a -> Text -> m (Maybe TreeEntry)
treeBuilderGetEntry builder :: a
builder path :: Text
path = IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeEntry) -> m (Maybe TreeEntry))
-> IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr TreeEntry
result <- Ptr TreeBuilder -> CString -> IO (Ptr TreeEntry)
ggit_tree_builder_get_entry Ptr TreeBuilder
builder' CString
path'
    Maybe TreeEntry
maybeResult <- Ptr TreeEntry
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeEntry
result ((Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry))
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr TreeEntry
result' -> do
        TreeEntry
result'' <- ((ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreeEntry -> TreeEntry
Ggit.TreeEntry.TreeEntry) Ptr TreeEntry
result'
        TreeEntry -> IO TreeEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TreeEntry
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    Maybe TreeEntry -> IO (Maybe TreeEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeBuilderGetEntryMethodInfo
instance (signature ~ (T.Text -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderGetEntryMethodInfo a signature where
    overloadedMethod = treeBuilderGetEntry

#endif

-- method TreeBuilder::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "TreeBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTreeBuilder."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the file name." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "oid"
--           , argType = TInterface Name { namespace = "Ggit" , name = "OId" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GgitOId of the file blob to insert."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file_mode"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "FileMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitFileMode." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Ggit" , name = "TreeEntry" })
-- throws : True
-- Skip return : False

foreign import ccall "ggit_tree_builder_insert" ggit_tree_builder_insert :: 
    Ptr TreeBuilder ->                      -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"})
    CString ->                              -- filename : TBasicType TUTF8
    Ptr Ggit.OId.OId ->                     -- oid : TInterface (Name {namespace = "Ggit", name = "OId"})
    CUInt ->                                -- file_mode : TInterface (Name {namespace = "Ggit", name = "FileMode"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Ggit.TreeEntry.TreeEntry)

-- | Insert a file with a given blob in the tree builder. If the tree builder
-- already contains an entry for the given file, then this entry will be
-- overwritten.
-- 
-- Note that the returned t'GI.Ggit.Structs.TreeEntry.TreeEntry' is bound to the lifetime of the tree
-- builder and cannot be used after the tree builder has been freed.
treeBuilderInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
    a
    -- ^ /@builder@/: a t'GI.Ggit.Objects.TreeBuilder.TreeBuilder'.
    -> T.Text
    -- ^ /@filename@/: the file name.
    -> Ggit.OId.OId
    -- ^ /@oid@/: the t'GI.Ggit.Structs.OId.OId' of the file blob to insert.
    -> Ggit.Enums.FileMode
    -- ^ /@fileMode@/: a t'GI.Ggit.Enums.FileMode'.
    -> m (Maybe Ggit.TreeEntry.TreeEntry)
    -- ^ __Returns:__ a t'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'P.Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/
treeBuilderInsert :: a -> Text -> OId -> FileMode -> m (Maybe TreeEntry)
treeBuilderInsert builder :: a
builder filename :: Text
filename oid :: OId
oid fileMode :: FileMode
fileMode = IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeEntry) -> m (Maybe TreeEntry))
-> IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    CString
filename' <- Text -> IO CString
textToCString Text
filename
    Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
    let fileMode' :: CUInt
fileMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (FileMode -> Int) -> FileMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FileMode -> Int
forall a. Enum a => a -> Int
fromEnum) FileMode
fileMode
    IO (Maybe TreeEntry) -> IO () -> IO (Maybe TreeEntry)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr TreeEntry
result <- (Ptr (Ptr GError) -> IO (Ptr TreeEntry)) -> IO (Ptr TreeEntry)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr TreeEntry)) -> IO (Ptr TreeEntry))
-> (Ptr (Ptr GError) -> IO (Ptr TreeEntry)) -> IO (Ptr TreeEntry)
forall a b. (a -> b) -> a -> b
$ Ptr TreeBuilder
-> CString
-> Ptr OId
-> CUInt
-> Ptr (Ptr GError)
-> IO (Ptr TreeEntry)
ggit_tree_builder_insert Ptr TreeBuilder
builder' CString
filename' Ptr OId
oid' CUInt
fileMode'
        Maybe TreeEntry
maybeResult <- Ptr TreeEntry
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeEntry
result ((Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry))
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr TreeEntry
result' -> do
            TreeEntry
result'' <- ((ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreeEntry -> TreeEntry
Ggit.TreeEntry.TreeEntry) Ptr TreeEntry
result'
            TreeEntry -> IO TreeEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TreeEntry
result''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
        OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
        Maybe TreeEntry -> IO (Maybe TreeEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
maybeResult
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
     )

#if defined(ENABLE_OVERLOADING)
data TreeBuilderInsertMethodInfo
instance (signature ~ (T.Text -> Ggit.OId.OId -> Ggit.Enums.FileMode -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderInsertMethodInfo a signature where
    overloadedMethod = treeBuilderInsert

#endif

-- method TreeBuilder::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "TreeBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTreeBuilder."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path to remove."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : True
-- Skip return : False

foreign import ccall "ggit_tree_builder_remove" ggit_tree_builder_remove :: 
    Ptr TreeBuilder ->                      -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"})
    CString ->                              -- path : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO ()

-- | Remove an entry from the builder by path.
treeBuilderRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
    a
    -- ^ /@builder@/: a t'GI.Ggit.Objects.TreeBuilder.TreeBuilder'.
    -> T.Text
    -- ^ /@path@/: the path to remove.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
treeBuilderRemove :: a -> Text -> m ()
treeBuilderRemove builder :: a
builder path :: Text
path = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    CString
path' <- Text -> IO CString
textToCString Text
path
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO ()) -> IO ())
-> (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr TreeBuilder -> CString -> Ptr (Ptr GError) -> IO ()
ggit_tree_builder_remove Ptr TreeBuilder
builder' CString
path'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
     )

#if defined(ENABLE_OVERLOADING)
data TreeBuilderRemoveMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderRemoveMethodInfo a signature where
    overloadedMethod = treeBuilderRemove

#endif

-- method TreeBuilder::write
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "TreeBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTreeBuilder."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Ggit" , name = "OId" })
-- throws : True
-- Skip return : False

foreign import ccall "ggit_tree_builder_write" ggit_tree_builder_write :: 
    Ptr TreeBuilder ->                      -- builder : TInterface (Name {namespace = "Ggit", name = "TreeBuilder"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Ggit.OId.OId)

-- | Write the contents of the tree builder as a tree object.
treeBuilderWrite ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeBuilder a) =>
    a
    -- ^ /@builder@/: a t'GI.Ggit.Objects.TreeBuilder.TreeBuilder'.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ the t'GI.Ggit.Structs.OId.OId' of the created tree object or 'P.Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/
treeBuilderWrite :: a -> m (Maybe OId)
treeBuilderWrite builder :: a
builder = IO (Maybe OId) -> m (Maybe OId)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OId) -> m (Maybe OId))
-> IO (Maybe OId) -> m (Maybe OId)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeBuilder
builder' <- a -> IO (Ptr TreeBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    IO (Maybe OId) -> IO () -> IO (Maybe OId)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr OId
result <- (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId))
-> (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a b. (a -> b) -> a -> b
$ Ptr TreeBuilder -> Ptr (Ptr GError) -> IO (Ptr OId)
ggit_tree_builder_write Ptr TreeBuilder
builder'
        Maybe OId
maybeResult <- Ptr OId -> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OId
result ((Ptr OId -> IO OId) -> IO (Maybe OId))
-> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr OId
result' -> do
            OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
            OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
        Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TreeBuilderWriteMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsTreeBuilder a) => O.MethodInfo TreeBuilderWriteMethodInfo a signature where
    overloadedMethod = treeBuilderWrite

#endif