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

Represents an entry in a tree.
-}

module GI.Ggit.Structs.TreeEntry
    ( 

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


 -- * Methods
-- ** getFileMode #method:getFileMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeEntryGetFileModeMethodInfo          ,
#endif
    treeEntryGetFileMode                    ,


-- ** getId #method:getId#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeEntryGetIdMethodInfo                ,
#endif
    treeEntryGetId                          ,


-- ** getName #method:getName#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeEntryGetNameMethodInfo              ,
#endif
    treeEntryGetName                        ,


-- ** getObjectType #method:getObjectType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeEntryGetObjectTypeMethodInfo        ,
#endif
    treeEntryGetObjectType                  ,


-- ** ref #method:ref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeEntryRefMethodInfo                  ,
#endif
    treeEntryRef                            ,


-- ** unref #method:unref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId

newtype TreeEntry = TreeEntry (ManagedPtr TreeEntry)
foreign import ccall "ggit_tree_entry_get_type" c_ggit_tree_entry_get_type :: 
    IO GType

instance BoxedObject TreeEntry where
    boxedType _ = c_ggit_tree_entry_get_type

noTreeEntry :: Maybe TreeEntry
noTreeEntry = Nothing


#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Ggit.Enums.FileMode' of a tree entry.
-}
treeEntryGetFileMode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m Ggit.Enums.FileMode
    {- ^ __Returns:__ the 'GI.Ggit.Enums.FileMode' of a tree entry. -}
treeEntryGetFileMode entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_get_file_mode entry'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr entry
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Ggit.Structs.OId.OId' of the entry.
-}
treeEntryGetId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m Ggit.OId.OId
    {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId'. -}
treeEntryGetId entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_get_id entry'
    checkUnexpectedReturnNULL "treeEntryGetId" result
    result' <- (wrapBoxed Ggit.OId.OId) result
    touchManagedPtr entry
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeEntryGetIdMethodInfo
instance (signature ~ (m 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 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m T.Text
    {- ^ __Returns:__ the name of the tree entry. -}
treeEntryGetName entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_get_name entry'
    checkUnexpectedReturnNULL "treeEntryGetName" result
    result' <- cstringToText result
    touchManagedPtr entry
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeEntryGetNameMethodInfo
instance (signature ~ (m 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 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m GType
    {- ^ __Returns:__ a 'GType'. -}
treeEntryGetObjectType entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_get_object_type entry'
    let result' = GType result
    touchManagedPtr entry
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m TreeEntry
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
treeEntryRef entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_ref entry'
    checkUnexpectedReturnNULL "treeEntryRef" result
    result' <- (newBoxed TreeEntry) result
    touchManagedPtr entry
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeEntryRefMethodInfo
instance (signature ~ (m 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 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m ()
treeEntryUnref entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    ggit_tree_entry_unref entry'
    touchManagedPtr entry
    return ()

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

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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) => O.IsLabelProxy t (TreeEntry -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

#endif