{-# 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 (Eq)
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

-- | 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 o = do
        gtype <- c_ggit_tree_entry_get_type
        B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_boxed)

    fromGValue gv = do
        ptr <- B.GValue.get_boxed gv :: IO (Ptr TreeEntry)
        B.ManagedPtr.newBoxed TreeEntry ptr



-- | A convenience alias for `Nothing` :: `Maybe` `TreeEntry`.
noTreeEntry :: Maybe TreeEntry
noTreeEntry = 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 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)
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 entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_get_id entry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr entry
    return 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 entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_get_name entry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr entry
    return 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 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)
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 entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    result <- ggit_tree_entry_ref entry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed TreeEntry) result'
        return result''
    touchManagedPtr entry
    return 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 entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    ggit_tree_entry_unref entry'
    touchManagedPtr entry
    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