{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An iterator object used to iterate over the members of a JSON object.
-- 
-- @JsonObjectIter@ must be allocated on the stack and initialised using
-- 'GI.Json.Structs.ObjectIter.objectIterInit' or 'GI.Json.Structs.ObjectIter.objectIterInitOrdered'.
-- 
-- The iterator is invalidated if the object is modified during
-- iteration.
-- 
-- All the fields in the @JsonObjectIter@ structure are private and should
-- never be accessed directly.
-- 
-- /Since: 1.2/

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

module GI.Json.Structs.ObjectIter
    ( 

-- * Exported types
    ObjectIter(..)                          ,
    newZeroObjectIter                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [init]("GI.Json.Structs.ObjectIter#g:method:init"), [initOrdered]("GI.Json.Structs.ObjectIter#g:method:initOrdered"), [next]("GI.Json.Structs.ObjectIter#g:method:next"), [nextOrdered]("GI.Json.Structs.ObjectIter#g:method:nextOrdered").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveObjectIterMethod                 ,
#endif

-- ** init #method:init#

#if defined(ENABLE_OVERLOADING)
    ObjectIterInitMethodInfo                ,
#endif
    objectIterInit                          ,


-- ** initOrdered #method:initOrdered#

#if defined(ENABLE_OVERLOADING)
    ObjectIterInitOrderedMethodInfo         ,
#endif
    objectIterInitOrdered                   ,


-- ** next #method:next#

#if defined(ENABLE_OVERLOADING)
    ObjectIterNextMethodInfo                ,
#endif
    objectIterNext                          ,


-- ** nextOrdered #method:nextOrdered#

#if defined(ENABLE_OVERLOADING)
    ObjectIterNextOrderedMethodInfo         ,
#endif
    objectIterNextOrdered                   ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Json.Callbacks as Json.Callbacks
import {-# SOURCE #-} qualified GI.Json.Enums as Json.Enums
import {-# SOURCE #-} qualified GI.Json.Structs.Array as Json.Array
import {-# SOURCE #-} qualified GI.Json.Structs.Node as Json.Node
import {-# SOURCE #-} qualified GI.Json.Structs.Object as Json.Object

#else
import {-# SOURCE #-} qualified GI.Json.Structs.Node as Json.Node
import {-# SOURCE #-} qualified GI.Json.Structs.Object as Json.Object

#endif

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

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

instance BoxedPtr ObjectIter where
    boxedPtrCopy :: ObjectIter -> IO ObjectIter
boxedPtrCopy = \ObjectIter
p -> ObjectIter -> (Ptr ObjectIter -> IO ObjectIter) -> IO ObjectIter
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ObjectIter
p (Int -> Ptr ObjectIter -> IO (Ptr ObjectIter)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr ObjectIter -> IO (Ptr ObjectIter))
-> (Ptr ObjectIter -> IO ObjectIter)
-> Ptr ObjectIter
-> IO ObjectIter
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ObjectIter -> ObjectIter)
-> Ptr ObjectIter -> IO ObjectIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ObjectIter -> ObjectIter
ObjectIter)
    boxedPtrFree :: ObjectIter -> IO ()
boxedPtrFree = \ObjectIter
x -> ObjectIter -> (Ptr ObjectIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ObjectIter
x Ptr ObjectIter -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ObjectIter where
    boxedPtrCalloc :: IO (Ptr ObjectIter)
boxedPtrCalloc = Int -> IO (Ptr ObjectIter)
forall a. Int -> IO (Ptr a)
callocBytes Int
64


-- | Construct a `ObjectIter` struct initialized to zero.
newZeroObjectIter :: MonadIO m => m ObjectIter
newZeroObjectIter :: forall (m :: * -> *). MonadIO m => m ObjectIter
newZeroObjectIter = IO ObjectIter -> m ObjectIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ObjectIter -> m ObjectIter) -> IO ObjectIter -> m ObjectIter
forall a b. (a -> b) -> a -> b
$ IO (Ptr ObjectIter)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ObjectIter)
-> (Ptr ObjectIter -> IO ObjectIter) -> IO ObjectIter
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ObjectIter -> ObjectIter)
-> Ptr ObjectIter -> IO ObjectIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ObjectIter -> ObjectIter
ObjectIter

instance tag ~ 'AttrSet => Constructible ObjectIter tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ObjectIter -> ObjectIter)
-> [AttrOp ObjectIter tag] -> m ObjectIter
new ManagedPtr ObjectIter -> ObjectIter
_ [AttrOp ObjectIter tag]
attrs = do
        ObjectIter
o <- m ObjectIter
forall (m :: * -> *). MonadIO m => m ObjectIter
newZeroObjectIter
        ObjectIter -> [AttrOp ObjectIter 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ObjectIter
o [AttrOp ObjectIter tag]
[AttrOp ObjectIter 'AttrSet]
attrs
        ObjectIter -> m ObjectIter
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectIter
o



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ObjectIter
type instance O.AttributeList ObjectIter = ObjectIterAttributeList
type ObjectIterAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

-- method ObjectIter::init
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "ObjectIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an uninitialised JSON object iterator"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the JSON object to iterate over"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "json_object_iter_init" json_object_iter_init :: 
    Ptr ObjectIter ->                       -- iter : TInterface (Name {namespace = "Json", name = "ObjectIter"})
    Ptr Json.Object.Object ->               -- object : TInterface (Name {namespace = "Json", name = "Object"})
    IO ()

-- | Initialises the /@iter@/ and associate it with /@object@/.
-- 
-- 
-- === /c code/
-- >JsonObjectIter iter;
-- >const gchar *member_name;
-- >JsonNode *member_node;
-- >
-- >json_object_iter_init (&iter, some_object);
-- >while (json_object_iter_next (&iter, &member_name, &member_node))
-- >  {
-- >    // Do something with @member_name and @member_node.
-- >  }
-- 
-- 
-- The iterator initialized with this function will iterate the
-- members of the object in an undefined order.
-- 
-- See also: 'GI.Json.Structs.ObjectIter.objectIterInitOrdered'
-- 
-- /Since: 1.2/
objectIterInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectIter
    -- ^ /@iter@/: an uninitialised JSON object iterator
    -> Json.Object.Object
    -- ^ /@object@/: the JSON object to iterate over
    -> m ()
objectIterInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectIter -> Object -> m ()
objectIterInit ObjectIter
iter Object
object = 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 ObjectIter
iter' <- ObjectIter -> IO (Ptr ObjectIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectIter
iter
    Ptr Object
object' <- Object -> IO (Ptr Object)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Object
object
    Ptr ObjectIter -> Ptr Object -> IO ()
json_object_iter_init Ptr ObjectIter
iter' Ptr Object
object'
    ObjectIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectIter
iter
    Object -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Object
object
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectIterInitMethodInfo
instance (signature ~ (Json.Object.Object -> m ()), MonadIO m) => O.OverloadedMethod ObjectIterInitMethodInfo ObjectIter signature where
    overloadedMethod = objectIterInit

instance O.OverloadedMethodInfo ObjectIterInitMethodInfo ObjectIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Structs.ObjectIter.objectIterInit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.6/docs/GI-Json-Structs-ObjectIter.html#v:objectIterInit"
        })


#endif

-- method ObjectIter::init_ordered
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "ObjectIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an uninitialised iterator"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the JSON object to iterate over"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "json_object_iter_init_ordered" json_object_iter_init_ordered :: 
    Ptr ObjectIter ->                       -- iter : TInterface (Name {namespace = "Json", name = "ObjectIter"})
    Ptr Json.Object.Object ->               -- object : TInterface (Name {namespace = "Json", name = "Object"})
    IO ()

-- | Initialises the /@iter@/ and associate it with /@object@/.
-- 
-- 
-- === /c code/
-- >JsonObjectIter iter;
-- >const gchar *member_name;
-- >JsonNode *member_node;
-- >
-- >json_object_iter_init_ordered (&iter, some_object);
-- >while (json_object_iter_next_ordered (&iter, &member_name, &member_node))
-- >  {
-- >    // Do something with @member_name and @member_node.
-- >  }
-- 
-- 
-- See also: 'GI.Json.Structs.ObjectIter.objectIterInit'
-- 
-- /Since: 1.6/
objectIterInitOrdered ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectIter
    -- ^ /@iter@/: an uninitialised iterator
    -> Json.Object.Object
    -- ^ /@object@/: the JSON object to iterate over
    -> m ()
objectIterInitOrdered :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectIter -> Object -> m ()
objectIterInitOrdered ObjectIter
iter Object
object = 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 ObjectIter
iter' <- ObjectIter -> IO (Ptr ObjectIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectIter
iter
    Ptr Object
object' <- Object -> IO (Ptr Object)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Object
object
    Ptr ObjectIter -> Ptr Object -> IO ()
json_object_iter_init_ordered Ptr ObjectIter
iter' Ptr Object
object'
    ObjectIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectIter
iter
    Object -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Object
object
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectIterInitOrderedMethodInfo
instance (signature ~ (Json.Object.Object -> m ()), MonadIO m) => O.OverloadedMethod ObjectIterInitOrderedMethodInfo ObjectIter signature where
    overloadedMethod = objectIterInitOrdered

instance O.OverloadedMethodInfo ObjectIterInitOrderedMethodInfo ObjectIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Structs.ObjectIter.objectIterInitOrdered",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.6/docs/GI-Json-Structs-ObjectIter.html#v:objectIterInitOrdered"
        })


#endif

-- method ObjectIter::next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "ObjectIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a JSON object iterator"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "member_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return\n   location for the member name, or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "member_node"
--           , argType = TInterface Name { namespace = "Json" , name = "Node" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return\n   location for the member value, or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "json_object_iter_next" json_object_iter_next :: 
    Ptr ObjectIter ->                       -- iter : TInterface (Name {namespace = "Json", name = "ObjectIter"})
    Ptr CString ->                          -- member_name : TBasicType TUTF8
    Ptr (Ptr Json.Node.Node) ->             -- member_node : TInterface (Name {namespace = "Json", name = "Node"})
    IO CInt

-- | Advances the iterator and retrieves the next member in the object.
-- 
-- If the end of the object is reached, @FALSE@ is returned and /@memberName@/
-- and /@memberNode@/ are set to invalid values. After that point, the /@iter@/
-- is invalid.
-- 
-- The order in which members are returned by the iterator is undefined. The
-- iterator is invalidated if the object is modified during iteration.
-- 
-- You must use this function with an iterator initialized with
-- 'GI.Json.Structs.ObjectIter.objectIterInit'; using this function with an iterator
-- initialized with 'GI.Json.Structs.ObjectIter.objectIterInitOrdered' yields undefined
-- behavior.
-- 
-- See also: 'GI.Json.Structs.ObjectIter.objectIterNextOrdered'
-- 
-- /Since: 1.2/
objectIterNext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectIter
    -- ^ /@iter@/: a JSON object iterator
    -> m ((Bool, T.Text, Json.Node.Node))
    -- ^ __Returns:__ @TRUE@ if /@memberName@/ and /@memberNode@/ are valid; @FALSE@ if
    --   there are no more members
objectIterNext :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectIter -> m (Bool, Text, Node)
objectIterNext ObjectIter
iter = IO (Bool, Text, Node) -> m (Bool, Text, Node)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, Node) -> m (Bool, Text, Node))
-> IO (Bool, Text, Node) -> m (Bool, Text, Node)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ObjectIter
iter' <- ObjectIter -> IO (Ptr ObjectIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectIter
iter
    Ptr CString
memberName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr (Ptr Node)
memberNode <- IO (Ptr (Ptr Node))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Json.Node.Node))
    CInt
result <- Ptr ObjectIter -> Ptr CString -> Ptr (Ptr Node) -> IO CInt
json_object_iter_next Ptr ObjectIter
iter' Ptr CString
memberName Ptr (Ptr Node)
memberNode
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CString
memberName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
memberName
    Text
memberName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
memberName'
    Ptr Node
memberNode' <- Ptr (Ptr Node) -> IO (Ptr Node)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Node)
memberNode
    Node
memberNode'' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
memberNode'
    ObjectIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectIter
iter
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
memberName
    Ptr (Ptr Node) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Node)
memberNode
    (Bool, Text, Node) -> IO (Bool, Text, Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
memberName'', Node
memberNode'')

#if defined(ENABLE_OVERLOADING)
data ObjectIterNextMethodInfo
instance (signature ~ (m ((Bool, T.Text, Json.Node.Node))), MonadIO m) => O.OverloadedMethod ObjectIterNextMethodInfo ObjectIter signature where
    overloadedMethod = objectIterNext

instance O.OverloadedMethodInfo ObjectIterNextMethodInfo ObjectIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Structs.ObjectIter.objectIterNext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.6/docs/GI-Json-Structs-ObjectIter.html#v:objectIterNext"
        })


#endif

-- method ObjectIter::next_ordered
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "ObjectIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an ordered JSON object iterator"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "member_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return\n   location for the member name, or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "member_node"
--           , argType = TInterface Name { namespace = "Json" , name = "Node" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return\n   location for the member value, or %NULL to ignore"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "json_object_iter_next_ordered" json_object_iter_next_ordered :: 
    Ptr ObjectIter ->                       -- iter : TInterface (Name {namespace = "Json", name = "ObjectIter"})
    Ptr CString ->                          -- member_name : TBasicType TUTF8
    Ptr (Ptr Json.Node.Node) ->             -- member_node : TInterface (Name {namespace = "Json", name = "Node"})
    IO CInt

-- | Advances the iterator and retrieves the next member in the object.
-- 
-- If the end of the object is reached, @FALSE@ is returned and /@memberName@/ and
-- /@memberNode@/ are set to invalid values. After that point, the /@iter@/ is invalid.
-- 
-- The order in which members are returned by the iterator is the same order in
-- which the members were added to the @JsonObject@. The iterator is invalidated
-- if its @JsonObject@ is modified during iteration.
-- 
-- You must use this function with an iterator initialized with
-- 'GI.Json.Structs.ObjectIter.objectIterInitOrdered'; using this function with an iterator
-- initialized with 'GI.Json.Structs.ObjectIter.objectIterInit' yields undefined behavior.
-- 
-- See also: 'GI.Json.Structs.ObjectIter.objectIterNext'
-- 
-- /Since: 1.6/
objectIterNextOrdered ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectIter
    -- ^ /@iter@/: an ordered JSON object iterator
    -> m ((Bool, T.Text, Json.Node.Node))
    -- ^ __Returns:__ @TRUE @if /@memberName@/ and /@memberNode@/ are valid; @FALSE@ if the end
    --    of the object has been reached
objectIterNextOrdered :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectIter -> m (Bool, Text, Node)
objectIterNextOrdered ObjectIter
iter = IO (Bool, Text, Node) -> m (Bool, Text, Node)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, Node) -> m (Bool, Text, Node))
-> IO (Bool, Text, Node) -> m (Bool, Text, Node)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ObjectIter
iter' <- ObjectIter -> IO (Ptr ObjectIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectIter
iter
    Ptr CString
memberName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr (Ptr Node)
memberNode <- IO (Ptr (Ptr Node))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Json.Node.Node))
    CInt
result <- Ptr ObjectIter -> Ptr CString -> Ptr (Ptr Node) -> IO CInt
json_object_iter_next_ordered Ptr ObjectIter
iter' Ptr CString
memberName Ptr (Ptr Node)
memberNode
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CString
memberName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
memberName
    Text
memberName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
memberName'
    Ptr Node
memberNode' <- Ptr (Ptr Node) -> IO (Ptr Node)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Node)
memberNode
    Node
memberNode'' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
memberNode'
    ObjectIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectIter
iter
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
memberName
    Ptr (Ptr Node) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Node)
memberNode
    (Bool, Text, Node) -> IO (Bool, Text, Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
memberName'', Node
memberNode'')

#if defined(ENABLE_OVERLOADING)
data ObjectIterNextOrderedMethodInfo
instance (signature ~ (m ((Bool, T.Text, Json.Node.Node))), MonadIO m) => O.OverloadedMethod ObjectIterNextOrderedMethodInfo ObjectIter signature where
    overloadedMethod = objectIterNextOrdered

instance O.OverloadedMethodInfo ObjectIterNextOrderedMethodInfo ObjectIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Structs.ObjectIter.objectIterNextOrdered",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.6/docs/GI-Json-Structs-ObjectIter.html#v:objectIterNextOrdered"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveObjectIterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveObjectIterMethod "init" o = ObjectIterInitMethodInfo
    ResolveObjectIterMethod "initOrdered" o = ObjectIterInitOrderedMethodInfo
    ResolveObjectIterMethod "next" o = ObjectIterNextMethodInfo
    ResolveObjectIterMethod "nextOrdered" o = ObjectIterNextOrderedMethodInfo
    ResolveObjectIterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveObjectIterMethod t ObjectIter, O.OverloadedMethod info ObjectIter p) => OL.IsLabel t (ObjectIter -> 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 ~ ResolveObjectIterMethod t ObjectIter, O.OverloadedMethod info ObjectIter p, R.HasField t ObjectIter p) => R.HasField t ObjectIter p where
    getField = O.overloadedMethod @info

#endif

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

#endif