{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Tree
(
Tree(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveTreeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TreeDestroyMethodInfo ,
#endif
treeDestroy ,
#if defined(ENABLE_OVERLOADING)
TreeForeachMethodInfo ,
#endif
treeForeach ,
#if defined(ENABLE_OVERLOADING)
TreeForeachNodeMethodInfo ,
#endif
treeForeachNode ,
#if defined(ENABLE_OVERLOADING)
TreeHeightMethodInfo ,
#endif
treeHeight ,
#if defined(ENABLE_OVERLOADING)
TreeInsertMethodInfo ,
#endif
treeInsert ,
#if defined(ENABLE_OVERLOADING)
TreeInsertNodeMethodInfo ,
#endif
treeInsertNode ,
#if defined(ENABLE_OVERLOADING)
TreeLookupMethodInfo ,
#endif
treeLookup ,
#if defined(ENABLE_OVERLOADING)
TreeLookupExtendedMethodInfo ,
#endif
treeLookupExtended ,
#if defined(ENABLE_OVERLOADING)
TreeLookupNodeMethodInfo ,
#endif
treeLookupNode ,
#if defined(ENABLE_OVERLOADING)
TreeLowerBoundMethodInfo ,
#endif
treeLowerBound ,
treeNewFull ,
#if defined(ENABLE_OVERLOADING)
TreeNnodesMethodInfo ,
#endif
treeNnodes ,
#if defined(ENABLE_OVERLOADING)
TreeNodeFirstMethodInfo ,
#endif
treeNodeFirst ,
#if defined(ENABLE_OVERLOADING)
TreeNodeLastMethodInfo ,
#endif
treeNodeLast ,
#if defined(ENABLE_OVERLOADING)
TreeRefMethodInfo ,
#endif
treeRef ,
#if defined(ENABLE_OVERLOADING)
TreeRemoveMethodInfo ,
#endif
treeRemove ,
#if defined(ENABLE_OVERLOADING)
TreeRemoveAllMethodInfo ,
#endif
treeRemoveAll ,
#if defined(ENABLE_OVERLOADING)
TreeReplaceMethodInfo ,
#endif
treeReplace ,
#if defined(ENABLE_OVERLOADING)
TreeReplaceNodeMethodInfo ,
#endif
treeReplaceNode ,
#if defined(ENABLE_OVERLOADING)
TreeSearchMethodInfo ,
#endif
treeSearch ,
#if defined(ENABLE_OVERLOADING)
TreeSearchNodeMethodInfo ,
#endif
treeSearchNode ,
#if defined(ENABLE_OVERLOADING)
TreeStealMethodInfo ,
#endif
treeSteal ,
#if defined(ENABLE_OVERLOADING)
TreeTraverseMethodInfo ,
#endif
treeTraverse ,
#if defined(ENABLE_OVERLOADING)
TreeUnrefMethodInfo ,
#endif
treeUnref ,
#if defined(ENABLE_OVERLOADING)
TreeUpperBoundMethodInfo ,
#endif
treeUpperBound ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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 Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
import {-# SOURCE #-} qualified GI.GLib.Structs.TreeNode as GLib.TreeNode
#else
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
import {-# SOURCE #-} qualified GI.GLib.Structs.TreeNode as GLib.TreeNode
#endif
newtype Tree = Tree (SP.ManagedPtr Tree)
deriving (Tree -> Tree -> Bool
(Tree -> Tree -> Bool) -> (Tree -> Tree -> Bool) -> Eq Tree
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tree -> Tree -> Bool
== :: Tree -> Tree -> Bool
$c/= :: Tree -> Tree -> Bool
/= :: Tree -> Tree -> Bool
Eq)
instance SP.ManagedPtrNewtype Tree where
toManagedPtr :: Tree -> ManagedPtr Tree
toManagedPtr (Tree ManagedPtr Tree
p) = ManagedPtr Tree
p
foreign import ccall "g_tree_get_type" c_g_tree_get_type ::
IO GType
type instance O.ParentTypes Tree = '[]
instance O.HasParentTypes Tree
instance B.Types.TypedObject Tree where
glibType :: IO GType
glibType = IO GType
c_g_tree_get_type
instance B.Types.GBoxed Tree
instance B.GValue.IsGValue (Maybe Tree) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_tree_get_type
gvalueSet_ :: Ptr GValue -> Maybe Tree -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Tree
P.Nothing = Ptr GValue -> Ptr Tree -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Tree
forall a. Ptr a
FP.nullPtr :: FP.Ptr Tree)
gvalueSet_ Ptr GValue
gv (P.Just Tree
obj) = Tree -> (Ptr Tree -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Tree
obj (Ptr GValue -> Ptr Tree -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Tree)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr Tree)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Tree)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newBoxed Tree ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Tree
type instance O.AttributeList Tree = TreeAttributeList
type TreeAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_tree_new_full" g_tree_new_full ::
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr Tree)
treeNewFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.Callbacks.CompareDataFunc
-> GLib.Callbacks.DestroyNotify
-> m Tree
treeNewFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CompareDataFunc -> DestroyNotify -> m Tree
treeNewFull CompareDataFunc
keyCompareFunc DestroyNotify
keyDestroyFunc = IO Tree -> m Tree
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Tree -> m Tree) -> IO Tree -> m Tree
forall a b. (a -> b) -> a -> b
$ do
keyCompareFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
keyCompareFunc))
ptrkeyDestroyFunc <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
keyDestroyFunc' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrkeyDestroyFunc) keyDestroyFunc)
poke ptrkeyDestroyFunc keyDestroyFunc'
let keyCompareData = FunPtr C_CompareDataFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
keyCompareFunc'
let valueDestroyFunc = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
result <- g_tree_new_full keyCompareFunc' keyCompareData keyDestroyFunc' valueDestroyFunc
checkUnexpectedReturnNULL "treeNewFull" result
result' <- (wrapBoxed Tree) result
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_tree_destroy" g_tree_destroy ::
Ptr Tree ->
IO ()
treeDestroy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m ()
treeDestroy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m ()
treeDestroy Tree
tree = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
g_tree_destroy tree'
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TreeDestroyMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m ()
forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m ()
treeDestroy
instance O.OverloadedMethodInfo TreeDestroyMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeDestroy",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeDestroy"
})
#endif
foreign import ccall "g_tree_foreach" g_tree_foreach ::
Ptr Tree ->
FunPtr GLib.Callbacks.C_TraverseFunc ->
Ptr () ->
IO ()
treeForeach ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> GLib.Callbacks.TraverseFunc
-> m ()
treeForeach :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> TraverseFunc -> m ()
treeForeach Tree
tree TraverseFunc
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
func' <- GLib.Callbacks.mk_TraverseFunc (GLib.Callbacks.wrap_TraverseFunc Nothing func)
let userData = Ptr a
forall a. Ptr a
nullPtr
g_tree_foreach tree' func' userData
safeFreeFunPtr $ castFunPtrToPtr func'
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeForeachMethodInfo
instance (signature ~ (GLib.Callbacks.TraverseFunc -> m ()), MonadIO m) => O.OverloadedMethod TreeForeachMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> TraverseFunc -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> TraverseFunc -> m ()
treeForeach
instance O.OverloadedMethodInfo TreeForeachMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeForeach",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeForeach"
})
#endif
foreign import ccall "g_tree_foreach_node" g_tree_foreach_node ::
Ptr Tree ->
FunPtr GLib.Callbacks.C_TraverseNodeFunc ->
Ptr () ->
IO ()
treeForeachNode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> GLib.Callbacks.TraverseNodeFunc
-> m ()
treeForeachNode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> TraverseNodeFunc -> m ()
treeForeachNode Tree
tree TraverseNodeFunc
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
func' <- GLib.Callbacks.mk_TraverseNodeFunc (GLib.Callbacks.wrap_TraverseNodeFunc Nothing func)
let userData = Ptr a
forall a. Ptr a
nullPtr
g_tree_foreach_node tree' func' userData
safeFreeFunPtr $ castFunPtrToPtr func'
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeForeachNodeMethodInfo
instance (signature ~ (GLib.Callbacks.TraverseNodeFunc -> m ()), MonadIO m) => O.OverloadedMethod TreeForeachNodeMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> TraverseNodeFunc -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> TraverseNodeFunc -> m ()
treeForeachNode
instance O.OverloadedMethodInfo TreeForeachNodeMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeForeachNode",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeForeachNode"
})
#endif
foreign import ccall "g_tree_height" g_tree_height ::
Ptr Tree ->
IO Int32
treeHeight ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m Int32
treeHeight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m Int32
treeHeight Tree
tree = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_height tree'
touchManagedPtr tree
return result
#if defined(ENABLE_OVERLOADING)
data TreeHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod TreeHeightMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m Int32
forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m Int32
treeHeight
instance O.OverloadedMethodInfo TreeHeightMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeHeight",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeHeight"
})
#endif
foreign import ccall "g_tree_insert" g_tree_insert ::
Ptr Tree ->
Ptr () ->
Ptr () ->
IO ()
treeInsert ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> Ptr ()
-> m ()
treeInsert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m ()
treeInsert Tree
tree Ptr ()
key Ptr ()
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
g_tree_insert tree' key value
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeInsertMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m ()), MonadIO m) => O.OverloadedMethod TreeInsertMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> Ptr () -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m ()
treeInsert
instance O.OverloadedMethodInfo TreeInsertMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeInsert",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeInsert"
})
#endif
foreign import ccall "g_tree_insert_node" g_tree_insert_node ::
Ptr Tree ->
Ptr () ->
Ptr () ->
IO (Ptr GLib.TreeNode.TreeNode)
treeInsertNode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> Ptr ()
-> m (Maybe GLib.TreeNode.TreeNode)
treeInsertNode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m (Maybe TreeNode)
treeInsertNode Tree
tree Ptr ()
key Ptr ()
value = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_insert_node tree' key value
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeInsertNodeMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeInsertNodeMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> Ptr () -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m (Maybe TreeNode)
treeInsertNode
instance O.OverloadedMethodInfo TreeInsertNodeMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeInsertNode",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeInsertNode"
})
#endif
foreign import ccall "g_tree_lookup" g_tree_lookup ::
Ptr Tree ->
Ptr () ->
IO (Ptr ())
treeLookup ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> m (Ptr ())
treeLookup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Ptr ())
treeLookup Tree
tree Ptr ()
key = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_lookup tree' key
touchManagedPtr tree
return result
#if defined(ENABLE_OVERLOADING)
data TreeLookupMethodInfo
instance (signature ~ (Ptr () -> m (Ptr ())), MonadIO m) => O.OverloadedMethod TreeLookupMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> m (Ptr ())
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Ptr ())
treeLookup
instance O.OverloadedMethodInfo TreeLookupMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeLookup",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeLookup"
})
#endif
foreign import ccall "g_tree_lookup_extended" g_tree_lookup_extended ::
Ptr Tree ->
Ptr () ->
Ptr (Ptr ()) ->
Ptr (Ptr ()) ->
IO CInt
treeLookupExtended ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> m ((Bool, Ptr (), Ptr ()))
treeLookupExtended :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Bool, Ptr (), Ptr ())
treeLookupExtended Tree
tree Ptr ()
lookupKey = IO (Bool, Ptr (), Ptr ()) -> m (Bool, Ptr (), Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Ptr (), Ptr ()) -> m (Bool, Ptr (), Ptr ()))
-> IO (Bool, Ptr (), Ptr ()) -> m (Bool, Ptr (), Ptr ())
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
origKey <- callocMem :: IO (Ptr (Ptr ()))
value <- callocMem :: IO (Ptr (Ptr ()))
result <- g_tree_lookup_extended tree' lookupKey origKey value
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
origKey' <- peek origKey
value' <- peek value
touchManagedPtr tree
freeMem origKey
freeMem value
return (result', origKey', value')
#if defined(ENABLE_OVERLOADING)
data TreeLookupExtendedMethodInfo
instance (signature ~ (Ptr () -> m ((Bool, Ptr (), Ptr ()))), MonadIO m) => O.OverloadedMethod TreeLookupExtendedMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> m (Bool, Ptr (), Ptr ())
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Bool, Ptr (), Ptr ())
treeLookupExtended
instance O.OverloadedMethodInfo TreeLookupExtendedMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeLookupExtended",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeLookupExtended"
})
#endif
foreign import ccall "g_tree_lookup_node" g_tree_lookup_node ::
Ptr Tree ->
Ptr () ->
IO (Ptr GLib.TreeNode.TreeNode)
treeLookupNode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> m (Maybe GLib.TreeNode.TreeNode)
treeLookupNode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Maybe TreeNode)
treeLookupNode Tree
tree Ptr ()
key = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_lookup_node tree' key
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeLookupNodeMethodInfo
instance (signature ~ (Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeLookupNodeMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Maybe TreeNode)
treeLookupNode
instance O.OverloadedMethodInfo TreeLookupNodeMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeLookupNode",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeLookupNode"
})
#endif
foreign import ccall "g_tree_lower_bound" g_tree_lower_bound ::
Ptr Tree ->
Ptr () ->
IO (Ptr GLib.TreeNode.TreeNode)
treeLowerBound ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> m (Maybe GLib.TreeNode.TreeNode)
treeLowerBound :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Maybe TreeNode)
treeLowerBound Tree
tree Ptr ()
key = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_lower_bound tree' key
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeLowerBoundMethodInfo
instance (signature ~ (Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeLowerBoundMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Maybe TreeNode)
treeLowerBound
instance O.OverloadedMethodInfo TreeLowerBoundMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeLowerBound",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeLowerBound"
})
#endif
foreign import ccall "g_tree_nnodes" g_tree_nnodes ::
Ptr Tree ->
IO Int32
treeNnodes ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m Int32
treeNnodes :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m Int32
treeNnodes Tree
tree = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_nnodes tree'
touchManagedPtr tree
return result
#if defined(ENABLE_OVERLOADING)
data TreeNnodesMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod TreeNnodesMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m Int32
forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m Int32
treeNnodes
instance O.OverloadedMethodInfo TreeNnodesMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeNnodes",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeNnodes"
})
#endif
foreign import ccall "g_tree_node_first" g_tree_node_first ::
Ptr Tree ->
IO (Ptr GLib.TreeNode.TreeNode)
treeNodeFirst ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m (Maybe GLib.TreeNode.TreeNode)
treeNodeFirst :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> m (Maybe TreeNode)
treeNodeFirst Tree
tree = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_node_first tree'
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeNodeFirstMethodInfo
instance (signature ~ (m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeNodeFirstMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> m (Maybe TreeNode)
treeNodeFirst
instance O.OverloadedMethodInfo TreeNodeFirstMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeNodeFirst",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeNodeFirst"
})
#endif
foreign import ccall "g_tree_node_last" g_tree_node_last ::
Ptr Tree ->
IO (Ptr GLib.TreeNode.TreeNode)
treeNodeLast ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m (Maybe GLib.TreeNode.TreeNode)
treeNodeLast :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> m (Maybe TreeNode)
treeNodeLast Tree
tree = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_node_last tree'
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeNodeLastMethodInfo
instance (signature ~ (m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeNodeLastMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> m (Maybe TreeNode)
treeNodeLast
instance O.OverloadedMethodInfo TreeNodeLastMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeNodeLast",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeNodeLast"
})
#endif
foreign import ccall "g_tree_ref" g_tree_ref ::
Ptr Tree ->
IO (Ptr Tree)
treeRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m Tree
treeRef :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m Tree
treeRef Tree
tree = IO Tree -> m Tree
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Tree -> m Tree) -> IO Tree -> m Tree
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_ref tree'
checkUnexpectedReturnNULL "treeRef" result
result' <- (wrapBoxed Tree) result
touchManagedPtr tree
return result'
#if defined(ENABLE_OVERLOADING)
data TreeRefMethodInfo
instance (signature ~ (m Tree), MonadIO m) => O.OverloadedMethod TreeRefMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m Tree
forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m Tree
treeRef
instance O.OverloadedMethodInfo TreeRefMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeRef",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeRef"
})
#endif
foreign import ccall "g_tree_remove" g_tree_remove ::
Ptr Tree ->
Ptr () ->
IO CInt
treeRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> m Bool
treeRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m Bool
treeRemove Tree
tree Ptr ()
key = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_remove tree' key
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr tree
return result'
#if defined(ENABLE_OVERLOADING)
data TreeRemoveMethodInfo
instance (signature ~ (Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod TreeRemoveMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m Bool
treeRemove
instance O.OverloadedMethodInfo TreeRemoveMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeRemove",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeRemove"
})
#endif
foreign import ccall "g_tree_remove_all" g_tree_remove_all ::
Ptr Tree ->
IO ()
treeRemoveAll ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m ()
treeRemoveAll :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m ()
treeRemoveAll Tree
tree = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
g_tree_remove_all tree'
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeRemoveAllMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TreeRemoveAllMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m ()
forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m ()
treeRemoveAll
instance O.OverloadedMethodInfo TreeRemoveAllMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeRemoveAll",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeRemoveAll"
})
#endif
foreign import ccall "g_tree_replace" g_tree_replace ::
Ptr Tree ->
Ptr () ->
Ptr () ->
IO ()
treeReplace ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> Ptr ()
-> m ()
treeReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m ()
treeReplace Tree
tree Ptr ()
key Ptr ()
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
g_tree_replace tree' key value
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeReplaceMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m ()), MonadIO m) => O.OverloadedMethod TreeReplaceMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> Ptr () -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m ()
treeReplace
instance O.OverloadedMethodInfo TreeReplaceMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeReplace",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeReplace"
})
#endif
foreign import ccall "g_tree_replace_node" g_tree_replace_node ::
Ptr Tree ->
Ptr () ->
Ptr () ->
IO (Ptr GLib.TreeNode.TreeNode)
treeReplaceNode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> Ptr ()
-> m (Maybe GLib.TreeNode.TreeNode)
treeReplaceNode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m (Maybe TreeNode)
treeReplaceNode Tree
tree Ptr ()
key Ptr ()
value = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_replace_node tree' key value
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeReplaceNodeMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeReplaceNodeMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> Ptr () -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m (Maybe TreeNode)
treeReplaceNode
instance O.OverloadedMethodInfo TreeReplaceNodeMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeReplaceNode",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeReplaceNode"
})
#endif
foreign import ccall "g_tree_search" g_tree_search ::
Ptr Tree ->
FunPtr GLib.Callbacks.C_CompareFunc ->
Ptr () ->
IO (Ptr ())
treeSearch ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> GLib.Callbacks.CompareFunc
-> m (Ptr ())
treeSearch :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> CompareDataFunc -> m (Ptr ())
treeSearch Tree
tree CompareDataFunc
searchFunc = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
searchFunc' <- GLib.Callbacks.mk_CompareFunc (GLib.Callbacks.wrap_CompareFunc Nothing searchFunc)
let userData = Ptr a
forall a. Ptr a
nullPtr
result <- g_tree_search tree' searchFunc' userData
safeFreeFunPtr $ castFunPtrToPtr searchFunc'
touchManagedPtr tree
return result
#if defined(ENABLE_OVERLOADING)
data TreeSearchMethodInfo
instance (signature ~ (GLib.Callbacks.CompareFunc -> m (Ptr ())), MonadIO m) => O.OverloadedMethod TreeSearchMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> CompareDataFunc -> m (Ptr ())
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> CompareDataFunc -> m (Ptr ())
treeSearch
instance O.OverloadedMethodInfo TreeSearchMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeSearch",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeSearch"
})
#endif
foreign import ccall "g_tree_search_node" g_tree_search_node ::
Ptr Tree ->
FunPtr GLib.Callbacks.C_CompareFunc ->
Ptr () ->
IO (Ptr GLib.TreeNode.TreeNode)
treeSearchNode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> GLib.Callbacks.CompareFunc
-> m (Maybe GLib.TreeNode.TreeNode)
treeSearchNode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> CompareDataFunc -> m (Maybe TreeNode)
treeSearchNode Tree
tree CompareDataFunc
searchFunc = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
searchFunc' <- GLib.Callbacks.mk_CompareFunc (GLib.Callbacks.wrap_CompareFunc Nothing searchFunc)
let userData = Ptr a
forall a. Ptr a
nullPtr
result <- g_tree_search_node tree' searchFunc' userData
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
safeFreeFunPtr $ castFunPtrToPtr searchFunc'
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeSearchNodeMethodInfo
instance (signature ~ (GLib.Callbacks.CompareFunc -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeSearchNodeMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> CompareDataFunc -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> CompareDataFunc -> m (Maybe TreeNode)
treeSearchNode
instance O.OverloadedMethodInfo TreeSearchNodeMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeSearchNode",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeSearchNode"
})
#endif
foreign import ccall "g_tree_steal" g_tree_steal ::
Ptr Tree ->
Ptr () ->
IO CInt
treeSteal ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> m Bool
treeSteal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m Bool
treeSteal Tree
tree Ptr ()
key = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_steal tree' key
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr tree
return result'
#if defined(ENABLE_OVERLOADING)
data TreeStealMethodInfo
instance (signature ~ (Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod TreeStealMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m Bool
treeSteal
instance O.OverloadedMethodInfo TreeStealMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeSteal",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeSteal"
})
#endif
foreign import ccall "g_tree_traverse" g_tree_traverse ::
Ptr Tree ->
FunPtr GLib.Callbacks.C_TraverseFunc ->
CUInt ->
Ptr () ->
IO ()
{-# DEPRECATED treeTraverse ["(Since version 2.2)","The order of a balanced tree is somewhat arbitrary."," If you just want to visit all nodes in sorted order, use"," 'GI.GLib.Structs.Tree.treeForeach' instead. If you really need to visit nodes in"," a different order, consider using an <http://developer.gnome.org/glib/stable/data-structures.html#n-ary-trees n-ary tree>."] #-}
treeTraverse ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> GLib.Callbacks.TraverseFunc
-> GLib.Enums.TraverseType
-> m ()
treeTraverse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> TraverseFunc -> TraverseType -> m ()
treeTraverse Tree
tree TraverseFunc
traverseFunc TraverseType
traverseType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
traverseFunc' <- GLib.Callbacks.mk_TraverseFunc (GLib.Callbacks.wrap_TraverseFunc Nothing traverseFunc)
let traverseType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TraverseType -> Int) -> TraverseType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TraverseType -> Int
forall a. Enum a => a -> Int
fromEnum) TraverseType
traverseType
let userData = Ptr a
forall a. Ptr a
nullPtr
g_tree_traverse tree' traverseFunc' traverseType' userData
safeFreeFunPtr $ castFunPtrToPtr traverseFunc'
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeTraverseMethodInfo
instance (signature ~ (GLib.Callbacks.TraverseFunc -> GLib.Enums.TraverseType -> m ()), MonadIO m) => O.OverloadedMethod TreeTraverseMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> TraverseFunc -> TraverseType -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> TraverseFunc -> TraverseType -> m ()
treeTraverse
instance O.OverloadedMethodInfo TreeTraverseMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeTraverse",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeTraverse"
})
#endif
foreign import ccall "g_tree_unref" g_tree_unref ::
Ptr Tree ->
IO ()
treeUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> m ()
treeUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m ()
treeUnref Tree
tree = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
g_tree_unref tree'
touchManagedPtr tree
return ()
#if defined(ENABLE_OVERLOADING)
data TreeUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TreeUnrefMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> m ()
forall (m :: * -> *). (HasCallStack, MonadIO m) => Tree -> m ()
treeUnref
instance O.OverloadedMethodInfo TreeUnrefMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeUnref",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeUnref"
})
#endif
foreign import ccall "g_tree_upper_bound" g_tree_upper_bound ::
Ptr Tree ->
Ptr () ->
IO (Ptr GLib.TreeNode.TreeNode)
treeUpperBound ::
(B.CallStack.HasCallStack, MonadIO m) =>
Tree
-> Ptr ()
-> m (Maybe GLib.TreeNode.TreeNode)
treeUpperBound :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Maybe TreeNode)
treeUpperBound Tree
tree Ptr ()
key = IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeNode) -> m (Maybe TreeNode))
-> IO (Maybe TreeNode) -> m (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ do
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
result <- g_tree_upper_bound tree' key
maybeResult <- convertIfNonNull result $ \Ptr TreeNode
result' -> do
result'' <- ((ManagedPtr TreeNode -> TreeNode) -> Ptr TreeNode -> IO TreeNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TreeNode -> TreeNode
GLib.TreeNode.TreeNode) Ptr TreeNode
result'
return result''
touchManagedPtr tree
return maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeUpperBoundMethodInfo
instance (signature ~ (Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeUpperBoundMethodInfo Tree signature where
overloadedMethod :: Tree -> signature
overloadedMethod = Tree -> signature
Tree -> Ptr () -> m (Maybe TreeNode)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> m (Maybe TreeNode)
treeUpperBound
instance O.OverloadedMethodInfo TreeUpperBoundMethodInfo Tree where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.Tree.treeUpperBound",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-Tree.html#v:treeUpperBound"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTreeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTreeMethod "destroy" o = TreeDestroyMethodInfo
ResolveTreeMethod "foreach" o = TreeForeachMethodInfo
ResolveTreeMethod "foreachNode" o = TreeForeachNodeMethodInfo
ResolveTreeMethod "height" o = TreeHeightMethodInfo
ResolveTreeMethod "insert" o = TreeInsertMethodInfo
ResolveTreeMethod "insertNode" o = TreeInsertNodeMethodInfo
ResolveTreeMethod "lookup" o = TreeLookupMethodInfo
ResolveTreeMethod "lookupExtended" o = TreeLookupExtendedMethodInfo
ResolveTreeMethod "lookupNode" o = TreeLookupNodeMethodInfo
ResolveTreeMethod "lowerBound" o = TreeLowerBoundMethodInfo
ResolveTreeMethod "nnodes" o = TreeNnodesMethodInfo
ResolveTreeMethod "nodeFirst" o = TreeNodeFirstMethodInfo
ResolveTreeMethod "nodeLast" o = TreeNodeLastMethodInfo
ResolveTreeMethod "ref" o = TreeRefMethodInfo
ResolveTreeMethod "remove" o = TreeRemoveMethodInfo
ResolveTreeMethod "removeAll" o = TreeRemoveAllMethodInfo
ResolveTreeMethod "replace" o = TreeReplaceMethodInfo
ResolveTreeMethod "replaceNode" o = TreeReplaceNodeMethodInfo
ResolveTreeMethod "search" o = TreeSearchMethodInfo
ResolveTreeMethod "searchNode" o = TreeSearchNodeMethodInfo
ResolveTreeMethod "steal" o = TreeStealMethodInfo
ResolveTreeMethod "traverse" o = TreeTraverseMethodInfo
ResolveTreeMethod "unref" o = TreeUnrefMethodInfo
ResolveTreeMethod "upperBound" o = TreeUpperBoundMethodInfo
ResolveTreeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTreeMethod t Tree, O.OverloadedMethod info Tree p) => OL.IsLabel t (Tree -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: Tree -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTreeMethod t Tree, O.OverloadedMethod info Tree p, R.HasField t Tree p) => R.HasField t Tree p where
getField :: Tree -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#endif
instance (info ~ ResolveTreeMethod t Tree, O.OverloadedMethodInfo info Tree) => OL.IsLabel t (O.MethodProxy info Tree) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: MethodProxy info Tree
fromLabel = MethodProxy info Tree
forall info obj. MethodProxy info obj
O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif