{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Poppler.Structs.StructureElementIter#g:method:copy"), [free]("GI.Poppler.Structs.StructureElementIter#g:method:free"), [next]("GI.Poppler.Structs.StructureElementIter#g:method:next").
-- 
-- ==== Getters
-- [getChild]("GI.Poppler.Structs.StructureElementIter#g:method:getChild"), [getElement]("GI.Poppler.Structs.StructureElementIter#g:method:getElement").
-- 
-- ==== Setters
-- /None/.

#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.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.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 {-# 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'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe StructureElementIter) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_poppler_structure_element_iter_get_type
    gvalueSet_ :: Ptr GValue -> Maybe StructureElementIter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe StructureElementIter
P.Nothing = Ptr GValue -> Ptr StructureElementIter -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr StructureElementIter
forall a. Ptr a
FP.nullPtr :: FP.Ptr StructureElementIter)
    gvalueSet_ Ptr GValue
gv (P.Just StructureElementIter
obj) = StructureElementIter
-> (Ptr StructureElementIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StructureElementIter
obj (Ptr GValue -> Ptr StructureElementIter -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe StructureElementIter)
gvalueGet_ Ptr GValue
gv = do
        Ptr StructureElementIter
ptr <- Ptr GValue -> IO (Ptr StructureElementIter)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr StructureElementIter)
        if Ptr StructureElementIter
ptr Ptr StructureElementIter -> Ptr StructureElementIter -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr StructureElementIter
forall a. Ptr a
FP.nullPtr
        then StructureElementIter -> Maybe StructureElementIter
forall a. a -> Maybe a
P.Just (StructureElementIter -> Maybe StructureElementIter)
-> IO StructureElementIter -> IO (Maybe StructureElementIter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe StructureElementIter -> IO (Maybe StructureElementIter)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StructureElementIter
forall a. Maybe a
P.Nothing
        
    


#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDocument a) =>
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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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.OverloadedMethod StructureElementIterCopyMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterCopy

instance O.OverloadedMethodInfo StructureElementIterCopyMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-StructureElementIter.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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.OverloadedMethod StructureElementIterFreeMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterFree

instance O.OverloadedMethodInfo StructureElementIterFreeMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-StructureElementIter.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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.OverloadedMethod StructureElementIterGetChildMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterGetChild

instance O.OverloadedMethodInfo StructureElementIterGetChildMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterGetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-StructureElementIter.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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.OverloadedMethod StructureElementIterGetElementMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterGetElement

instance O.OverloadedMethodInfo StructureElementIterGetElementMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterGetElement",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-StructureElementIter.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
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.OverloadedMethod StructureElementIterNextMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterNext

instance O.OverloadedMethodInfo StructureElementIterNextMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterNext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-StructureElementIter.html#v: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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveStructureElementIterMethod t StructureElementIter, O.OverloadedMethod info StructureElementIter p, R.HasField t StructureElementIter p) => R.HasField t StructureElementIter p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveStructureElementIterMethod t StructureElementIter, O.OverloadedMethodInfo info StructureElementIter) => OL.IsLabel t (O.MethodProxy info StructureElementIter) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif