Tree.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 a tree object.
-}

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

module GI.Ggit.Objects.Tree
    ( 

-- * Exported types
    Tree(..)                                ,
    IsTree                                  ,
    toTree                                  ,
    noTree                                  ,


 -- * Methods
-- ** get #method:get#

#if ENABLE_OVERLOADING
    TreeGetMethodInfo                       ,
#endif
    treeGet                                 ,


-- ** getByName #method:getByName#

#if ENABLE_OVERLOADING
    TreeGetByNameMethodInfo                 ,
#endif
    treeGetByName                           ,


-- ** getByPath #method:getByPath#

#if ENABLE_OVERLOADING
    TreeGetByPathMethodInfo                 ,
#endif
    treeGetByPath                           ,


-- ** getId #method:getId#

#if ENABLE_OVERLOADING
    TreeGetIdMethodInfo                     ,
#endif
    treeGetId                               ,


-- ** size #method:size#

#if ENABLE_OVERLOADING
    TreeSizeMethodInfo                      ,
#endif
    treeSize                                ,


-- ** walk #method:walk#

#if ENABLE_OVERLOADING
    TreeWalkMethodInfo                      ,
#endif
    treeWalk                                ,




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Ggit.Callbacks as Ggit.Callbacks
import {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.TreeEntry as Ggit.TreeEntry

-- | Memory-managed wrapper type.
newtype Tree = Tree (ManagedPtr Tree)
foreign import ccall "ggit_tree_get_type"
    c_ggit_tree_get_type :: IO GType

instance GObject Tree where
    gobjectType = c_ggit_tree_get_type
    

-- | Type class for types which can be safely cast to `Tree`, for instance with `toTree`.
class (GObject o, O.IsDescendantOf Tree o) => IsTree o
instance (GObject o, O.IsDescendantOf Tree o) => IsTree o

instance O.HasParentTypes Tree
type instance O.ParentTypes Tree = '[Ggit.Object.Object, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]

-- | Cast to `Tree`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTree :: (MonadIO m, IsTree o) => o -> m Tree
toTree = liftIO . unsafeCastTo Tree

-- | A convenience alias for `Nothing` :: `Maybe` `Tree`.
noTree :: Maybe Tree
noTree = Nothing

#if ENABLE_OVERLOADING
type family ResolveTreeMethod (t :: Symbol) (o :: *) :: * where
    ResolveTreeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTreeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTreeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTreeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTreeMethod "get" o = TreeGetMethodInfo
    ResolveTreeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTreeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTreeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTreeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTreeMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTreeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTreeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTreeMethod "size" o = TreeSizeMethodInfo
    ResolveTreeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTreeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTreeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTreeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTreeMethod "walk" o = TreeWalkMethodInfo
    ResolveTreeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTreeMethod "getByName" o = TreeGetByNameMethodInfo
    ResolveTreeMethod "getByPath" o = TreeGetByPathMethodInfo
    ResolveTreeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTreeMethod "getId" o = TreeGetIdMethodInfo
    ResolveTreeMethod "getOwner" o = Ggit.Object.ObjectGetOwnerMethodInfo
    ResolveTreeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTreeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTreeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTreeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTreeMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTreeMethod t Tree, O.MethodInfo info Tree p) => OL.IsLabel t (Tree -> 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

#if ENABLE_OVERLOADING
instance O.HasAttributeList Tree
type instance O.AttributeList Tree = TreeAttributeList
type TreeAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
type instance O.SignalList Tree = TreeSignalList
type TreeSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Tree::get
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the entry.", 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_get" ggit_tree_get :: 
    Ptr Tree ->                             -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"})
    Word32 ->                               -- i : TBasicType TUInt
    IO (Ptr Ggit.TreeEntry.TreeEntry)

{- |
Get a tree entry by index.
-}
treeGet ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> Word32
    {- ^ /@i@/: the index of the entry. -}
    -> m (Maybe Ggit.TreeEntry.TreeEntry)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. -}
treeGet tree i = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    result <- ggit_tree_get tree' i
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result'
        return result''
    touchManagedPtr tree
    return maybeResult

#if ENABLE_OVERLOADING
data TreeGetMethodInfo
instance (signature ~ (Word32 -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTree a) => O.MethodInfo TreeGetMethodInfo a signature where
    overloadedMethod _ = treeGet

#endif

-- method Tree::get_by_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a filename.", 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_get_by_name" ggit_tree_get_by_name :: 
    Ptr Tree ->                             -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Ggit.TreeEntry.TreeEntry)

{- |
Get a tree entry by name.
-}
treeGetByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> T.Text
    {- ^ /@name@/: a filename. -}
    -> m (Maybe Ggit.TreeEntry.TreeEntry)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. -}
treeGetByName tree name = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    name' <- textToCString name
    result <- ggit_tree_get_by_name tree' name'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result'
        return result''
    touchManagedPtr tree
    freeMem name'
    return maybeResult

#if ENABLE_OVERLOADING
data TreeGetByNameMethodInfo
instance (signature ~ (T.Text -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTree a) => O.MethodInfo TreeGetByNameMethodInfo a signature where
    overloadedMethod _ = treeGetByName

#endif

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

foreign import ccall "ggit_tree_get_by_path" ggit_tree_get_by_path :: 
    Ptr Tree ->                             -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"})
    CString ->                              -- path : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Ggit.TreeEntry.TreeEntry)

{- |
Retrieves a tree entry contained in a tree or in any of its subtrees,
given its relative path.
-}
treeGetByPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> T.Text
    {- ^ /@path@/: a path. -}
    -> m (Maybe Ggit.TreeEntry.TreeEntry)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry' or 'Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
treeGetByPath tree path = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    path' <- textToCString path
    onException (do
        result <- propagateGError $ ggit_tree_get_by_path tree' path'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result'
            return result''
        touchManagedPtr tree
        freeMem path'
        return maybeResult
     ) (do
        freeMem path'
     )

#if ENABLE_OVERLOADING
data TreeGetByPathMethodInfo
instance (signature ~ (T.Text -> m (Maybe Ggit.TreeEntry.TreeEntry)), MonadIO m, IsTree a) => O.MethodInfo TreeGetByPathMethodInfo a signature where
    overloadedMethod _ = treeGetByPath

#endif

-- method Tree::get_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", 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_get_id" ggit_tree_get_id :: 
    Ptr Tree ->                             -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"})
    IO (Ptr Ggit.OId.OId)

{- |
Get the 'GI.Ggit.Structs.OId.OId' of the tree.
-}
treeGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> m (Maybe Ggit.OId.OId)
    {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId' or 'Nothing'. -}
treeGetId tree = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    result <- ggit_tree_get_id tree'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr tree
    return maybeResult

#if ENABLE_OVERLOADING
data TreeGetIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsTree a) => O.MethodInfo TreeGetIdMethodInfo a signature where
    overloadedMethod _ = treeGetId

#endif

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

foreign import ccall "ggit_tree_size" ggit_tree_size :: 
    Ptr Tree ->                             -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"})
    IO Word32

{- |
Get the number of entries in the tree.
-}
treeSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> m Word32
    {- ^ __Returns:__ the number of entries in the tree. -}
treeSize tree = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    result <- ggit_tree_size tree'
    touchManagedPtr tree
    return result

#if ENABLE_OVERLOADING
data TreeSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTree a) => O.MethodInfo TreeSizeMethodInfo a signature where
    overloadedMethod _ = treeSize

#endif

-- method Tree::walk
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tree", argType = TInterface (Name {namespace = "Ggit", name = "Tree"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitTree.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Ggit", name = "TreeWalkMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the walking order.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Ggit", name = "TreeWalkCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the callback to call for each entry.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for the callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "ggit_tree_walk" ggit_tree_walk :: 
    Ptr Tree ->                             -- tree : TInterface (Name {namespace = "Ggit", name = "Tree"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Ggit", name = "TreeWalkMode"})
    FunPtr Ggit.Callbacks.C_TreeWalkCallback -> -- callback : TInterface (Name {namespace = "Ggit", name = "TreeWalkCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
Walk all the entries of a tree object recursively (resolving and walking
subtrees of the tree as needed). The /@error@/ will be set to the error returned
by /@callback@/ (if any).
-}
treeWalk ::
    (B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
    a
    {- ^ /@tree@/: a 'GI.Ggit.Objects.Tree.Tree'. -}
    -> Ggit.Enums.TreeWalkMode
    {- ^ /@mode@/: the walking order. -}
    -> Ggit.Callbacks.TreeWalkCallback
    {- ^ /@callback@/: the callback to call for each entry. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
treeWalk tree mode callback = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    let mode' = (fromIntegral . fromEnum) mode
    callback' <- Ggit.Callbacks.mk_TreeWalkCallback (Ggit.Callbacks.wrap_TreeWalkCallback Nothing (Ggit.Callbacks.drop_closures_TreeWalkCallback callback))
    let userData = nullPtr
    onException (do
        propagateGError $ ggit_tree_walk tree' mode' callback' userData
        safeFreeFunPtr $ castFunPtrToPtr callback'
        touchManagedPtr tree
        return ()
     ) (do
        safeFreeFunPtr $ castFunPtrToPtr callback'
        return ()
     )

#if ENABLE_OVERLOADING
data TreeWalkMethodInfo
instance (signature ~ (Ggit.Enums.TreeWalkMode -> Ggit.Callbacks.TreeWalkCallback -> m ()), MonadIO m, IsTree a) => O.MethodInfo TreeWalkMethodInfo a signature where
    overloadedMethod _ = treeWalk

#endif