{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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(..)                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [ref]("GI.Ggit.Structs.TreeEntry#g:method:ref"), [unref]("GI.Ggit.Structs.TreeEntry#g:method:unref").
-- 
-- ==== Getters
-- [getFileMode]("GI.Ggit.Structs.TreeEntry#g:method:getFileMode"), [getId]("GI.Ggit.Structs.TreeEntry#g:method:getId"), [getName]("GI.Ggit.Structs.TreeEntry#g:method:getName"), [getObjectType]("GI.Ggit.Structs.TreeEntry#g:method:getObjectType").
-- 
-- ==== Setters
-- /None/.

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

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

foreign import ccall "ggit_tree_entry_get_type" c_ggit_tree_entry_get_type :: 
    IO GType

type instance O.ParentTypes TreeEntry = '[]
instance O.HasParentTypes TreeEntry

instance B.Types.TypedObject TreeEntry where
    glibType :: IO GType
glibType = IO GType
c_ggit_tree_entry_get_type

instance B.Types.GBoxed TreeEntry

-- | Convert 'TreeEntry' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe TreeEntry) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_tree_entry_get_type
    gvalueSet_ :: Ptr GValue -> Maybe TreeEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TreeEntry
P.Nothing = Ptr GValue -> Ptr TreeEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr TreeEntry
forall a. Ptr a
FP.nullPtr :: FP.Ptr TreeEntry)
    gvalueSet_ Ptr GValue
gv (P.Just TreeEntry
obj) = TreeEntry -> (Ptr TreeEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeEntry
obj (Ptr GValue -> Ptr TreeEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe TreeEntry)
gvalueGet_ Ptr GValue
gv = do
        Ptr TreeEntry
ptr <- Ptr GValue -> IO (Ptr TreeEntry)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr TreeEntry)
        if Ptr TreeEntry
ptr Ptr TreeEntry -> Ptr TreeEntry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TreeEntry
forall a. Ptr a
FP.nullPtr
        then TreeEntry -> Maybe TreeEntry
forall a. a -> Maybe a
P.Just (TreeEntry -> Maybe TreeEntry)
-> IO TreeEntry -> IO (Maybe TreeEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TreeEntry -> TreeEntry
TreeEntry Ptr TreeEntry
ptr
        else Maybe TreeEntry -> IO (Maybe TreeEntry)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
forall a. Maybe a
P.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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m FileMode
treeEntryGetFileMode TreeEntry
entry = IO FileMode -> m FileMode
forall a. IO a -> m a
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 a. a -> IO a
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.OverloadedMethod TreeEntryGetFileModeMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryGetFileMode

instance O.OverloadedMethodInfo TreeEntryGetFileModeMethodInfo TreeEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetFileMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m (Maybe OId)
treeEntryGetId TreeEntry
entry = IO (Maybe OId) -> m (Maybe OId)
forall a. IO a -> m a
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
$ \Ptr OId
result' -> do
        OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
        OId -> IO OId
forall a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod TreeEntryGetIdMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryGetId

instance O.OverloadedMethodInfo TreeEntryGetIdMethodInfo TreeEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m (Maybe Text)
treeEntryGetName TreeEntry
entry = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod TreeEntryGetNameMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryGetName

instance O.OverloadedMethodInfo TreeEntryGetNameMethodInfo TreeEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m GType
treeEntryGetObjectType TreeEntry
entry = IO GType -> m GType
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'

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

instance O.OverloadedMethodInfo TreeEntryGetObjectTypeMethodInfo TreeEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetObjectType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m (Maybe TreeEntry)
treeEntryRef TreeEntry
entry = IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall a. IO a -> m a
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
$ \Ptr TreeEntry
result' -> do
        TreeEntry
result'' <- ((ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TreeEntry -> TreeEntry
TreeEntry) Ptr TreeEntry
result'
        TreeEntry -> IO TreeEntry
forall a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod TreeEntryRefMethodInfo TreeEntry signature where
    overloadedMethod = treeEntryRef

instance O.OverloadedMethodInfo TreeEntryRefMethodInfo TreeEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m ()
treeEntryUnref TreeEntry
entry = 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 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TreeEntryUnrefMethodInfo TreeEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-TreeEntry.html#v: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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTreeEntryMethod t TreeEntry, O.OverloadedMethod info TreeEntry p, R.HasField t TreeEntry p) => R.HasField t TreeEntry p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveTreeEntryMethod t TreeEntry, O.OverloadedMethodInfo info TreeEntry) => OL.IsLabel t (O.MethodProxy info TreeEntry) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif