TreeEntry.hs


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

Represents an entry in a tree.
-}

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

module GI.Ggit.Structs.TreeEntry
    ( 

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


 -- * Methods
-- ** getFileMode #method:getFileMode#

#if ENABLE_OVERLOADING
    TreeEntryGetFileModeMethodInfo          ,
#endif
    treeEntryGetFileMode                    ,


-- ** getId #method:getId#

#if ENABLE_OVERLOADING
    TreeEntryGetIdMethodInfo                ,
#endif
    treeEntryGetId                          ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    TreeEntryGetNameMethodInfo              ,
#endif
    treeEntryGetName                        ,


-- ** getObjectType #method:getObjectType#

#if ENABLE_OVERLOADING
    TreeEntryGetObjectTypeMethodInfo        ,
#endif
    treeEntryGetObjectType                  ,


-- ** ref #method:ref#

#if ENABLE_OVERLOADING
    TreeEntryRefMethodInfo                  ,
#endif
    treeEntryRef                            ,


-- ** unref #method:unref#

#if 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.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)
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

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


#if 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 '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 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 'GI.Ggit.Structs.OId.OId' of the entry.
-}
treeEntryGetId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    TreeEntry
    {- ^ /@entry@/: a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m (Maybe Ggit.OId.OId)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or '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 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 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the name of the tree entry or '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 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 '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 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 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m (Maybe TreeEntry)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or '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 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 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
    -> m ()
treeEntryUnref entry = liftIO $ do
    entry' <- unsafeManagedPtrGetPtr entry
    ggit_tree_entry_unref entry'
    touchManagedPtr entry
    return ()

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

#endif

#if 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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif