{-# 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)
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)
TreeStealMethodInfo ,
#endif
treeSteal ,
#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.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 GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.TreeNode as GLib.TreeNode
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 Tree
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 Tree
ptr Ptr Tree -> Ptr Tree -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Tree
forall a. Ptr a
FP.nullPtr
then Tree -> Maybe Tree
forall a. a -> Maybe a
P.Just (Tree -> Maybe Tree) -> IO Tree -> IO (Maybe Tree)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Tree -> Tree) -> Ptr Tree -> IO Tree
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Tree -> Tree
Tree Ptr Tree
ptr
else Maybe Tree -> IO (Maybe Tree)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Tree
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Tree
type instance O.AttributeList Tree = TreeAttributeList
type TreeAttributeList = ('[ ] :: [(Symbol, *)])
#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
FunPtr C_CompareDataFunc
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))
Ptr (FunPtr DestroyNotify)
ptrkeyDestroyFunc <- IO (Ptr (FunPtr DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
keyDestroyFunc' <- DestroyNotify -> IO (FunPtr DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr DestroyNotify))
-> DestroyNotify -> DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr DestroyNotify) -> Maybe (Ptr (FunPtr DestroyNotify))
forall a. a -> Maybe a
Just Ptr (FunPtr DestroyNotify)
ptrkeyDestroyFunc) DestroyNotify
keyDestroyFunc)
Ptr (FunPtr DestroyNotify) -> FunPtr DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrkeyDestroyFunc FunPtr DestroyNotify
keyDestroyFunc'
let keyCompareData :: Ptr ()
keyCompareData = FunPtr C_CompareDataFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
keyCompareFunc'
let valueDestroyFunc :: FunPtr (Ptr a -> IO ())
valueDestroyFunc = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Tree
result <- FunPtr C_CompareDataFunc
-> Ptr ()
-> FunPtr DestroyNotify
-> FunPtr DestroyNotify
-> IO (Ptr Tree)
g_tree_new_full FunPtr C_CompareDataFunc
keyCompareFunc' Ptr ()
keyCompareData FunPtr DestroyNotify
keyDestroyFunc' FunPtr DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
valueDestroyFunc
Text -> Ptr Tree -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeNewFull" Ptr Tree
result
Tree
result' <- ((ManagedPtr Tree -> Tree) -> Ptr Tree -> IO Tree
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Tree -> Tree
Tree) Ptr Tree
result
Tree -> IO Tree
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Tree
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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr Tree -> IO ()
g_tree_destroy Ptr Tree
tree'
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TreeDestroyMethodInfo Tree signature where
overloadedMethod = treeDestroy
instance O.OverloadedMethodInfo TreeDestroyMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeDestroy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Tree.html#v:treeDestroy"
})
#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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Int32
result <- Ptr Tree -> IO Int32
g_tree_height Ptr Tree
tree'
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TreeHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod TreeHeightMethodInfo Tree signature where
overloadedMethod = treeHeight
instance O.OverloadedMethodInfo TreeHeightMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeHeight",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr Tree -> Ptr () -> DestroyNotify
g_tree_insert Ptr Tree
tree' Ptr ()
key Ptr ()
value
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeInsertMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m ()), MonadIO m) => O.OverloadedMethod TreeInsertMethodInfo Tree signature where
overloadedMethod = treeInsert
instance O.OverloadedMethodInfo TreeInsertMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeInsert",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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 GLib.TreeNode.TreeNode
treeInsertNode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m TreeNode
treeInsertNode Tree
tree Ptr ()
key Ptr ()
value = IO TreeNode -> m TreeNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeNode -> m TreeNode) -> IO TreeNode -> m TreeNode
forall a b. (a -> b) -> a -> b
$ do
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr TreeNode
result <- Ptr Tree -> Ptr () -> Ptr () -> IO (Ptr TreeNode)
g_tree_insert_node Ptr Tree
tree' Ptr ()
key Ptr ()
value
Text -> Ptr TreeNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeInsertNode" Ptr TreeNode
result
TreeNode
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
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result'
#if defined(ENABLE_OVERLOADING)
data TreeInsertNodeMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m GLib.TreeNode.TreeNode), MonadIO m) => O.OverloadedMethod TreeInsertNodeMethodInfo Tree signature where
overloadedMethod = treeInsertNode
instance O.OverloadedMethodInfo TreeInsertNodeMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeInsertNode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr ()
result <- Ptr Tree -> Ptr () -> IO (Ptr ())
g_tree_lookup Ptr Tree
tree' Ptr ()
key
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data TreeLookupMethodInfo
instance (signature ~ (Ptr () -> m (Ptr ())), MonadIO m) => O.OverloadedMethod TreeLookupMethodInfo Tree signature where
overloadedMethod = treeLookup
instance O.OverloadedMethodInfo TreeLookupMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeLookup",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr (Ptr ())
origKey <- IO (Ptr (Ptr ()))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr ()))
Ptr (Ptr ())
value <- IO (Ptr (Ptr ()))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr ()))
CInt
result <- Ptr Tree -> Ptr () -> Ptr (Ptr ()) -> Ptr (Ptr ()) -> IO CInt
g_tree_lookup_extended Ptr Tree
tree' Ptr ()
lookupKey Ptr (Ptr ())
origKey Ptr (Ptr ())
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr ()
origKey' <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
origKey
Ptr ()
value' <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
value
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Ptr (Ptr ()) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
origKey
Ptr (Ptr ()) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
value
(Bool, Ptr (), Ptr ()) -> IO (Bool, Ptr (), Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Ptr ()
origKey', Ptr ()
value')
#if defined(ENABLE_OVERLOADING)
data TreeLookupExtendedMethodInfo
instance (signature ~ (Ptr () -> m ((Bool, Ptr (), Ptr ()))), MonadIO m) => O.OverloadedMethod TreeLookupExtendedMethodInfo Tree signature where
overloadedMethod = treeLookupExtended
instance O.OverloadedMethodInfo TreeLookupExtendedMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeLookupExtended",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr TreeNode
result <- Ptr Tree -> Ptr () -> IO (Ptr TreeNode)
g_tree_lookup_node Ptr Tree
tree' Ptr ()
key
Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
TreeNode
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'
TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeLookupNodeMethodInfo
instance (signature ~ (Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeLookupNodeMethodInfo Tree signature where
overloadedMethod = treeLookupNode
instance O.OverloadedMethodInfo TreeLookupNodeMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeLookupNode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr TreeNode
result <- Ptr Tree -> Ptr () -> IO (Ptr TreeNode)
g_tree_lower_bound Ptr Tree
tree' Ptr ()
key
Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
TreeNode
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'
TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeLowerBoundMethodInfo
instance (signature ~ (Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeLowerBoundMethodInfo Tree signature where
overloadedMethod = treeLowerBound
instance O.OverloadedMethodInfo TreeLowerBoundMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeLowerBound",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Int32
result <- Ptr Tree -> IO Int32
g_tree_nnodes Ptr Tree
tree'
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TreeNnodesMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod TreeNnodesMethodInfo Tree signature where
overloadedMethod = treeNnodes
instance O.OverloadedMethodInfo TreeNnodesMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeNnodes",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr TreeNode
result <- Ptr Tree -> IO (Ptr TreeNode)
g_tree_node_first Ptr Tree
tree'
Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
TreeNode
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'
TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeNodeFirstMethodInfo
instance (signature ~ (m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeNodeFirstMethodInfo Tree signature where
overloadedMethod = treeNodeFirst
instance O.OverloadedMethodInfo TreeNodeFirstMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeNodeFirst",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr TreeNode
result <- Ptr Tree -> IO (Ptr TreeNode)
g_tree_node_last Ptr Tree
tree'
Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
TreeNode
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'
TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeNodeLastMethodInfo
instance (signature ~ (m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeNodeLastMethodInfo Tree signature where
overloadedMethod = treeNodeLast
instance O.OverloadedMethodInfo TreeNodeLastMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeNodeLast",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr Tree
result <- Ptr Tree -> IO (Ptr Tree)
g_tree_ref Ptr Tree
tree'
Text -> Ptr Tree -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeRef" Ptr Tree
result
Tree
result' <- ((ManagedPtr Tree -> Tree) -> Ptr Tree -> IO Tree
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Tree -> Tree
Tree) Ptr Tree
result
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Tree -> IO Tree
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Tree
result'
#if defined(ENABLE_OVERLOADING)
data TreeRefMethodInfo
instance (signature ~ (m Tree), MonadIO m) => O.OverloadedMethod TreeRefMethodInfo Tree signature where
overloadedMethod = treeRef
instance O.OverloadedMethodInfo TreeRefMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
CInt
result <- Ptr Tree -> Ptr () -> IO CInt
g_tree_remove Ptr Tree
tree' Ptr ()
key
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TreeRemoveMethodInfo
instance (signature ~ (Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod TreeRemoveMethodInfo Tree signature where
overloadedMethod = treeRemove
instance O.OverloadedMethodInfo TreeRemoveMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr Tree -> IO ()
g_tree_remove_all Ptr Tree
tree'
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeRemoveAllMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TreeRemoveAllMethodInfo Tree signature where
overloadedMethod = treeRemoveAll
instance O.OverloadedMethodInfo TreeRemoveAllMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeRemoveAll",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr Tree -> Ptr () -> DestroyNotify
g_tree_replace Ptr Tree
tree' Ptr ()
key Ptr ()
value
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeReplaceMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m ()), MonadIO m) => O.OverloadedMethod TreeReplaceMethodInfo Tree signature where
overloadedMethod = treeReplace
instance O.OverloadedMethodInfo TreeReplaceMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeReplace",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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 GLib.TreeNode.TreeNode
treeReplaceNode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Tree -> Ptr () -> Ptr () -> m TreeNode
treeReplaceNode Tree
tree Ptr ()
key Ptr ()
value = IO TreeNode -> m TreeNode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TreeNode -> m TreeNode) -> IO TreeNode -> m TreeNode
forall a b. (a -> b) -> a -> b
$ do
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr TreeNode
result <- Ptr Tree -> Ptr () -> Ptr () -> IO (Ptr TreeNode)
g_tree_replace_node Ptr Tree
tree' Ptr ()
key Ptr ()
value
Text -> Ptr TreeNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeReplaceNode" Ptr TreeNode
result
TreeNode
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
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result'
#if defined(ENABLE_OVERLOADING)
data TreeReplaceNodeMethodInfo
instance (signature ~ (Ptr () -> Ptr () -> m GLib.TreeNode.TreeNode), MonadIO m) => O.OverloadedMethod TreeReplaceNodeMethodInfo Tree signature where
overloadedMethod = treeReplaceNode
instance O.OverloadedMethodInfo TreeReplaceNodeMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeReplaceNode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Tree.html#v:treeReplaceNode"
})
#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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
CInt
result <- Ptr Tree -> Ptr () -> IO CInt
g_tree_steal Ptr Tree
tree' Ptr ()
key
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TreeStealMethodInfo
instance (signature ~ (Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod TreeStealMethodInfo Tree signature where
overloadedMethod = treeSteal
instance O.OverloadedMethodInfo TreeStealMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeSteal",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Tree.html#v:treeSteal"
})
#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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr Tree -> IO ()
g_tree_unref Ptr Tree
tree'
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TreeUnrefMethodInfo Tree signature where
overloadedMethod = treeUnref
instance O.OverloadedMethodInfo TreeUnrefMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/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
Ptr Tree
tree' <- Tree -> IO (Ptr Tree)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Tree
tree
Ptr TreeNode
result <- Ptr Tree -> Ptr () -> IO (Ptr TreeNode)
g_tree_upper_bound Ptr Tree
tree' Ptr ()
key
Maybe TreeNode
maybeResult <- Ptr TreeNode
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeNode
result ((Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode))
-> (Ptr TreeNode -> IO TreeNode) -> IO (Maybe TreeNode)
forall a b. (a -> b) -> a -> b
$ \Ptr TreeNode
result' -> do
TreeNode
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'
TreeNode -> IO TreeNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TreeNode
result''
Tree -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Tree
tree
Maybe TreeNode -> IO (Maybe TreeNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeNode
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeUpperBoundMethodInfo
instance (signature ~ (Ptr () -> m (Maybe GLib.TreeNode.TreeNode)), MonadIO m) => O.OverloadedMethod TreeUpperBoundMethodInfo Tree signature where
overloadedMethod = treeUpperBound
instance O.OverloadedMethodInfo TreeUpperBoundMethodInfo Tree where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Tree.treeUpperBound",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Tree.html#v:treeUpperBound"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTreeMethod (t :: Symbol) (o :: *) :: * where
ResolveTreeMethod "destroy" o = TreeDestroyMethodInfo
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 "steal" o = TreeStealMethodInfo
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 = 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 = 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 = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif