{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Poppler.Structs.StructureElementIter
    ( 

-- * Exported types
    StructureElementIter(..)                ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveStructureElementIterMethod       ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterCopyMethodInfo      ,
#endif
    structureElementIterCopy                ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterFreeMethodInfo      ,
#endif
    structureElementIterFree                ,


-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterGetChildMethodInfo  ,
#endif
    structureElementIterGetChild            ,


-- ** getElement #method:getElement#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterGetElementMethodInfo,
#endif
    structureElementIterGetElement          ,


-- ** new #method:new#

    structureElementIterNew                 ,


-- ** next #method:next#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterNextMethodInfo      ,
#endif
    structureElementIterNext                ,




    ) 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.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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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.Poppler.Objects.Document as Poppler.Document
import {-# SOURCE #-} qualified GI.Poppler.Objects.StructureElement as Poppler.StructureElement

-- | Memory-managed wrapper type.
newtype StructureElementIter = StructureElementIter (SP.ManagedPtr StructureElementIter)
    deriving (StructureElementIter -> StructureElementIter -> Bool
(StructureElementIter -> StructureElementIter -> Bool)
-> (StructureElementIter -> StructureElementIter -> Bool)
-> Eq StructureElementIter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureElementIter -> StructureElementIter -> Bool
$c/= :: StructureElementIter -> StructureElementIter -> Bool
== :: StructureElementIter -> StructureElementIter -> Bool
$c== :: StructureElementIter -> StructureElementIter -> Bool
Eq)

instance SP.ManagedPtrNewtype StructureElementIter where
    toManagedPtr :: StructureElementIter -> ManagedPtr StructureElementIter
toManagedPtr (StructureElementIter ManagedPtr StructureElementIter
p) = ManagedPtr StructureElementIter
p

foreign import ccall "poppler_structure_element_iter_get_type" c_poppler_structure_element_iter_get_type :: 
    IO GType

type instance O.ParentTypes StructureElementIter = '[]
instance O.HasParentTypes StructureElementIter

instance B.Types.TypedObject StructureElementIter where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_element_iter_get_type

instance B.Types.GBoxed StructureElementIter

-- | Convert 'StructureElementIter' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue StructureElementIter where
    toGValue :: StructureElementIter -> IO GValue
toGValue StructureElementIter
o = do
        GType
gtype <- IO GType
c_poppler_structure_element_iter_get_type
        StructureElementIter
-> (Ptr StructureElementIter -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StructureElementIter
o (GType
-> (GValue -> Ptr StructureElementIter -> IO ())
-> Ptr StructureElementIter
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr StructureElementIter -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO StructureElementIter
fromGValue GValue
gv = do
        Ptr StructureElementIter
ptr <- GValue -> IO (Ptr StructureElementIter)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr StructureElementIter)
        (ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter Ptr StructureElementIter
ptr
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StructureElementIter
type instance O.AttributeList StructureElementIter = StructureElementIterAttributeList
type StructureElementIterAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method StructureElementIter::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "poppler_document"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Document" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerDocument."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureElementIter" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_iter_new" poppler_structure_element_iter_new :: 
    Ptr Poppler.Document.Document ->        -- poppler_document : TInterface (Name {namespace = "Poppler", name = "Document"})
    IO (Ptr StructureElementIter)

-- | Returns the root t'GI.Poppler.Structs.StructureElementIter.StructureElementIter' for /@document@/, or 'P.Nothing'. The
-- returned value must be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'.
-- 
-- Documents may have an associated structure tree &mdashmostly, Tagged-PDF
-- compliant documents&mdash; which can be used to obtain information about
-- the document structure and its contents. Each node in the tree contains
-- a t'GI.Poppler.Objects.StructureElement.StructureElement'.
-- 
-- Here is a simple example that walks the whole tree:
-- 
-- \<informalexample>\<programlisting>
-- static void
-- walk_structure (PopplerStructureElementIter *iter)
-- {
--   do {
--     \/\<!-- -->* Get the element and do something with it *\<!-- -->\/
--     PopplerStructureElementIter *child = poppler_structure_element_iter_get_child (iter);
--     if (child)
--       walk_structure (child);
--     poppler_structure_element_iter_free (child);
--   } while (poppler_structure_element_iter_next (iter));
-- }
-- ...
-- {
--   iter = poppler_structure_element_iter_new (document);
--   walk_structure (iter);
--   poppler_structure_element_iter_free (iter);
-- }
-- \<\/programlisting>\<\/informalexample>
-- 
-- /Since: 0.26/
structureElementIterNew ::
    (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) =>
    a
    -- ^ /@popplerDocument@/: a t'GI.Poppler.Objects.Document.Document'.
    -> m StructureElementIter
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter', or 'P.Nothing' if document
    --    doesn\'t have structure tree.
structureElementIterNew :: a -> m StructureElementIter
structureElementIterNew a
popplerDocument = IO StructureElementIter -> m StructureElementIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElementIter -> m StructureElementIter)
-> IO StructureElementIter -> m StructureElementIter
forall a b. (a -> b) -> a -> b
$ do
    Ptr Document
popplerDocument' <- a -> IO (Ptr Document)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerDocument
    Ptr StructureElementIter
result <- Ptr Document -> IO (Ptr StructureElementIter)
poppler_structure_element_iter_new Ptr Document
popplerDocument'
    Text -> Ptr StructureElementIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterNew" Ptr StructureElementIter
result
    StructureElementIter
result' <- ((ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter) Ptr StructureElementIter
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerDocument
    StructureElementIter -> IO StructureElementIter
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElementIter
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "poppler_structure_element_iter_copy" poppler_structure_element_iter_copy :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO (Ptr StructureElementIter)

-- | Creates a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter' as a copy of /@iter@/. The
-- returned value must be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'.
-- 
-- /Since: 0.26/
structureElementIterCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m StructureElementIter
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
structureElementIterCopy :: StructureElementIter -> m StructureElementIter
structureElementIterCopy StructureElementIter
iter = IO StructureElementIter -> m StructureElementIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElementIter -> m StructureElementIter)
-> IO StructureElementIter -> m StructureElementIter
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    Ptr StructureElementIter
result <- Ptr StructureElementIter -> IO (Ptr StructureElementIter)
poppler_structure_element_iter_copy Ptr StructureElementIter
iter'
    Text -> Ptr StructureElementIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterCopy" Ptr StructureElementIter
result
    StructureElementIter
result' <- ((ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter) Ptr StructureElementIter
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    StructureElementIter -> IO StructureElementIter
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElementIter
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterCopyMethodInfo
instance (signature ~ (m StructureElementIter), MonadIO m) => O.MethodInfo StructureElementIterCopyMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterCopy

#endif

-- method StructureElementIter::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElementIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerStructureElementIter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_iter_free" poppler_structure_element_iter_free :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO ()

-- | Frees /@iter@/.
-- 
-- /Since: 0.26/
structureElementIterFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m ()
structureElementIterFree :: StructureElementIter -> m ()
structureElementIterFree StructureElementIter
iter = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    Ptr StructureElementIter -> IO ()
poppler_structure_element_iter_free Ptr StructureElementIter
iter'
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StructureElementIterFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureElementIterFreeMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterFree

#endif

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

foreign import ccall "poppler_structure_element_iter_get_child" poppler_structure_element_iter_get_child :: 
    Ptr StructureElementIter ->             -- parent : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO (Ptr StructureElementIter)

-- | Returns a new iterator to the children elements of the
-- t'GI.Poppler.Objects.StructureElement.StructureElement' associated with /@iter@/. The returned value must
-- be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'.
-- 
-- /Since: 0.26/
structureElementIterGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@parent@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m StructureElementIter
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
structureElementIterGetChild :: StructureElementIter -> m StructureElementIter
structureElementIterGetChild StructureElementIter
parent = IO StructureElementIter -> m StructureElementIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElementIter -> m StructureElementIter)
-> IO StructureElementIter -> m StructureElementIter
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
parent' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
parent
    Ptr StructureElementIter
result <- Ptr StructureElementIter -> IO (Ptr StructureElementIter)
poppler_structure_element_iter_get_child Ptr StructureElementIter
parent'
    Text -> Ptr StructureElementIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterGetChild" Ptr StructureElementIter
result
    StructureElementIter
result' <- ((ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter) Ptr StructureElementIter
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
parent
    StructureElementIter -> IO StructureElementIter
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElementIter
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterGetChildMethodInfo
instance (signature ~ (m StructureElementIter), MonadIO m) => O.MethodInfo StructureElementIterGetChildMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterGetChild

#endif

-- method StructureElementIter::get_element
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElementIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerStructureElementIter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureElement" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_iter_get_element" poppler_structure_element_iter_get_element :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO (Ptr Poppler.StructureElement.StructureElement)

-- | Returns the t'GI.Poppler.Structs.StructureElementIter.StructureElementIter' associated with /@iter@/.
-- 
-- /Since: 0.26/
structureElementIterGetElement ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m Poppler.StructureElement.StructureElement
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
structureElementIterGetElement :: StructureElementIter -> m StructureElement
structureElementIterGetElement StructureElementIter
iter = IO StructureElement -> m StructureElement
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElement -> m StructureElement)
-> IO StructureElement -> m StructureElement
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    Ptr StructureElement
result <- Ptr StructureElementIter -> IO (Ptr StructureElement)
poppler_structure_element_iter_get_element Ptr StructureElementIter
iter'
    Text -> Ptr StructureElement -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterGetElement" Ptr StructureElement
result
    StructureElement
result' <- ((ManagedPtr StructureElement -> StructureElement)
-> Ptr StructureElement -> IO StructureElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr StructureElement -> StructureElement
Poppler.StructureElement.StructureElement) Ptr StructureElement
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    StructureElement -> IO StructureElement
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElement
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterGetElementMethodInfo
instance (signature ~ (m Poppler.StructureElement.StructureElement), MonadIO m) => O.MethodInfo StructureElementIterGetElementMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterGetElement

#endif

-- method StructureElementIter::next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElementIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerStructureElementIter"
--                 , 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 "poppler_structure_element_iter_next" poppler_structure_element_iter_next :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO CInt

-- | Sets /@iter@/ to point to the next structure element at the current level
-- of the tree, if valid. See 'GI.Poppler.Structs.StructureElementIter.structureElementIterNew' for more
-- information.
-- 
-- /Since: 0.26/
structureElementIterNext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m Bool
    -- ^ __Returns:__ 'P.True', if /@iter@/ was set to the next structure element
structureElementIterNext :: StructureElementIter -> m Bool
structureElementIterNext StructureElementIter
iter = IO Bool -> m Bool
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 StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    CInt
result <- Ptr StructureElementIter -> IO CInt
poppler_structure_element_iter_next Ptr StructureElementIter
iter'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterNextMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo StructureElementIterNextMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterNext

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveStructureElementIterMethod (t :: Symbol) (o :: *) :: * where
    ResolveStructureElementIterMethod "copy" o = StructureElementIterCopyMethodInfo
    ResolveStructureElementIterMethod "free" o = StructureElementIterFreeMethodInfo
    ResolveStructureElementIterMethod "next" o = StructureElementIterNextMethodInfo
    ResolveStructureElementIterMethod "getChild" o = StructureElementIterGetChildMethodInfo
    ResolveStructureElementIterMethod "getElement" o = StructureElementIterGetElementMethodInfo
    ResolveStructureElementIterMethod l o = O.MethodResolutionFailed l o

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

#endif