{-# LANGUAGE TypeApplications #-}


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

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

module GI.Ggit.Structs.TreeEntry
    ( 

-- * Exported types
    TreeEntry(..)                           ,
    noTreeEntry                             ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveTreeEntryMethod                  ,
#endif


-- ** getFileMode #method:getFileMode#

#if defined(ENABLE_OVERLOADING)
    TreeEntryGetFileModeMethodInfo          ,
#endif
    treeEntryGetFileMode                    ,


-- ** getId #method:getId#

#if defined(ENABLE_OVERLOADING)
    TreeEntryGetIdMethodInfo                ,
#endif
    treeEntryGetId                          ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    TreeEntryGetNameMethodInfo              ,
#endif
    treeEntryGetName                        ,


-- ** getObjectType #method:getObjectType#

#if defined(ENABLE_OVERLOADING)
    TreeEntryGetObjectTypeMethodInfo        ,
#endif
    treeEntryGetObjectType                  ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    TreeEntryRefMethodInfo                  ,
#endif
    treeEntryRef                            ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    TreeEntryUnrefMethodInfo                ,
#endif
    treeEntryUnref                          ,




    ) 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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId

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

instance BoxedObject TreeEntry where
    boxedType :: TreeEntry -> IO GType
boxedType _ = IO GType
c_ggit_tree_entry_get_type

-- | Convert 'TreeEntry' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue TreeEntry where
    toGValue :: TreeEntry -> IO GValue
toGValue o :: TreeEntry
o = do
        GType
gtype <- IO GType
c_ggit_tree_entry_get_type
        TreeEntry -> (Ptr TreeEntry -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeEntry
o (GType
-> (GValue -> Ptr TreeEntry -> IO ()) -> Ptr TreeEntry -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TreeEntry -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO TreeEntry
fromGValue gv :: GValue
gv = do
        Ptr TreeEntry
ptr <- GValue -> IO (Ptr TreeEntry)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr TreeEntry)
        (ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TreeEntry -> TreeEntry
TreeEntry Ptr TreeEntry
ptr
        
    

-- | A convenience alias for `Nothing` :: `Maybe` `TreeEntry`.
noTreeEntry :: Maybe TreeEntry
noTreeEntry :: Maybe TreeEntry
noTreeEntry = Maybe TreeEntry
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TreeEntry
type instance O.AttributeList TreeEntry = TreeEntryAttributeList
type TreeEntryAttributeList = ('[ ] :: [(Symbol, *)])
#endif

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

foreign import ccall "ggit_tree_entry_get_file_mode" ggit_tree_entry_get_file_mode :: 
    Ptr TreeEntry ->                        -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"})
    IO CUInt

-- | Gets the t'GI.Ggit.Enums.FileMode' of a tree entry.
treeEntryGetFileMode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.TreeEntry.TreeEntry'.
    -> m Ggit.Enums.FileMode
    -- ^ __Returns:__ the t'GI.Ggit.Enums.FileMode' of a tree entry.
treeEntryGetFileMode :: TreeEntry -> m FileMode
treeEntryGetFileMode entry :: TreeEntry
entry = IO FileMode -> m FileMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FileMode -> m FileMode) -> IO FileMode -> m FileMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
    CUInt
result <- Ptr TreeEntry -> IO CUInt
ggit_tree_entry_get_file_mode Ptr TreeEntry
entry'
    let result' :: FileMode
result' = (Int -> FileMode
forall a. Enum a => Int -> a
toEnum (Int -> FileMode) -> (CUInt -> Int) -> CUInt -> FileMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
    FileMode -> IO FileMode
forall (m :: * -> *) a. Monad m => a -> m a
return FileMode
result'

#if defined(ENABLE_OVERLOADING)
data TreeEntryGetFileModeMethodInfo
instance (signature ~ (m Ggit.Enums.FileMode), MonadIO m) => O.MethodInfo TreeEntryGetFileModeMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryGetFileMode

#endif

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

foreign import ccall "ggit_tree_entry_get_id" ggit_tree_entry_get_id :: 
    Ptr TreeEntry ->                        -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"})
    IO (Ptr Ggit.OId.OId)

-- | Get the t'GI.Ggit.Structs.OId.OId' of the entry.
treeEntryGetId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.TreeEntry.TreeEntry'.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ a t'GI.Ggit.Structs.OId.OId' or 'P.Nothing'.
treeEntryGetId :: TreeEntry -> m (Maybe OId)
treeEntryGetId entry :: TreeEntry
entry = 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 TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
    Ptr OId
result <- Ptr TreeEntry -> IO (Ptr OId)
ggit_tree_entry_get_id Ptr TreeEntry
entry'
    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''
    TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
    Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeEntryGetIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo TreeEntryGetIdMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryGetId

#endif

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

foreign import ccall "ggit_tree_entry_get_name" ggit_tree_entry_get_name :: 
    Ptr TreeEntry ->                        -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"})
    IO CString

-- | Get the name of the tree entry.
treeEntryGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.TreeEntry.TreeEntry'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the tree entry or 'P.Nothing'.
treeEntryGetName :: TreeEntry -> m (Maybe Text)
treeEntryGetName entry :: TreeEntry
entry = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
    CString
result <- Ptr TreeEntry -> IO CString
ggit_tree_entry_get_name Ptr TreeEntry
entry'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeEntryGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo TreeEntryGetNameMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryGetName

#endif

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

foreign import ccall "ggit_tree_entry_get_object_type" ggit_tree_entry_get_object_type :: 
    Ptr TreeEntry ->                        -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"})
    IO CGType

-- | Get the type of the tree entry object.
treeEntryGetObjectType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.TreeEntry.TreeEntry'.
    -> m GType
    -- ^ __Returns:__ a t'GType'.
treeEntryGetObjectType :: TreeEntry -> m GType
treeEntryGetObjectType entry :: TreeEntry
entry = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
    Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
    CGType
result <- Ptr TreeEntry -> IO CGType
ggit_tree_entry_get_object_type Ptr TreeEntry
entry'
    let result' :: GType
result' = CGType -> GType
GType CGType
result
    TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
    GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'

#if defined(ENABLE_OVERLOADING)
data TreeEntryGetObjectTypeMethodInfo
instance (signature ~ (m GType), MonadIO m) => O.MethodInfo TreeEntryGetObjectTypeMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryGetObjectType

#endif

-- method TreeEntry::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "TreeEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTreeEntry." , 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_entry_ref" ggit_tree_entry_ref :: 
    Ptr TreeEntry ->                        -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"})
    IO (Ptr TreeEntry)

-- | Atomically increments the reference count of /@entry@/ by one.
-- This function is MT-safe and may be called from any thread.
treeEntryRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.TreeEntry.TreeEntry'.
    -> m (Maybe TreeEntry)
    -- ^ __Returns:__ a t'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'P.Nothing'.
treeEntryRef :: TreeEntry -> m (Maybe TreeEntry)
treeEntryRef entry :: TreeEntry
entry = 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 TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
    Ptr TreeEntry
result <- Ptr TreeEntry -> IO (Ptr TreeEntry)
ggit_tree_entry_ref Ptr TreeEntry
entry'
    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
newBoxed ManagedPtr TreeEntry -> TreeEntry
TreeEntry) Ptr TreeEntry
result'
        TreeEntry -> IO TreeEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TreeEntry
result''
    TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
    Maybe TreeEntry -> IO (Maybe TreeEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
maybeResult

#if defined(ENABLE_OVERLOADING)
data TreeEntryRefMethodInfo
instance (signature ~ (m (Maybe TreeEntry)), MonadIO m) => O.MethodInfo TreeEntryRefMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryRef

#endif

-- method TreeEntry::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "TreeEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitTreeEntry." , 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_entry_unref" ggit_tree_entry_unref :: 
    Ptr TreeEntry ->                        -- entry : TInterface (Name {namespace = "Ggit", name = "TreeEntry"})
    IO ()

-- | Atomically decrements the reference count of /@entry@/ by one.
-- If the reference count drops to 0, /@entry@/ is freed.
treeEntryUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.TreeEntry.TreeEntry'.
    -> m ()
treeEntryUnref :: TreeEntry -> m ()
treeEntryUnref entry :: TreeEntry
entry = 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 TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
    Ptr TreeEntry -> IO ()
ggit_tree_entry_unref Ptr TreeEntry
entry'
    TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TreeEntryUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TreeEntryUnrefMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryUnref

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveTreeEntryMethod (t :: Symbol) (o :: *) :: * where
    ResolveTreeEntryMethod "ref" o = TreeEntryRefMethodInfo
    ResolveTreeEntryMethod "unref" o = TreeEntryUnrefMethodInfo
    ResolveTreeEntryMethod "getFileMode" o = TreeEntryGetFileModeMethodInfo
    ResolveTreeEntryMethod "getId" o = TreeEntryGetIdMethodInfo
    ResolveTreeEntryMethod "getName" o = TreeEntryGetNameMethodInfo
    ResolveTreeEntryMethod "getObjectType" o = TreeEntryGetObjectTypeMethodInfo
    ResolveTreeEntryMethod l o = O.MethodResolutionFailed l o

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

#endif