Node.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

The 'GI.GLib.Structs.Node.Node' struct represents one node in a [n-ary tree][glib-N-ary-Trees].
-}

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

module GI.GLib.Structs.Node
    ( 

-- * Exported types
    Node(..)                                ,
    newZeroNode                             ,
    noNode                                  ,


 -- * Methods
-- ** childIndex #method:childIndex#

#if ENABLE_OVERLOADING
    NodeChildIndexMethodInfo                ,
#endif
    nodeChildIndex                          ,


-- ** childPosition #method:childPosition#

#if ENABLE_OVERLOADING
    NodeChildPositionMethodInfo             ,
#endif
    nodeChildPosition                       ,


-- ** depth #method:depth#

#if ENABLE_OVERLOADING
    NodeDepthMethodInfo                     ,
#endif
    nodeDepth                               ,


-- ** destroy #method:destroy#

#if ENABLE_OVERLOADING
    NodeDestroyMethodInfo                   ,
#endif
    nodeDestroy                             ,


-- ** isAncestor #method:isAncestor#

#if ENABLE_OVERLOADING
    NodeIsAncestorMethodInfo                ,
#endif
    nodeIsAncestor                          ,


-- ** maxHeight #method:maxHeight#

#if ENABLE_OVERLOADING
    NodeMaxHeightMethodInfo                 ,
#endif
    nodeMaxHeight                           ,


-- ** nChildren #method:nChildren#

#if ENABLE_OVERLOADING
    NodeNChildrenMethodInfo                 ,
#endif
    nodeNChildren                           ,


-- ** nNodes #method:nNodes#

#if ENABLE_OVERLOADING
    NodeNNodesMethodInfo                    ,
#endif
    nodeNNodes                              ,


-- ** reverseChildren #method:reverseChildren#

#if ENABLE_OVERLOADING
    NodeReverseChildrenMethodInfo           ,
#endif
    nodeReverseChildren                     ,


-- ** unlink #method:unlink#

#if ENABLE_OVERLOADING
    NodeUnlinkMethodInfo                    ,
#endif
    nodeUnlink                              ,




 -- * Properties
-- ** children #attr:children#
{- | points to the first child of the 'GI.GLib.Structs.Node.Node'.  The other
           children are accessed by using the /@next@/ pointer of each
           child.
-}
    clearNodeChildren                       ,
    getNodeChildren                         ,
#if ENABLE_OVERLOADING
    node_children                           ,
#endif
    setNodeChildren                         ,


-- ** data #attr:data#
{- | contains the actual data of the node.
-}
    clearNodeData                           ,
    getNodeData                             ,
#if ENABLE_OVERLOADING
    node_data                               ,
#endif
    setNodeData                             ,


-- ** next #attr:next#
{- | points to the node\'s next sibling (a sibling is another
       'GI.GLib.Structs.Node.Node' with the same parent).
-}
    clearNodeNext                           ,
    getNodeNext                             ,
#if ENABLE_OVERLOADING
    node_next                               ,
#endif
    setNodeNext                             ,


-- ** parent #attr:parent#
{- | points to the parent of the 'GI.GLib.Structs.Node.Node', or is 'Nothing' if the
         'GI.GLib.Structs.Node.Node' is the root of the tree.
-}
    clearNodeParent                         ,
    getNodeParent                           ,
#if ENABLE_OVERLOADING
    node_parent                             ,
#endif
    setNodeParent                           ,


-- ** prev #attr:prev#
{- | points to the node\'s previous sibling.
-}
    clearNodePrev                           ,
    getNodePrev                             ,
#if ENABLE_OVERLOADING
    node_prev                               ,
#endif
    setNodePrev                             ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.GLib.Flags as GLib.Flags

-- | Memory-managed wrapper type.
newtype Node = Node (ManagedPtr Node)
instance WrappedPtr Node where
    wrappedPtrCalloc = callocBytes 40
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 40 >=> wrapPtr Node)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `Node` struct initialized to zero.
newZeroNode :: MonadIO m => m Node
newZeroNode = liftIO $ wrappedPtrCalloc >>= wrapPtr Node

instance tag ~ 'AttrSet => Constructible Node tag where
    new _ attrs = do
        o <- newZeroNode
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `Node`.
noNode :: Maybe Node
noNode = Nothing

{- |
Get the value of the “@data@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' node #data
@
-}
getNodeData :: MonadIO m => Node -> m (Ptr ())
getNodeData s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
    return val

{- |
Set the value of the “@data@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' node [ #data 'Data.GI.Base.Attributes.:=' value ]
@
-}
setNodeData :: MonadIO m => Node -> Ptr () -> m ()
setNodeData s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Ptr ())

{- |
Set the value of the “@data@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #data
@
-}
clearNodeData :: MonadIO m => Node -> m ()
clearNodeData s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())

#if ENABLE_OVERLOADING
data NodeDataFieldInfo
instance AttrInfo NodeDataFieldInfo where
    type AttrAllowedOps NodeDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeDataFieldInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint NodeDataFieldInfo = (~) Node
    type AttrGetType NodeDataFieldInfo = Ptr ()
    type AttrLabel NodeDataFieldInfo = "data"
    type AttrOrigin NodeDataFieldInfo = Node
    attrGet _ = getNodeData
    attrSet _ = setNodeData
    attrConstruct = undefined
    attrClear _ = clearNodeData

node_data :: AttrLabelProxy "data"
node_data = AttrLabelProxy

#endif


{- |
Get the value of the “@next@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' node #next
@
-}
getNodeNext :: MonadIO m => Node -> m (Maybe Node)
getNodeNext s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Node)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr Node) val'
        return val''
    return result

{- |
Set the value of the “@next@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' node [ #next 'Data.GI.Base.Attributes.:=' value ]
@
-}
setNodeNext :: MonadIO m => Node -> Ptr Node -> m ()
setNodeNext s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Ptr Node)

{- |
Set the value of the “@next@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #next
@
-}
clearNodeNext :: MonadIO m => Node -> m ()
clearNodeNext s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Node)

#if ENABLE_OVERLOADING
data NodeNextFieldInfo
instance AttrInfo NodeNextFieldInfo where
    type AttrAllowedOps NodeNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeNextFieldInfo = (~) (Ptr Node)
    type AttrBaseTypeConstraint NodeNextFieldInfo = (~) Node
    type AttrGetType NodeNextFieldInfo = Maybe Node
    type AttrLabel NodeNextFieldInfo = "next"
    type AttrOrigin NodeNextFieldInfo = Node
    attrGet _ = getNodeNext
    attrSet _ = setNodeNext
    attrConstruct = undefined
    attrClear _ = clearNodeNext

node_next :: AttrLabelProxy "next"
node_next = AttrLabelProxy

#endif


{- |
Get the value of the “@prev@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' node #prev
@
-}
getNodePrev :: MonadIO m => Node -> m (Maybe Node)
getNodePrev s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Node)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr Node) val'
        return val''
    return result

{- |
Set the value of the “@prev@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' node [ #prev 'Data.GI.Base.Attributes.:=' value ]
@
-}
setNodePrev :: MonadIO m => Node -> Ptr Node -> m ()
setNodePrev s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Ptr Node)

{- |
Set the value of the “@prev@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #prev
@
-}
clearNodePrev :: MonadIO m => Node -> m ()
clearNodePrev s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Node)

#if ENABLE_OVERLOADING
data NodePrevFieldInfo
instance AttrInfo NodePrevFieldInfo where
    type AttrAllowedOps NodePrevFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodePrevFieldInfo = (~) (Ptr Node)
    type AttrBaseTypeConstraint NodePrevFieldInfo = (~) Node
    type AttrGetType NodePrevFieldInfo = Maybe Node
    type AttrLabel NodePrevFieldInfo = "prev"
    type AttrOrigin NodePrevFieldInfo = Node
    attrGet _ = getNodePrev
    attrSet _ = setNodePrev
    attrConstruct = undefined
    attrClear _ = clearNodePrev

node_prev :: AttrLabelProxy "prev"
node_prev = AttrLabelProxy

#endif


{- |
Get the value of the “@parent@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' node #parent
@
-}
getNodeParent :: MonadIO m => Node -> m (Maybe Node)
getNodeParent s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO (Ptr Node)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr Node) val'
        return val''
    return result

{- |
Set the value of the “@parent@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' node [ #parent 'Data.GI.Base.Attributes.:=' value ]
@
-}
setNodeParent :: MonadIO m => Node -> Ptr Node -> m ()
setNodeParent s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Ptr Node)

{- |
Set the value of the “@parent@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #parent
@
-}
clearNodeParent :: MonadIO m => Node -> m ()
clearNodeParent s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr Node)

#if ENABLE_OVERLOADING
data NodeParentFieldInfo
instance AttrInfo NodeParentFieldInfo where
    type AttrAllowedOps NodeParentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeParentFieldInfo = (~) (Ptr Node)
    type AttrBaseTypeConstraint NodeParentFieldInfo = (~) Node
    type AttrGetType NodeParentFieldInfo = Maybe Node
    type AttrLabel NodeParentFieldInfo = "parent"
    type AttrOrigin NodeParentFieldInfo = Node
    attrGet _ = getNodeParent
    attrSet _ = setNodeParent
    attrConstruct = undefined
    attrClear _ = clearNodeParent

node_parent :: AttrLabelProxy "parent"
node_parent = AttrLabelProxy

#endif


{- |
Get the value of the “@children@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' node #children
@
-}
getNodeChildren :: MonadIO m => Node -> m (Maybe Node)
getNodeChildren s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO (Ptr Node)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr Node) val'
        return val''
    return result

{- |
Set the value of the “@children@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' node [ #children 'Data.GI.Base.Attributes.:=' value ]
@
-}
setNodeChildren :: MonadIO m => Node -> Ptr Node -> m ()
setNodeChildren s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Ptr Node)

{- |
Set the value of the “@children@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #children
@
-}
clearNodeChildren :: MonadIO m => Node -> m ()
clearNodeChildren s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Node)

#if ENABLE_OVERLOADING
data NodeChildrenFieldInfo
instance AttrInfo NodeChildrenFieldInfo where
    type AttrAllowedOps NodeChildrenFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeChildrenFieldInfo = (~) (Ptr Node)
    type AttrBaseTypeConstraint NodeChildrenFieldInfo = (~) Node
    type AttrGetType NodeChildrenFieldInfo = Maybe Node
    type AttrLabel NodeChildrenFieldInfo = "children"
    type AttrOrigin NodeChildrenFieldInfo = Node
    attrGet _ = getNodeChildren
    attrSet _ = setNodeChildren
    attrConstruct = undefined
    attrClear _ = clearNodeChildren

node_children :: AttrLabelProxy "children"
node_children = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList Node
type instance O.AttributeList Node = NodeAttributeList
type NodeAttributeList = ('[ '("data", NodeDataFieldInfo), '("next", NodeNextFieldInfo), '("prev", NodePrevFieldInfo), '("parent", NodeParentFieldInfo), '("children", NodeChildrenFieldInfo)] :: [(Symbol, *)])
#endif

-- method Node::child_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "node", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to find", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_child_index" g_node_child_index :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO Int32

{- |
Gets the position of the first child of a 'GI.GLib.Structs.Node.Node'
which contains the given data.
-}
nodeChildIndex ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@node@/: a 'GI.GLib.Structs.Node.Node' -}
    -> Ptr ()
    {- ^ /@data@/: the data to find -}
    -> m Int32
    {- ^ __Returns:__ the index of the child of /@node@/ which contains
    /@data@/, or -1 if the data is not found -}
nodeChildIndex node data_ = liftIO $ do
    node' <- unsafeManagedPtrGetPtr node
    result <- g_node_child_index node' data_
    touchManagedPtr node
    return result

#if ENABLE_OVERLOADING
data NodeChildIndexMethodInfo
instance (signature ~ (Ptr () -> m Int32), MonadIO m) => O.MethodInfo NodeChildIndexMethodInfo Node signature where
    overloadedMethod _ = nodeChildIndex

#endif

-- method Node::child_position
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "node", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a child of @node", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_child_position" g_node_child_position :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    Ptr Node ->                             -- child : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Int32

{- |
Gets the position of a 'GI.GLib.Structs.Node.Node' with respect to its siblings.
/@child@/ must be a child of /@node@/. The first child is numbered 0,
the second 1, and so on.
-}
nodeChildPosition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@node@/: a 'GI.GLib.Structs.Node.Node' -}
    -> Node
    {- ^ /@child@/: a child of /@node@/ -}
    -> m Int32
    {- ^ __Returns:__ the position of /@child@/ with respect to its siblings -}
nodeChildPosition node child = liftIO $ do
    node' <- unsafeManagedPtrGetPtr node
    child' <- unsafeManagedPtrGetPtr child
    result <- g_node_child_position node' child'
    touchManagedPtr node
    touchManagedPtr child
    return result

#if ENABLE_OVERLOADING
data NodeChildPositionMethodInfo
instance (signature ~ (Node -> m Int32), MonadIO m) => O.MethodInfo NodeChildPositionMethodInfo Node signature where
    overloadedMethod _ = nodeChildPosition

#endif

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

foreign import ccall "g_node_depth" g_node_depth :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Word32

{- |
Gets the depth of a 'GI.GLib.Structs.Node.Node'.

If /@node@/ is 'Nothing' the depth is 0. The root node has a depth of 1.
For the children of the root node the depth is 2. And so on.
-}
nodeDepth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@node@/: a 'GI.GLib.Structs.Node.Node' -}
    -> m Word32
    {- ^ __Returns:__ the depth of the 'GI.GLib.Structs.Node.Node' -}
nodeDepth node = liftIO $ do
    node' <- unsafeManagedPtrGetPtr node
    result <- g_node_depth node'
    touchManagedPtr node
    return result

#if ENABLE_OVERLOADING
data NodeDepthMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NodeDepthMethodInfo Node signature where
    overloadedMethod _ = nodeDepth

#endif

-- method Node::destroy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "root", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the root of the tree/subtree to destroy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_node_destroy" g_node_destroy :: 
    Ptr Node ->                             -- root : TInterface (Name {namespace = "GLib", name = "Node"})
    IO ()

{- |
Removes /@root@/ and its children from the tree, freeing any memory
allocated.
-}
nodeDestroy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@root@/: the root of the tree\/subtree to destroy -}
    -> m ()
nodeDestroy root = liftIO $ do
    root' <- unsafeManagedPtrGetPtr root
    g_node_destroy root'
    touchManagedPtr root
    return ()

#if ENABLE_OVERLOADING
data NodeDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NodeDestroyMethodInfo Node signature where
    overloadedMethod _ = nodeDestroy

#endif

-- method Node::is_ancestor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "node", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "descendant", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_is_ancestor" g_node_is_ancestor :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    Ptr Node ->                             -- descendant : TInterface (Name {namespace = "GLib", name = "Node"})
    IO CInt

{- |
Returns 'True' if /@node@/ is an ancestor of /@descendant@/.
This is true if node is the parent of /@descendant@/,
or if node is the grandparent of /@descendant@/ etc.
-}
nodeIsAncestor ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@node@/: a 'GI.GLib.Structs.Node.Node' -}
    -> Node
    {- ^ /@descendant@/: a 'GI.GLib.Structs.Node.Node' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@node@/ is an ancestor of /@descendant@/ -}
nodeIsAncestor node descendant = liftIO $ do
    node' <- unsafeManagedPtrGetPtr node
    descendant' <- unsafeManagedPtrGetPtr descendant
    result <- g_node_is_ancestor node' descendant'
    let result' = (/= 0) result
    touchManagedPtr node
    touchManagedPtr descendant
    return result'

#if ENABLE_OVERLOADING
data NodeIsAncestorMethodInfo
instance (signature ~ (Node -> m Bool), MonadIO m) => O.MethodInfo NodeIsAncestorMethodInfo Node signature where
    overloadedMethod _ = nodeIsAncestor

#endif

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

foreign import ccall "g_node_max_height" g_node_max_height :: 
    Ptr Node ->                             -- root : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Word32

{- |
Gets the maximum height of all branches beneath a 'GI.GLib.Structs.Node.Node'.
This is the maximum distance from the 'GI.GLib.Structs.Node.Node' to all leaf nodes.

If /@root@/ is 'Nothing', 0 is returned. If /@root@/ has no children,
1 is returned. If /@root@/ has children, 2 is returned. And so on.
-}
nodeMaxHeight ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@root@/: a 'GI.GLib.Structs.Node.Node' -}
    -> m Word32
    {- ^ __Returns:__ the maximum height of the tree beneath /@root@/ -}
nodeMaxHeight root = liftIO $ do
    root' <- unsafeManagedPtrGetPtr root
    result <- g_node_max_height root'
    touchManagedPtr root
    return result

#if ENABLE_OVERLOADING
data NodeMaxHeightMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NodeMaxHeightMethodInfo Node signature where
    overloadedMethod _ = nodeMaxHeight

#endif

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

foreign import ccall "g_node_n_children" g_node_n_children :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Word32

{- |
Gets the number of children of a 'GI.GLib.Structs.Node.Node'.
-}
nodeNChildren ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@node@/: a 'GI.GLib.Structs.Node.Node' -}
    -> m Word32
    {- ^ __Returns:__ the number of children of /@node@/ -}
nodeNChildren node = liftIO $ do
    node' <- unsafeManagedPtrGetPtr node
    result <- g_node_n_children node'
    touchManagedPtr node
    return result

#if ENABLE_OVERLOADING
data NodeNChildrenMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NodeNChildrenMethodInfo Node signature where
    overloadedMethod _ = nodeNChildren

#endif

-- method Node::n_nodes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "root", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GLib", name = "TraverseFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "which types of children are to be counted, one of\n    %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_n_nodes" g_node_n_nodes :: 
    Ptr Node ->                             -- root : TInterface (Name {namespace = "GLib", name = "Node"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "GLib", name = "TraverseFlags"})
    IO Word32

{- |
Gets the number of nodes in a tree.
-}
nodeNNodes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@root@/: a 'GI.GLib.Structs.Node.Node' -}
    -> [GLib.Flags.TraverseFlags]
    {- ^ /@flags@/: which types of children are to be counted, one of
    'GI.GLib.Flags.TraverseFlagsAll', 'GI.GLib.Flags.TraverseFlagsLeaves' and 'GI.GLib.Flags.TraverseFlagsNonLeaves' -}
    -> m Word32
    {- ^ __Returns:__ the number of nodes in the tree -}
nodeNNodes root flags = liftIO $ do
    root' <- unsafeManagedPtrGetPtr root
    let flags' = gflagsToWord flags
    result <- g_node_n_nodes root' flags'
    touchManagedPtr root
    return result

#if ENABLE_OVERLOADING
data NodeNNodesMethodInfo
instance (signature ~ ([GLib.Flags.TraverseFlags] -> m Word32), MonadIO m) => O.MethodInfo NodeNNodesMethodInfo Node signature where
    overloadedMethod _ = nodeNNodes

#endif

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

foreign import ccall "g_node_reverse_children" g_node_reverse_children :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO ()

{- |
Reverses the order of the children of a 'GI.GLib.Structs.Node.Node'.
(It doesn\'t change the order of the grandchildren.)
-}
nodeReverseChildren ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@node@/: a 'GI.GLib.Structs.Node.Node'. -}
    -> m ()
nodeReverseChildren node = liftIO $ do
    node' <- unsafeManagedPtrGetPtr node
    g_node_reverse_children node'
    touchManagedPtr node
    return ()

#if ENABLE_OVERLOADING
data NodeReverseChildrenMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NodeReverseChildrenMethodInfo Node signature where
    overloadedMethod _ = nodeReverseChildren

#endif

-- method Node::unlink
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "node", argType = TInterface (Name {namespace = "GLib", name = "Node"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GNode to unlink, which becomes the root of a new tree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_node_unlink" g_node_unlink :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO ()

{- |
Unlinks a 'GI.GLib.Structs.Node.Node' from a tree, resulting in two separate trees.
-}
nodeUnlink ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    {- ^ /@node@/: the 'GI.GLib.Structs.Node.Node' to unlink, which becomes the root of a new tree -}
    -> m ()
nodeUnlink node = liftIO $ do
    node' <- unsafeManagedPtrGetPtr node
    g_node_unlink node'
    touchManagedPtr node
    return ()

#if ENABLE_OVERLOADING
data NodeUnlinkMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NodeUnlinkMethodInfo Node signature where
    overloadedMethod _ = nodeUnlink

#endif

#if ENABLE_OVERLOADING
type family ResolveNodeMethod (t :: Symbol) (o :: *) :: * where
    ResolveNodeMethod "childIndex" o = NodeChildIndexMethodInfo
    ResolveNodeMethod "childPosition" o = NodeChildPositionMethodInfo
    ResolveNodeMethod "depth" o = NodeDepthMethodInfo
    ResolveNodeMethod "destroy" o = NodeDestroyMethodInfo
    ResolveNodeMethod "isAncestor" o = NodeIsAncestorMethodInfo
    ResolveNodeMethod "maxHeight" o = NodeMaxHeightMethodInfo
    ResolveNodeMethod "nChildren" o = NodeNChildrenMethodInfo
    ResolveNodeMethod "nNodes" o = NodeNNodesMethodInfo
    ResolveNodeMethod "reverseChildren" o = NodeReverseChildrenMethodInfo
    ResolveNodeMethod "unlink" o = NodeUnlinkMethodInfo
    ResolveNodeMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveNodeMethod t Node, O.MethodInfo info Node p) => OL.IsLabel t (Node -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif