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

module GI.Ggit.Objects.Tree
    ( 

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


 -- * Methods
-- ** get #method:get#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeGetMethodInfo                       ,
#endif
    treeGet                                 ,


-- ** getByName #method:getByName#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeGetByNameMethodInfo                 ,
#endif
    treeGetByName                           ,


-- ** getByPath #method:getByPath#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeGetByPathMethodInfo                 ,
#endif
    treeGetByPath                           ,


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


-- ** size #method:size#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TreeSizeMethodInfo                      ,
#endif
    treeSize                                ,


-- ** walk #method:walk#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.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 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

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
    

class GObject o => IsTree o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Tree a) =>
    IsTree a
#endif
instance IsTree Tree
instance Ggit.Object.IsObject Tree
instance Ggit.Native.IsNative Tree
instance Ggit.ObjectFactoryBase.IsObjectFactoryBase Tree
instance GObject.Object.IsObject Tree

toTree :: (MonadIO m, IsTree o) => o -> m Tree
toTree = liftIO . unsafeCastTo Tree

noTree :: Maybe Tree
noTree = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveTreeMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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) => O.IsLabelProxy t (Tree -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveTreeMethod t Tree, O.MethodInfo info Tree p) => O.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

#endif

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 Ggit.TreeEntry.TreeEntry
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
treeGet tree i = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    result <- ggit_tree_get tree' i
    checkUnexpectedReturnNULL "treeGet" result
    result' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result
    touchManagedPtr tree
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeGetMethodInfo
instance (signature ~ (Word32 -> m 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 Ggit.TreeEntry.TreeEntry
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. -}
treeGetByName tree name = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    name' <- textToCString name
    result <- ggit_tree_get_by_name tree' name'
    checkUnexpectedReturnNULL "treeGetByName" result
    result' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result
    touchManagedPtr tree
    freeMem name'
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeGetByNameMethodInfo
instance (signature ~ (T.Text -> m 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 Ggit.TreeEntry.TreeEntry
    {- ^ __Returns:__ a 'GI.Ggit.Structs.TreeEntry.TreeEntry'. /(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'
        checkUnexpectedReturnNULL "treeGetByPath" result
        result' <- (wrapBoxed Ggit.TreeEntry.TreeEntry) result
        touchManagedPtr tree
        freeMem path'
        return result'
     ) (do
        freeMem path'
     )

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeGetByPathMethodInfo
instance (signature ~ (T.Text -> m 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 Ggit.OId.OId
    {- ^ __Returns:__ a 'GI.Ggit.Structs.OId.OId'. -}
treeGetId tree = liftIO $ do
    tree' <- unsafeManagedPtrCastPtr tree
    result <- ggit_tree_get_id tree'
    checkUnexpectedReturnNULL "treeGetId" result
    result' <- (wrapBoxed Ggit.OId.OId) result
    touchManagedPtr tree
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeGetIdMethodInfo
instance (signature ~ (m 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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TreeWalkMethodInfo
instance (signature ~ (Ggit.Enums.TreeWalkMode -> Ggit.Callbacks.TreeWalkCallback -> m ()), MonadIO m, IsTree a) => O.MethodInfo TreeWalkMethodInfo a signature where
    overloadedMethod _ = treeWalk

#endif