#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Ggit.Objects.Tree
(
Tree(..) ,
IsTree ,
toTree ,
noTree ,
#if ENABLE_OVERLOADING
TreeGetMethodInfo ,
#endif
treeGet ,
#if ENABLE_OVERLOADING
TreeGetByNameMethodInfo ,
#endif
treeGetByName ,
#if ENABLE_OVERLOADING
TreeGetByPathMethodInfo ,
#endif
treeGetByPath ,
#if ENABLE_OVERLOADING
TreeGetIdMethodInfo ,
#endif
treeGetId ,
#if ENABLE_OVERLOADING
TreeSizeMethodInfo ,
#endif
treeSize ,
#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
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, 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]
toTree :: (MonadIO m, IsTree o) => o -> m Tree
toTree = liftIO . unsafeCastTo 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
foreign import ccall "ggit_tree_get" ggit_tree_get ::
Ptr Tree ->
Word32 ->
IO (Ptr Ggit.TreeEntry.TreeEntry)
treeGet ::
(B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
a
-> Word32
-> m (Maybe Ggit.TreeEntry.TreeEntry)
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
foreign import ccall "ggit_tree_get_by_name" ggit_tree_get_by_name ::
Ptr Tree ->
CString ->
IO (Ptr Ggit.TreeEntry.TreeEntry)
treeGetByName ::
(B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
a
-> T.Text
-> m (Maybe Ggit.TreeEntry.TreeEntry)
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
foreign import ccall "ggit_tree_get_by_path" ggit_tree_get_by_path ::
Ptr Tree ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.TreeEntry.TreeEntry)
treeGetByPath ::
(B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
a
-> T.Text
-> m (Maybe Ggit.TreeEntry.TreeEntry)
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
foreign import ccall "ggit_tree_get_id" ggit_tree_get_id ::
Ptr Tree ->
IO (Ptr Ggit.OId.OId)
treeGetId ::
(B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
a
-> m (Maybe Ggit.OId.OId)
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
foreign import ccall "ggit_tree_size" ggit_tree_size ::
Ptr Tree ->
IO Word32
treeSize ::
(B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
a
-> m Word32
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
foreign import ccall "ggit_tree_walk" ggit_tree_walk ::
Ptr Tree ->
CUInt ->
FunPtr Ggit.Callbacks.C_TreeWalkCallback ->
Ptr () ->
Ptr (Ptr GError) ->
IO ()
treeWalk ::
(B.CallStack.HasCallStack, MonadIO m, IsTree a) =>
a
-> Ggit.Enums.TreeWalkMode
-> Ggit.Callbacks.TreeWalkCallback
-> m ()
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