{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @JsonParser@ provides an object for parsing a JSON data stream, either
-- inside a file or inside a static buffer.
-- 
-- == Using @JsonParser@
-- 
-- The @JsonParser@ API is fairly simple:
-- 
-- \`\`@c
-- gboolean
-- parse_json (const char *filename)
-- {
--   g_autoptr(JsonParser) parser = json_parser_new ();
--   g_autoptr(GError) error = NULL
-- 
--   json_parser_load_from_file (parser, filename, &error);
--   if (error != NULL)
--     {
--       g_critical (\"Unable to parse \'%s\': %s\", filename, error->message);
--       return FALSE;
--     }
-- 
--   g_autoptr(JsonNode) root = json_parser_get_root (parser);
-- 
--   \/\/ manipulate the object tree from the root node
-- 
--   return TRUE
-- }
-- @\`@
-- 
-- By default, the entire process of loading the data and parsing it is
-- synchronous; the [method\@Json.Parser.load_from_stream_async()] API will
-- load the data asynchronously, but parse it in the main context as the
-- signals of the parser must be emitted in the same thread. If you do
-- not use signals, and you wish to also parse the JSON data without blocking,
-- you should use a @GTask@ and the synchronous @JsonParser\` API inside the
-- task itself.

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

module GI.Json.Objects.Parser
    ( 

-- * Exported types
    Parser(..)                              ,
    IsParser                                ,
    toParser                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasAssignment]("GI.Json.Objects.Parser#g:method:hasAssignment"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [loadFromData]("GI.Json.Objects.Parser#g:method:loadFromData"), [loadFromFile]("GI.Json.Objects.Parser#g:method:loadFromFile"), [loadFromMappedFile]("GI.Json.Objects.Parser#g:method:loadFromMappedFile"), [loadFromStream]("GI.Json.Objects.Parser#g:method:loadFromStream"), [loadFromStreamAsync]("GI.Json.Objects.Parser#g:method:loadFromStreamAsync"), [loadFromStreamFinish]("GI.Json.Objects.Parser#g:method:loadFromStreamFinish"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [stealRoot]("GI.Json.Objects.Parser#g:method:stealRoot"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getCurrentLine]("GI.Json.Objects.Parser#g:method:getCurrentLine"), [getCurrentPos]("GI.Json.Objects.Parser#g:method:getCurrentPos"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRoot]("GI.Json.Objects.Parser#g:method:getRoot").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveParserMethod                     ,
#endif

-- ** getCurrentLine #method:getCurrentLine#

#if defined(ENABLE_OVERLOADING)
    ParserGetCurrentLineMethodInfo          ,
#endif
    parserGetCurrentLine                    ,


-- ** getCurrentPos #method:getCurrentPos#

#if defined(ENABLE_OVERLOADING)
    ParserGetCurrentPosMethodInfo           ,
#endif
    parserGetCurrentPos                     ,


-- ** getRoot #method:getRoot#

#if defined(ENABLE_OVERLOADING)
    ParserGetRootMethodInfo                 ,
#endif
    parserGetRoot                           ,


-- ** hasAssignment #method:hasAssignment#

#if defined(ENABLE_OVERLOADING)
    ParserHasAssignmentMethodInfo           ,
#endif
    parserHasAssignment                     ,


-- ** loadFromData #method:loadFromData#

#if defined(ENABLE_OVERLOADING)
    ParserLoadFromDataMethodInfo            ,
#endif
    parserLoadFromData                      ,


-- ** loadFromFile #method:loadFromFile#

#if defined(ENABLE_OVERLOADING)
    ParserLoadFromFileMethodInfo            ,
#endif
    parserLoadFromFile                      ,


-- ** loadFromMappedFile #method:loadFromMappedFile#

#if defined(ENABLE_OVERLOADING)
    ParserLoadFromMappedFileMethodInfo      ,
#endif
    parserLoadFromMappedFile                ,


-- ** loadFromStream #method:loadFromStream#

#if defined(ENABLE_OVERLOADING)
    ParserLoadFromStreamMethodInfo          ,
#endif
    parserLoadFromStream                    ,


-- ** loadFromStreamAsync #method:loadFromStreamAsync#

#if defined(ENABLE_OVERLOADING)
    ParserLoadFromStreamAsyncMethodInfo     ,
#endif
    parserLoadFromStreamAsync               ,


-- ** loadFromStreamFinish #method:loadFromStreamFinish#

#if defined(ENABLE_OVERLOADING)
    ParserLoadFromStreamFinishMethodInfo    ,
#endif
    parserLoadFromStreamFinish              ,


-- ** new #method:new#

    parserNew                               ,


-- ** newImmutable #method:newImmutable#

    parserNewImmutable                      ,


-- ** stealRoot #method:stealRoot#

#if defined(ENABLE_OVERLOADING)
    ParserStealRootMethodInfo               ,
#endif
    parserStealRoot                         ,




 -- * Properties


-- ** immutable #attr:immutable#
-- | Whether the tree built by the parser should be immutable
-- when created.
-- 
-- Making the output immutable on creation avoids the expense
-- of traversing it to make it immutable later.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    ParserImmutablePropertyInfo             ,
#endif
    constructParserImmutable                ,
    getParserImmutable                      ,
#if defined(ENABLE_OVERLOADING)
    parserImmutable                         ,
#endif




 -- * Signals


-- ** arrayElement #signal:arrayElement#

    ParserArrayElementCallback              ,
#if defined(ENABLE_OVERLOADING)
    ParserArrayElementSignalInfo            ,
#endif
    afterParserArrayElement                 ,
    onParserArrayElement                    ,


-- ** arrayEnd #signal:arrayEnd#

    ParserArrayEndCallback                  ,
#if defined(ENABLE_OVERLOADING)
    ParserArrayEndSignalInfo                ,
#endif
    afterParserArrayEnd                     ,
    onParserArrayEnd                        ,


-- ** arrayStart #signal:arrayStart#

    ParserArrayStartCallback                ,
#if defined(ENABLE_OVERLOADING)
    ParserArrayStartSignalInfo              ,
#endif
    afterParserArrayStart                   ,
    onParserArrayStart                      ,


-- ** error #signal:error#

    ParserErrorCallback                     ,
#if defined(ENABLE_OVERLOADING)
    ParserErrorSignalInfo                   ,
#endif
    afterParserError                        ,
    onParserError                           ,


-- ** objectEnd #signal:objectEnd#

    ParserObjectEndCallback                 ,
#if defined(ENABLE_OVERLOADING)
    ParserObjectEndSignalInfo               ,
#endif
    afterParserObjectEnd                    ,
    onParserObjectEnd                       ,


-- ** objectMember #signal:objectMember#

    ParserObjectMemberCallback              ,
#if defined(ENABLE_OVERLOADING)
    ParserObjectMemberSignalInfo            ,
#endif
    afterParserObjectMember                 ,
    onParserObjectMember                    ,


-- ** objectStart #signal:objectStart#

    ParserObjectStartCallback               ,
#if defined(ENABLE_OVERLOADING)
    ParserObjectStartSignalInfo             ,
#endif
    afterParserObjectStart                  ,
    onParserObjectStart                     ,


-- ** parseEnd #signal:parseEnd#

    ParserParseEndCallback                  ,
#if defined(ENABLE_OVERLOADING)
    ParserParseEndSignalInfo                ,
#endif
    afterParserParseEnd                     ,
    onParserParseEnd                        ,


-- ** parseStart #signal:parseStart#

    ParserParseStartCallback                ,
#if defined(ENABLE_OVERLOADING)
    ParserParseStartSignalInfo              ,
#endif
    afterParserParseStart                   ,
    onParserParseStart                      ,




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
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

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

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

foreign import ccall "json_parser_get_type"
    c_json_parser_get_type :: IO B.Types.GType

instance B.Types.TypedObject Parser where
    glibType :: IO GType
glibType = IO GType
c_json_parser_get_type

instance B.Types.GObject Parser

-- | Type class for types which can be safely cast to `Parser`, for instance with `toParser`.
class (SP.GObject o, O.IsDescendantOf Parser o) => IsParser o
instance (SP.GObject o, O.IsDescendantOf Parser o) => IsParser o

instance O.HasParentTypes Parser
type instance O.ParentTypes Parser = '[GObject.Object.Object]

-- | Cast to `Parser`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toParser :: (MIO.MonadIO m, IsParser o) => o -> m Parser
toParser :: forall (m :: * -> *) o. (MonadIO m, IsParser o) => o -> m Parser
toParser = IO Parser -> m Parser
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Parser -> m Parser) -> (o -> IO Parser) -> o -> m Parser
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Parser -> Parser) -> o -> IO Parser
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Parser -> Parser
Parser

-- | Convert 'Parser' 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 Parser) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_json_parser_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Parser -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Parser
P.Nothing = Ptr GValue -> Ptr Parser -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Parser
forall a. Ptr a
FP.nullPtr :: FP.Ptr Parser)
    gvalueSet_ Ptr GValue
gv (P.Just Parser
obj) = Parser -> (Ptr Parser -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Parser
obj (Ptr GValue -> Ptr Parser -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Parser)
gvalueGet_ Ptr GValue
gv = do
        Ptr Parser
ptr <- Ptr GValue -> IO (Ptr Parser)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Parser)
        if Ptr Parser
ptr Ptr Parser -> Ptr Parser -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Parser
forall a. Ptr a
FP.nullPtr
        then Parser -> Maybe Parser
forall a. a -> Maybe a
P.Just (Parser -> Maybe Parser) -> IO Parser -> IO (Maybe Parser)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Parser -> Parser) -> Ptr Parser -> IO Parser
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Parser -> Parser
Parser Ptr Parser
ptr
        else Maybe Parser -> IO (Maybe Parser)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Parser
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveParserMethod (t :: Symbol) (o :: *) :: * where
    ResolveParserMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveParserMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveParserMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveParserMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveParserMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveParserMethod "hasAssignment" o = ParserHasAssignmentMethodInfo
    ResolveParserMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveParserMethod "loadFromData" o = ParserLoadFromDataMethodInfo
    ResolveParserMethod "loadFromFile" o = ParserLoadFromFileMethodInfo
    ResolveParserMethod "loadFromMappedFile" o = ParserLoadFromMappedFileMethodInfo
    ResolveParserMethod "loadFromStream" o = ParserLoadFromStreamMethodInfo
    ResolveParserMethod "loadFromStreamAsync" o = ParserLoadFromStreamAsyncMethodInfo
    ResolveParserMethod "loadFromStreamFinish" o = ParserLoadFromStreamFinishMethodInfo
    ResolveParserMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveParserMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveParserMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveParserMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveParserMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveParserMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveParserMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveParserMethod "stealRoot" o = ParserStealRootMethodInfo
    ResolveParserMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveParserMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveParserMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveParserMethod "getCurrentLine" o = ParserGetCurrentLineMethodInfo
    ResolveParserMethod "getCurrentPos" o = ParserGetCurrentPosMethodInfo
    ResolveParserMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveParserMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveParserMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveParserMethod "getRoot" o = ParserGetRootMethodInfo
    ResolveParserMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveParserMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveParserMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveParserMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal Parser::array-element
-- | The @::array-element@ signal is emitted each time a parser
-- has successfully parsed a single element of a JSON array.
type ParserArrayElementCallback =
    Json.Array.Array
    -- ^ /@array@/: a JSON array
    -> Int32
    -- ^ /@index_@/: the index of the newly parsed array element
    -> IO ()

type C_ParserArrayElementCallback =
    Ptr Parser ->                           -- object
    Ptr Json.Array.Array ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserArrayElementCallback`.
foreign import ccall "wrapper"
    mk_ParserArrayElementCallback :: C_ParserArrayElementCallback -> IO (FunPtr C_ParserArrayElementCallback)

wrap_ParserArrayElementCallback :: 
    GObject a => (a -> ParserArrayElementCallback) ->
    C_ParserArrayElementCallback
wrap_ParserArrayElementCallback :: forall a.
GObject a =>
(a -> ParserArrayElementCallback) -> C_ParserArrayElementCallback
wrap_ParserArrayElementCallback a -> ParserArrayElementCallback
gi'cb Ptr Parser
gi'selfPtr Ptr Array
array Int32
index_ Ptr ()
_ = do
    Ptr Array -> (Array -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Array
array ((Array -> IO ()) -> IO ()) -> (Array -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Array
array' -> do
        Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> ParserArrayElementCallback
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self)  Array
array' Int32
index_


-- | Connect a signal handler for the [arrayElement](#signal:arrayElement) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #arrayElement callback
-- @
-- 
-- 
onParserArrayElement :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserArrayElementCallback) -> m SignalHandlerId
onParserArrayElement :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a
-> ((?self::a) => ParserArrayElementCallback) -> m SignalHandlerId
onParserArrayElement a
obj (?self::a) => ParserArrayElementCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserArrayElementCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserArrayElementCallback
ParserArrayElementCallback
cb
    let wrapped' :: C_ParserArrayElementCallback
wrapped' = (a -> ParserArrayElementCallback) -> C_ParserArrayElementCallback
forall a.
GObject a =>
(a -> ParserArrayElementCallback) -> C_ParserArrayElementCallback
wrap_ParserArrayElementCallback a -> ParserArrayElementCallback
wrapped
    FunPtr C_ParserArrayElementCallback
wrapped'' <- C_ParserArrayElementCallback
-> IO (FunPtr C_ParserArrayElementCallback)
mk_ParserArrayElementCallback C_ParserArrayElementCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayElementCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"array-element" FunPtr C_ParserArrayElementCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [arrayElement](#signal:arrayElement) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #arrayElement callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserArrayElement :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserArrayElementCallback) -> m SignalHandlerId
afterParserArrayElement :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a
-> ((?self::a) => ParserArrayElementCallback) -> m SignalHandlerId
afterParserArrayElement a
obj (?self::a) => ParserArrayElementCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserArrayElementCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserArrayElementCallback
ParserArrayElementCallback
cb
    let wrapped' :: C_ParserArrayElementCallback
wrapped' = (a -> ParserArrayElementCallback) -> C_ParserArrayElementCallback
forall a.
GObject a =>
(a -> ParserArrayElementCallback) -> C_ParserArrayElementCallback
wrap_ParserArrayElementCallback a -> ParserArrayElementCallback
wrapped
    FunPtr C_ParserArrayElementCallback
wrapped'' <- C_ParserArrayElementCallback
-> IO (FunPtr C_ParserArrayElementCallback)
mk_ParserArrayElementCallback C_ParserArrayElementCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayElementCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"array-element" FunPtr C_ParserArrayElementCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserArrayElementSignalInfo
instance SignalInfo ParserArrayElementSignalInfo where
    type HaskellCallbackType ParserArrayElementSignalInfo = ParserArrayElementCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserArrayElementCallback cb
        cb'' <- mk_ParserArrayElementCallback cb'
        connectSignalFunPtr obj "array-element" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::array-element"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:arrayElement"})

#endif

-- signal Parser::array-end
-- | The @::array-end@ signal is emitted each time a parser
-- has successfully parsed an entire JSON array.
type ParserArrayEndCallback =
    Json.Array.Array
    -- ^ /@array@/: the parsed JSON array
    -> IO ()

type C_ParserArrayEndCallback =
    Ptr Parser ->                           -- object
    Ptr Json.Array.Array ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserArrayEndCallback`.
foreign import ccall "wrapper"
    mk_ParserArrayEndCallback :: C_ParserArrayEndCallback -> IO (FunPtr C_ParserArrayEndCallback)

wrap_ParserArrayEndCallback :: 
    GObject a => (a -> ParserArrayEndCallback) ->
    C_ParserArrayEndCallback
wrap_ParserArrayEndCallback :: forall a.
GObject a =>
(a -> Array -> IO ()) -> C_ParserArrayEndCallback
wrap_ParserArrayEndCallback a -> Array -> IO ()
gi'cb Ptr Parser
gi'selfPtr Ptr Array
array Ptr ()
_ = do
    Ptr Array -> (Array -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Array
array ((Array -> IO ()) -> IO ()) -> (Array -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Array
array' -> do
        Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> Array -> IO ()
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self)  Array
array'


-- | Connect a signal handler for the [arrayEnd](#signal:arrayEnd) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #arrayEnd callback
-- @
-- 
-- 
onParserArrayEnd :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserArrayEndCallback) -> m SignalHandlerId
onParserArrayEnd :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => Array -> IO ()) -> m SignalHandlerId
onParserArrayEnd a
obj (?self::a) => Array -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Array -> IO ()
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => Array -> IO ()
Array -> IO ()
cb
    let wrapped' :: C_ParserArrayEndCallback
wrapped' = (a -> Array -> IO ()) -> C_ParserArrayEndCallback
forall a.
GObject a =>
(a -> Array -> IO ()) -> C_ParserArrayEndCallback
wrap_ParserArrayEndCallback a -> Array -> IO ()
wrapped
    FunPtr C_ParserArrayEndCallback
wrapped'' <- C_ParserArrayEndCallback -> IO (FunPtr C_ParserArrayEndCallback)
mk_ParserArrayEndCallback C_ParserArrayEndCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayEndCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"array-end" FunPtr C_ParserArrayEndCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [arrayEnd](#signal:arrayEnd) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #arrayEnd callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserArrayEnd :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserArrayEndCallback) -> m SignalHandlerId
afterParserArrayEnd :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => Array -> IO ()) -> m SignalHandlerId
afterParserArrayEnd a
obj (?self::a) => Array -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Array -> IO ()
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => Array -> IO ()
Array -> IO ()
cb
    let wrapped' :: C_ParserArrayEndCallback
wrapped' = (a -> Array -> IO ()) -> C_ParserArrayEndCallback
forall a.
GObject a =>
(a -> Array -> IO ()) -> C_ParserArrayEndCallback
wrap_ParserArrayEndCallback a -> Array -> IO ()
wrapped
    FunPtr C_ParserArrayEndCallback
wrapped'' <- C_ParserArrayEndCallback -> IO (FunPtr C_ParserArrayEndCallback)
mk_ParserArrayEndCallback C_ParserArrayEndCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayEndCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"array-end" FunPtr C_ParserArrayEndCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserArrayEndSignalInfo
instance SignalInfo ParserArrayEndSignalInfo where
    type HaskellCallbackType ParserArrayEndSignalInfo = ParserArrayEndCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserArrayEndCallback cb
        cb'' <- mk_ParserArrayEndCallback cb'
        connectSignalFunPtr obj "array-end" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::array-end"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:arrayEnd"})

#endif

-- signal Parser::array-start
-- | The @::array-start@ signal is emitted each time a parser
-- starts parsing a JSON array.
type ParserArrayStartCallback =
    IO ()

type C_ParserArrayStartCallback =
    Ptr Parser ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserArrayStartCallback`.
foreign import ccall "wrapper"
    mk_ParserArrayStartCallback :: C_ParserArrayStartCallback -> IO (FunPtr C_ParserArrayStartCallback)

wrap_ParserArrayStartCallback :: 
    GObject a => (a -> ParserArrayStartCallback) ->
    C_ParserArrayStartCallback
wrap_ParserArrayStartCallback :: forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserArrayStartCallback a -> IO ()
gi'cb Ptr Parser
gi'selfPtr Ptr ()
_ = do
    Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> IO ()
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self) 


-- | Connect a signal handler for the [arrayStart](#signal:arrayStart) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #arrayStart callback
-- @
-- 
-- 
onParserArrayStart :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserArrayStartCallback) -> m SignalHandlerId
onParserArrayStart :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onParserArrayStart a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserArrayStartCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserArrayStartCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"array-start" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [arrayStart](#signal:arrayStart) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #arrayStart callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserArrayStart :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserArrayStartCallback) -> m SignalHandlerId
afterParserArrayStart :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterParserArrayStart a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserArrayStartCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserArrayStartCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"array-start" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserArrayStartSignalInfo
instance SignalInfo ParserArrayStartSignalInfo where
    type HaskellCallbackType ParserArrayStartSignalInfo = ParserArrayStartCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserArrayStartCallback cb
        cb'' <- mk_ParserArrayStartCallback cb'
        connectSignalFunPtr obj "array-start" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::array-start"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:arrayStart"})

#endif

-- signal Parser::error
-- | The @::error@ signal is emitted each time a parser encounters
-- an error in a JSON stream.
type ParserErrorCallback =
    Ptr ()
    -- ^ /@error@/: the error
    -> IO ()

type C_ParserErrorCallback =
    Ptr Parser ->                           -- object
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserErrorCallback`.
foreign import ccall "wrapper"
    mk_ParserErrorCallback :: C_ParserErrorCallback -> IO (FunPtr C_ParserErrorCallback)

wrap_ParserErrorCallback :: 
    GObject a => (a -> ParserErrorCallback) ->
    C_ParserErrorCallback
wrap_ParserErrorCallback :: forall a.
GObject a =>
(a -> ParserErrorCallback) -> C_ParserErrorCallback
wrap_ParserErrorCallback a -> ParserErrorCallback
gi'cb Ptr Parser
gi'selfPtr Ptr ()
error_ Ptr ()
_ = do
    Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> ParserErrorCallback
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self)  Ptr ()
error_


-- | Connect a signal handler for the [error](#signal:error) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #error callback
-- @
-- 
-- 
onParserError :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserErrorCallback) -> m SignalHandlerId
onParserError :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => ParserErrorCallback) -> m SignalHandlerId
onParserError a
obj (?self::a) => ParserErrorCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserErrorCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserErrorCallback
ParserErrorCallback
cb
    let wrapped' :: C_ParserErrorCallback
wrapped' = (a -> ParserErrorCallback) -> C_ParserErrorCallback
forall a.
GObject a =>
(a -> ParserErrorCallback) -> C_ParserErrorCallback
wrap_ParserErrorCallback a -> ParserErrorCallback
wrapped
    FunPtr C_ParserErrorCallback
wrapped'' <- C_ParserErrorCallback -> IO (FunPtr C_ParserErrorCallback)
mk_ParserErrorCallback C_ParserErrorCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserErrorCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"error" FunPtr C_ParserErrorCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [error](#signal:error) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #error callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserError :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserErrorCallback) -> m SignalHandlerId
afterParserError :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => ParserErrorCallback) -> m SignalHandlerId
afterParserError a
obj (?self::a) => ParserErrorCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserErrorCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserErrorCallback
ParserErrorCallback
cb
    let wrapped' :: C_ParserErrorCallback
wrapped' = (a -> ParserErrorCallback) -> C_ParserErrorCallback
forall a.
GObject a =>
(a -> ParserErrorCallback) -> C_ParserErrorCallback
wrap_ParserErrorCallback a -> ParserErrorCallback
wrapped
    FunPtr C_ParserErrorCallback
wrapped'' <- C_ParserErrorCallback -> IO (FunPtr C_ParserErrorCallback)
mk_ParserErrorCallback C_ParserErrorCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserErrorCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"error" FunPtr C_ParserErrorCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserErrorSignalInfo
instance SignalInfo ParserErrorSignalInfo where
    type HaskellCallbackType ParserErrorSignalInfo = ParserErrorCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserErrorCallback cb
        cb'' <- mk_ParserErrorCallback cb'
        connectSignalFunPtr obj "error" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::error"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:error"})

#endif

-- signal Parser::object-end
-- | The @::object-end@ signal is emitted each time a parser
-- has successfully parsed an entire JSON object.
type ParserObjectEndCallback =
    Json.Object.Object
    -- ^ /@object@/: the parsed JSON object
    -> IO ()

type C_ParserObjectEndCallback =
    Ptr Parser ->                           -- object
    Ptr Json.Object.Object ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserObjectEndCallback`.
foreign import ccall "wrapper"
    mk_ParserObjectEndCallback :: C_ParserObjectEndCallback -> IO (FunPtr C_ParserObjectEndCallback)

wrap_ParserObjectEndCallback :: 
    GObject a => (a -> ParserObjectEndCallback) ->
    C_ParserObjectEndCallback
wrap_ParserObjectEndCallback :: forall a.
GObject a =>
(a -> ParserObjectEndCallback) -> C_ParserObjectEndCallback
wrap_ParserObjectEndCallback a -> ParserObjectEndCallback
gi'cb Ptr Parser
gi'selfPtr Ptr Object
object Ptr ()
_ = do
    Ptr Object -> ParserObjectEndCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Object
object (ParserObjectEndCallback -> IO ())
-> ParserObjectEndCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \Object
object' -> do
        Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> ParserObjectEndCallback
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self)  Object
object'


-- | Connect a signal handler for the [objectEnd](#signal:objectEnd) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #objectEnd callback
-- @
-- 
-- 
onParserObjectEnd :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserObjectEndCallback) -> m SignalHandlerId
onParserObjectEnd :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => ParserObjectEndCallback) -> m SignalHandlerId
onParserObjectEnd a
obj (?self::a) => ParserObjectEndCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserObjectEndCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserObjectEndCallback
ParserObjectEndCallback
cb
    let wrapped' :: C_ParserObjectEndCallback
wrapped' = (a -> ParserObjectEndCallback) -> C_ParserObjectEndCallback
forall a.
GObject a =>
(a -> ParserObjectEndCallback) -> C_ParserObjectEndCallback
wrap_ParserObjectEndCallback a -> ParserObjectEndCallback
wrapped
    FunPtr C_ParserObjectEndCallback
wrapped'' <- C_ParserObjectEndCallback -> IO (FunPtr C_ParserObjectEndCallback)
mk_ParserObjectEndCallback C_ParserObjectEndCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserObjectEndCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"object-end" FunPtr C_ParserObjectEndCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [objectEnd](#signal:objectEnd) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #objectEnd callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserObjectEnd :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserObjectEndCallback) -> m SignalHandlerId
afterParserObjectEnd :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => ParserObjectEndCallback) -> m SignalHandlerId
afterParserObjectEnd a
obj (?self::a) => ParserObjectEndCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserObjectEndCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserObjectEndCallback
ParserObjectEndCallback
cb
    let wrapped' :: C_ParserObjectEndCallback
wrapped' = (a -> ParserObjectEndCallback) -> C_ParserObjectEndCallback
forall a.
GObject a =>
(a -> ParserObjectEndCallback) -> C_ParserObjectEndCallback
wrap_ParserObjectEndCallback a -> ParserObjectEndCallback
wrapped
    FunPtr C_ParserObjectEndCallback
wrapped'' <- C_ParserObjectEndCallback -> IO (FunPtr C_ParserObjectEndCallback)
mk_ParserObjectEndCallback C_ParserObjectEndCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserObjectEndCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"object-end" FunPtr C_ParserObjectEndCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserObjectEndSignalInfo
instance SignalInfo ParserObjectEndSignalInfo where
    type HaskellCallbackType ParserObjectEndSignalInfo = ParserObjectEndCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserObjectEndCallback cb
        cb'' <- mk_ParserObjectEndCallback cb'
        connectSignalFunPtr obj "object-end" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::object-end"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:objectEnd"})

#endif

-- signal Parser::object-member
-- | The @::object-member@ signal is emitted each time a parser
-- has successfully parsed a single member of a JSON object
type ParserObjectMemberCallback =
    Json.Object.Object
    -- ^ /@object@/: the JSON object being parsed
    -> T.Text
    -- ^ /@memberName@/: the name of the newly parsed member
    -> IO ()

type C_ParserObjectMemberCallback =
    Ptr Parser ->                           -- object
    Ptr Json.Object.Object ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserObjectMemberCallback`.
foreign import ccall "wrapper"
    mk_ParserObjectMemberCallback :: C_ParserObjectMemberCallback -> IO (FunPtr C_ParserObjectMemberCallback)

wrap_ParserObjectMemberCallback :: 
    GObject a => (a -> ParserObjectMemberCallback) ->
    C_ParserObjectMemberCallback
wrap_ParserObjectMemberCallback :: forall a.
GObject a =>
(a -> ParserObjectMemberCallback) -> C_ParserObjectMemberCallback
wrap_ParserObjectMemberCallback a -> ParserObjectMemberCallback
gi'cb Ptr Parser
gi'selfPtr Ptr Object
object CString
memberName Ptr ()
_ = do
    Ptr Object -> ParserObjectEndCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Object
object (ParserObjectEndCallback -> IO ())
-> ParserObjectEndCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \Object
object' -> do
        Text
memberName' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
memberName
        Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> ParserObjectMemberCallback
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self)  Object
object' Text
memberName'


-- | Connect a signal handler for the [objectMember](#signal:objectMember) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #objectMember callback
-- @
-- 
-- 
onParserObjectMember :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserObjectMemberCallback) -> m SignalHandlerId
onParserObjectMember :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a
-> ((?self::a) => ParserObjectMemberCallback) -> m SignalHandlerId
onParserObjectMember a
obj (?self::a) => ParserObjectMemberCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserObjectMemberCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserObjectMemberCallback
ParserObjectMemberCallback
cb
    let wrapped' :: C_ParserObjectMemberCallback
wrapped' = (a -> ParserObjectMemberCallback) -> C_ParserObjectMemberCallback
forall a.
GObject a =>
(a -> ParserObjectMemberCallback) -> C_ParserObjectMemberCallback
wrap_ParserObjectMemberCallback a -> ParserObjectMemberCallback
wrapped
    FunPtr C_ParserObjectMemberCallback
wrapped'' <- C_ParserObjectMemberCallback
-> IO (FunPtr C_ParserObjectMemberCallback)
mk_ParserObjectMemberCallback C_ParserObjectMemberCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserObjectMemberCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"object-member" FunPtr C_ParserObjectMemberCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [objectMember](#signal:objectMember) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #objectMember callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserObjectMember :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserObjectMemberCallback) -> m SignalHandlerId
afterParserObjectMember :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a
-> ((?self::a) => ParserObjectMemberCallback) -> m SignalHandlerId
afterParserObjectMember a
obj (?self::a) => ParserObjectMemberCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ParserObjectMemberCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ParserObjectMemberCallback
ParserObjectMemberCallback
cb
    let wrapped' :: C_ParserObjectMemberCallback
wrapped' = (a -> ParserObjectMemberCallback) -> C_ParserObjectMemberCallback
forall a.
GObject a =>
(a -> ParserObjectMemberCallback) -> C_ParserObjectMemberCallback
wrap_ParserObjectMemberCallback a -> ParserObjectMemberCallback
wrapped
    FunPtr C_ParserObjectMemberCallback
wrapped'' <- C_ParserObjectMemberCallback
-> IO (FunPtr C_ParserObjectMemberCallback)
mk_ParserObjectMemberCallback C_ParserObjectMemberCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserObjectMemberCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"object-member" FunPtr C_ParserObjectMemberCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserObjectMemberSignalInfo
instance SignalInfo ParserObjectMemberSignalInfo where
    type HaskellCallbackType ParserObjectMemberSignalInfo = ParserObjectMemberCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserObjectMemberCallback cb
        cb'' <- mk_ParserObjectMemberCallback cb'
        connectSignalFunPtr obj "object-member" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::object-member"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:objectMember"})

#endif

-- signal Parser::object-start
-- | This signal is emitted each time a parser starts parsing a JSON object.
type ParserObjectStartCallback =
    IO ()

type C_ParserObjectStartCallback =
    Ptr Parser ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserObjectStartCallback`.
foreign import ccall "wrapper"
    mk_ParserObjectStartCallback :: C_ParserObjectStartCallback -> IO (FunPtr C_ParserObjectStartCallback)

wrap_ParserObjectStartCallback :: 
    GObject a => (a -> ParserObjectStartCallback) ->
    C_ParserObjectStartCallback
wrap_ParserObjectStartCallback :: forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserObjectStartCallback a -> IO ()
gi'cb Ptr Parser
gi'selfPtr Ptr ()
_ = do
    Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> IO ()
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self) 


-- | Connect a signal handler for the [objectStart](#signal:objectStart) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #objectStart callback
-- @
-- 
-- 
onParserObjectStart :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserObjectStartCallback) -> m SignalHandlerId
onParserObjectStart :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onParserObjectStart a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserObjectStartCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserObjectStartCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"object-start" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [objectStart](#signal:objectStart) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #objectStart callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserObjectStart :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserObjectStartCallback) -> m SignalHandlerId
afterParserObjectStart :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterParserObjectStart a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserObjectStartCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserObjectStartCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"object-start" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserObjectStartSignalInfo
instance SignalInfo ParserObjectStartSignalInfo where
    type HaskellCallbackType ParserObjectStartSignalInfo = ParserObjectStartCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserObjectStartCallback cb
        cb'' <- mk_ParserObjectStartCallback cb'
        connectSignalFunPtr obj "object-start" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::object-start"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:objectStart"})

#endif

-- signal Parser::parse-end
-- | This signal is emitted when a parser successfully finished parsing a
-- JSON data stream
type ParserParseEndCallback =
    IO ()

type C_ParserParseEndCallback =
    Ptr Parser ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserParseEndCallback`.
foreign import ccall "wrapper"
    mk_ParserParseEndCallback :: C_ParserParseEndCallback -> IO (FunPtr C_ParserParseEndCallback)

wrap_ParserParseEndCallback :: 
    GObject a => (a -> ParserParseEndCallback) ->
    C_ParserParseEndCallback
wrap_ParserParseEndCallback :: forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserParseEndCallback a -> IO ()
gi'cb Ptr Parser
gi'selfPtr Ptr ()
_ = do
    Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> IO ()
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self) 


-- | Connect a signal handler for the [parseEnd](#signal:parseEnd) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #parseEnd callback
-- @
-- 
-- 
onParserParseEnd :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserParseEndCallback) -> m SignalHandlerId
onParserParseEnd :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onParserParseEnd a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserParseEndCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserParseEndCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"parse-end" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [parseEnd](#signal:parseEnd) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #parseEnd callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserParseEnd :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserParseEndCallback) -> m SignalHandlerId
afterParserParseEnd :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterParserParseEnd a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserParseEndCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserParseEndCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"parse-end" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserParseEndSignalInfo
instance SignalInfo ParserParseEndSignalInfo where
    type HaskellCallbackType ParserParseEndSignalInfo = ParserParseEndCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserParseEndCallback cb
        cb'' <- mk_ParserParseEndCallback cb'
        connectSignalFunPtr obj "parse-end" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::parse-end"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:parseEnd"})

#endif

-- signal Parser::parse-start
-- | This signal is emitted when a parser starts parsing a JSON data stream.
type ParserParseStartCallback =
    IO ()

type C_ParserParseStartCallback =
    Ptr Parser ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ParserParseStartCallback`.
foreign import ccall "wrapper"
    mk_ParserParseStartCallback :: C_ParserParseStartCallback -> IO (FunPtr C_ParserParseStartCallback)

wrap_ParserParseStartCallback :: 
    GObject a => (a -> ParserParseStartCallback) ->
    C_ParserParseStartCallback
wrap_ParserParseStartCallback :: forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserParseStartCallback a -> IO ()
gi'cb Ptr Parser
gi'selfPtr Ptr ()
_ = do
    Ptr Parser -> (Parser -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Parser
gi'selfPtr ((Parser -> IO ()) -> IO ()) -> (Parser -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Parser
gi'self -> a -> IO ()
gi'cb (Parser -> a
Coerce.coerce Parser
gi'self) 


-- | Connect a signal handler for the [parseStart](#signal:parseStart) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' parser #parseStart callback
-- @
-- 
-- 
onParserParseStart :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserParseStartCallback) -> m SignalHandlerId
onParserParseStart :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onParserParseStart a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserParseStartCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserParseStartCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"parse-start" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [parseStart](#signal:parseStart) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' parser #parseStart callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterParserParseStart :: (IsParser a, MonadIO m) => a -> ((?self :: a) => ParserParseStartCallback) -> m SignalHandlerId
afterParserParseStart :: forall a (m :: * -> *).
(IsParser a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterParserParseStart a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ParserArrayStartCallback
wrapped' = (a -> IO ()) -> C_ParserArrayStartCallback
forall a. GObject a => (a -> IO ()) -> C_ParserArrayStartCallback
wrap_ParserParseStartCallback a -> IO ()
wrapped
    FunPtr C_ParserArrayStartCallback
wrapped'' <- C_ParserArrayStartCallback
-> IO (FunPtr C_ParserArrayStartCallback)
mk_ParserParseStartCallback C_ParserArrayStartCallback
wrapped'
    a
-> Text
-> FunPtr C_ParserArrayStartCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"parse-start" FunPtr C_ParserArrayStartCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ParserParseStartSignalInfo
instance SignalInfo ParserParseStartSignalInfo where
    type HaskellCallbackType ParserParseStartSignalInfo = ParserParseStartCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ParserParseStartCallback cb
        cb'' <- mk_ParserParseStartCallback cb'
        connectSignalFunPtr obj "parse-start" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser::parse-start"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:signal:parseStart"})

#endif

-- VVV Prop "immutable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@immutable@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' parser #immutable
-- @
getParserImmutable :: (MonadIO m, IsParser o) => o -> m Bool
getParserImmutable :: forall (m :: * -> *) o. (MonadIO m, IsParser o) => o -> m Bool
getParserImmutable o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"immutable"

-- | Construct a `GValueConstruct` with valid value for the “@immutable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructParserImmutable :: (IsParser o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructParserImmutable :: forall o (m :: * -> *).
(IsParser o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructParserImmutable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"immutable" Bool
val

#if defined(ENABLE_OVERLOADING)
data ParserImmutablePropertyInfo
instance AttrInfo ParserImmutablePropertyInfo where
    type AttrAllowedOps ParserImmutablePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ParserImmutablePropertyInfo = IsParser
    type AttrSetTypeConstraint ParserImmutablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ParserImmutablePropertyInfo = (~) Bool
    type AttrTransferType ParserImmutablePropertyInfo = Bool
    type AttrGetType ParserImmutablePropertyInfo = Bool
    type AttrLabel ParserImmutablePropertyInfo = "immutable"
    type AttrOrigin ParserImmutablePropertyInfo = Parser
    attrGet = getParserImmutable
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructParserImmutable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.immutable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#g:attr:immutable"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Parser
type instance O.AttributeList Parser = ParserAttributeList
type ParserAttributeList = ('[ '("immutable", ParserImmutablePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
parserImmutable :: AttrLabelProxy "immutable"
parserImmutable = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Parser = ParserSignalList
type ParserSignalList = ('[ '("arrayElement", ParserArrayElementSignalInfo), '("arrayEnd", ParserArrayEndSignalInfo), '("arrayStart", ParserArrayStartSignalInfo), '("error", ParserErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("objectEnd", ParserObjectEndSignalInfo), '("objectMember", ParserObjectMemberSignalInfo), '("objectStart", ParserObjectStartSignalInfo), '("parseEnd", ParserParseEndSignalInfo), '("parseStart", ParserParseStartSignalInfo)] :: [(Symbol, *)])

#endif

-- method Parser::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Parser" })
-- throws : False
-- Skip return : False

foreign import ccall "json_parser_new" json_parser_new :: 
    IO (Ptr Parser)

-- | Creates a new JSON parser.
-- 
-- You can use the @JsonParser@ to load a JSON stream from either a file or a
-- buffer and then walk the hierarchy using the data types API.
parserNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Parser
    -- ^ __Returns:__ the newly created parser
parserNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Parser
parserNew  = IO Parser -> m Parser
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Parser -> m Parser) -> IO Parser -> m Parser
forall a b. (a -> b) -> a -> b
$ do
    Ptr Parser
result <- IO (Ptr Parser)
json_parser_new
    Text -> Ptr Parser -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"parserNew" Ptr Parser
result
    Parser
result' <- ((ManagedPtr Parser -> Parser) -> Ptr Parser -> IO Parser
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Parser -> Parser
Parser) Ptr Parser
result
    Parser -> IO Parser
forall (m :: * -> *) a. Monad m => a -> m a
return Parser
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Parser::new_immutable
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Parser" })
-- throws : False
-- Skip return : False

foreign import ccall "json_parser_new_immutable" json_parser_new_immutable :: 
    IO (Ptr Parser)

-- | Creates a new parser instance with its [property/@json@/.Parser:immutable]
-- property set to @TRUE@ to create immutable output trees.
-- 
-- /Since: 1.2/
parserNewImmutable ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Parser
    -- ^ __Returns:__ the newly created parser
parserNewImmutable :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Parser
parserNewImmutable  = IO Parser -> m Parser
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Parser -> m Parser) -> IO Parser -> m Parser
forall a b. (a -> b) -> a -> b
$ do
    Ptr Parser
result <- IO (Ptr Parser)
json_parser_new_immutable
    Text -> Ptr Parser -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"parserNewImmutable" Ptr Parser
result
    Parser
result' <- ((ManagedPtr Parser -> Parser) -> Ptr Parser -> IO Parser
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Parser -> Parser
Parser) Ptr Parser
result
    Parser -> IO Parser
forall (m :: * -> *) a. Monad m => a -> m a
return Parser
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Parser::get_current_line
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , 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 "json_parser_get_current_line" json_parser_get_current_line :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    IO Word32

-- | Retrieves the line currently parsed, starting from 1.
-- 
-- This function has defined behaviour only while parsing; calling this
-- function from outside the signal handlers emitted by the parser will
-- yield 0.
parserGetCurrentLine ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> m Word32
    -- ^ __Returns:__ the currently parsed line, or 0.
parserGetCurrentLine :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> m Word32
parserGetCurrentLine a
parser = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Word32
result <- Ptr Parser -> IO Word32
json_parser_get_current_line Ptr Parser
parser'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ParserGetCurrentLineMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsParser a) => O.OverloadedMethod ParserGetCurrentLineMethodInfo a signature where
    overloadedMethod = parserGetCurrentLine

instance O.OverloadedMethodInfo ParserGetCurrentLineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserGetCurrentLine",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserGetCurrentLine"
        })


#endif

-- method Parser::get_current_pos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , 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 "json_parser_get_current_pos" json_parser_get_current_pos :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    IO Word32

-- | Retrieves the current position inside the current line, starting
-- from 0.
-- 
-- This function has defined behaviour only while parsing; calling this
-- function from outside the signal handlers emitted by the parser will
-- yield 0.
parserGetCurrentPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> m Word32
    -- ^ __Returns:__ the position in the current line, or 0.
parserGetCurrentPos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> m Word32
parserGetCurrentPos a
parser = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Word32
result <- Ptr Parser -> IO Word32
json_parser_get_current_pos Ptr Parser
parser'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ParserGetCurrentPosMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsParser a) => O.OverloadedMethod ParserGetCurrentPosMethodInfo a signature where
    overloadedMethod = parserGetCurrentPos

instance O.OverloadedMethodInfo ParserGetCurrentPosMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserGetCurrentPos",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserGetCurrentPos"
        })


#endif

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

foreign import ccall "json_parser_get_root" json_parser_get_root :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    IO (Ptr Json.Node.Node)

-- | Retrieves the top level node from the parsed JSON stream.
-- 
-- If the parser input was an empty string, or if parsing failed, the root
-- will be @NULL@. It will also be @NULL@ if it has been stolen using
-- [method/@json@/.Parser.steal_root].
parserGetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> m (Maybe Json.Node.Node)
    -- ^ __Returns:__ the root node.
parserGetRoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> m (Maybe Node)
parserGetRoot a
parser = IO (Maybe Node) -> m (Maybe Node)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Node) -> m (Maybe Node))
-> IO (Maybe Node) -> m (Maybe Node)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Ptr Node
result <- Ptr Parser -> IO (Ptr Node)
json_parser_get_root Ptr Parser
parser'
    Maybe Node
maybeResult <- Ptr Node -> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Node
result ((Ptr Node -> IO Node) -> IO (Maybe Node))
-> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. (a -> b) -> a -> b
$ \Ptr Node
result' -> do
        Node
result'' <- ((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
result'
        Node -> IO Node
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
    Maybe Node -> IO (Maybe Node)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
maybeResult

#if defined(ENABLE_OVERLOADING)
data ParserGetRootMethodInfo
instance (signature ~ (m (Maybe Json.Node.Node)), MonadIO m, IsParser a) => O.OverloadedMethod ParserGetRootMethodInfo a signature where
    overloadedMethod = parserGetRoot

instance O.OverloadedMethodInfo ParserGetRootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserGetRoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserGetRoot"
        })


#endif

-- method Parser::has_assignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "variable_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the variable name" , 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 "json_parser_has_assignment" json_parser_has_assignment :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    Ptr CString ->                          -- variable_name : TBasicType TUTF8
    IO CInt

-- | A JSON data stream might sometimes contain an assignment, like:
-- 
-- \`\`@
-- var _json_data = { \"member_name\" : [ ...
-- @\`@
-- 
-- even though it would technically constitute a violation of the RFC.
-- 
-- @JsonParser@ will ignore the left hand identifier and parse the right
-- hand value of the assignment. @JsonParser\` will record, though, the
-- existence of the assignment in the data stream and the variable name
-- used.
-- 
-- /Since: 0.4/
parserHasAssignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> m ((Bool, T.Text))
    -- ^ __Returns:__ @TRUE@ if there was an assignment, and @FALSE@ otherwise
parserHasAssignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> m (Bool, Text)
parserHasAssignment a
parser = IO (Bool, Text) -> m (Bool, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text) -> m (Bool, Text))
-> IO (Bool, Text) -> m (Bool, Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Ptr CString
variableName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    CInt
result <- Ptr Parser -> Ptr CString -> IO CInt
json_parser_has_assignment Ptr Parser
parser' Ptr CString
variableName
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CString
variableName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
variableName
    Text
variableName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
variableName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
variableName
    (Bool, Text) -> IO (Bool, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
variableName'')

#if defined(ENABLE_OVERLOADING)
data ParserHasAssignmentMethodInfo
instance (signature ~ (m ((Bool, T.Text))), MonadIO m, IsParser a) => O.OverloadedMethod ParserHasAssignmentMethodInfo a signature where
    overloadedMethod = parserHasAssignment

instance O.OverloadedMethodInfo ParserHasAssignmentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserHasAssignment",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserHasAssignment"
        })


#endif

-- method Parser::load_from_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the buffer to parse"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the length of the buffer, or -1 if it is `NUL` terminated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "json_parser_load_from_data" json_parser_load_from_data :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    CString ->                              -- data : TBasicType TUTF8
    Int64 ->                                -- length : TBasicType TInt64
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Loads a JSON stream from a buffer and parses it.
-- 
-- You can call this function multiple times with the same parser, but the
-- contents of the parser will be destroyed each time.
parserLoadFromData ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> T.Text
    -- ^ /@data@/: the buffer to parse
    -> Int64
    -- ^ /@length@/: the length of the buffer, or -1 if it is @NUL@ terminated
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
parserLoadFromData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> Text -> Int64 -> m ()
parserLoadFromData a
parser Text
data_ Int64
length_ = 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 Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    CString
data_' <- Text -> IO CString
textToCString Text
data_
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Parser -> CString -> Int64 -> Ptr (Ptr GError) -> IO CInt
json_parser_load_from_data Ptr Parser
parser' CString
data_' Int64
length_
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
     )

#if defined(ENABLE_OVERLOADING)
data ParserLoadFromDataMethodInfo
instance (signature ~ (T.Text -> Int64 -> m ()), MonadIO m, IsParser a) => O.OverloadedMethod ParserLoadFromDataMethodInfo a signature where
    overloadedMethod = parserLoadFromData

instance O.OverloadedMethodInfo ParserLoadFromDataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserLoadFromData",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserLoadFromData"
        })


#endif

-- method Parser::load_from_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TFileName
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path for the file to parse"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "json_parser_load_from_file" json_parser_load_from_file :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    CString ->                              -- filename : TBasicType TFileName
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Loads a JSON stream from the content of @filename@ and parses it.
-- 
-- If the file is large or shared between processes,
-- [method/@json@/.Parser.load_from_mapped_file] may be a more efficient
-- way to load it.
-- 
-- See also: [method/@json@/.Parser.load_from_data]
parserLoadFromFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> [Char]
    -- ^ /@filename@/: the path for the file to parse
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
parserLoadFromFile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> String -> m ()
parserLoadFromFile a
parser String
filename = 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 Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    CString
filename' <- String -> IO CString
stringToCString String
filename
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Parser -> CString -> Ptr (Ptr GError) -> IO CInt
json_parser_load_from_file Ptr Parser
parser' CString
filename'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
     )

#if defined(ENABLE_OVERLOADING)
data ParserLoadFromFileMethodInfo
instance (signature ~ ([Char] -> m ()), MonadIO m, IsParser a) => O.OverloadedMethod ParserLoadFromFileMethodInfo a signature where
    overloadedMethod = parserLoadFromFile

instance O.OverloadedMethodInfo ParserLoadFromFileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserLoadFromFile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserLoadFromFile"
        })


#endif

-- method Parser::load_from_mapped_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TFileName
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the path for the file to parse"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "json_parser_load_from_mapped_file" json_parser_load_from_mapped_file :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    CString ->                              -- filename : TBasicType TFileName
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Loads a JSON stream from the content of @filename@ and parses it.
-- 
-- Unlike [method/@json@/.Parser.load_from_file], @filename@ will be memory
-- mapped as read-only and parsed. @filename@ will be unmapped before this
-- function returns.
-- 
-- If mapping or reading the file fails, a @G_FILE_ERROR@ will be returned.
-- 
-- /Since: 1.6/
parserLoadFromMappedFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> [Char]
    -- ^ /@filename@/: the path for the file to parse
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
parserLoadFromMappedFile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> String -> m ()
parserLoadFromMappedFile a
parser String
filename = 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 Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    CString
filename' <- String -> IO CString
stringToCString String
filename
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Parser -> CString -> Ptr (Ptr GError) -> IO CInt
json_parser_load_from_mapped_file Ptr Parser
parser' CString
filename'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
     )

#if defined(ENABLE_OVERLOADING)
data ParserLoadFromMappedFileMethodInfo
instance (signature ~ ([Char] -> m ()), MonadIO m, IsParser a) => O.OverloadedMethod ParserLoadFromMappedFileMethodInfo a signature where
    overloadedMethod = parserLoadFromMappedFile

instance O.OverloadedMethodInfo ParserLoadFromMappedFileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserLoadFromMappedFile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserLoadFromMappedFile"
        })


#endif

-- method Parser::load_from_stream
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the input stream with the JSON data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "json_parser_load_from_stream" json_parser_load_from_stream :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Loads the contents of an input stream and parses them.
-- 
-- If @cancellable@ is not @NULL@, then the operation can be cancelled by
-- triggering the cancellable object from another thread. If the
-- operation was cancelled, @G_IO_ERROR_CANCELLED@ will be set
-- on the given @error@.
-- 
-- /Since: 0.12/
parserLoadFromStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@parser@/: a parser
    -> b
    -- ^ /@stream@/: the input stream with the JSON data
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
parserLoadFromStream :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsParser a, IsInputStream b,
 IsCancellable c) =>
a -> b -> Maybe c -> m ()
parserLoadFromStream a
parser b
stream Maybe c
cancellable = 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 Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Ptr InputStream
stream' <- b -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
stream
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Parser
-> Ptr InputStream
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
json_parser_load_from_stream Ptr Parser
parser' Ptr InputStream
stream' Ptr Cancellable
maybeCancellable
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
stream
        Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ParserLoadFromStreamMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsParser a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod ParserLoadFromStreamMethodInfo a signature where
    overloadedMethod = parserLoadFromStream

instance O.OverloadedMethodInfo ParserLoadFromStreamMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserLoadFromStream",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserLoadFromStream"
        })


#endif

-- method Parser::load_from_stream_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the input stream with the JSON data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the function to call when the request is satisfied"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "json_parser_load_from_stream_async" json_parser_load_from_stream_async :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Asynchronously reads the contents of a stream.
-- 
-- For more details, see [method/@json@/.Parser.load_from_stream], which is the
-- synchronous version of this call.
-- 
-- When the operation is finished, /@callback@/ will be called. You should
-- then call [method/@json@/.Parser.load_from_stream_finish] to get the result
-- of the operation.
-- 
-- /Since: 0.12/
parserLoadFromStreamAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@parser@/: a parser
    -> b
    -- ^ /@stream@/: the input stream with the JSON data
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: the function to call when the request is satisfied
    -> m ()
parserLoadFromStreamAsync :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsParser a, IsInputStream b,
 IsCancellable c) =>
a -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()
parserLoadFromStreamAsync a
parser b
stream Maybe c
cancellable Maybe AsyncReadyCallback
callback = 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 Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Ptr InputStream
stream' <- b -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
stream
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Parser
-> Ptr InputStream
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> ParserErrorCallback
json_parser_load_from_stream_async Ptr Parser
parser' Ptr InputStream
stream' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
stream
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ParserLoadFromStreamAsyncMethodInfo
instance (signature ~ (b -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsParser a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod ParserLoadFromStreamAsyncMethodInfo a signature where
    overloadedMethod = parserLoadFromStreamAsync

instance O.OverloadedMethodInfo ParserLoadFromStreamAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserLoadFromStreamAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserLoadFromStreamAsync"
        })


#endif

-- method Parser::load_from_stream_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parser"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Parser" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parser" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the result of the asynchronous operation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "json_parser_load_from_stream_finish" json_parser_load_from_stream_finish :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Finishes an asynchronous stream loading started with
-- [method/@json@/.Parser.load_from_stream_async].
-- 
-- /Since: 0.12/
parserLoadFromStreamFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@parser@/: a parser
    -> b
    -- ^ /@result@/: the result of the asynchronous operation
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
parserLoadFromStreamFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsParser a, IsAsyncResult b) =>
a -> b -> m ()
parserLoadFromStreamFinish a
parser b
result_ = 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 Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Parser -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
json_parser_load_from_stream_finish Ptr Parser
parser' Ptr AsyncResult
result_'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ParserLoadFromStreamFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsParser a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod ParserLoadFromStreamFinishMethodInfo a signature where
    overloadedMethod = parserLoadFromStreamFinish

instance O.OverloadedMethodInfo ParserLoadFromStreamFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserLoadFromStreamFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserLoadFromStreamFinish"
        })


#endif

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

foreign import ccall "json_parser_steal_root" json_parser_steal_root :: 
    Ptr Parser ->                           -- parser : TInterface (Name {namespace = "Json", name = "Parser"})
    IO (Ptr Json.Node.Node)

-- | Steals the top level node from the parsed JSON stream.
-- 
-- This will be @NULL@ in the same situations as [method/@json@/.Parser.get_root]
-- return @NULL@.
-- 
-- /Since: 1.4/
parserStealRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
    a
    -- ^ /@parser@/: a parser
    -> m (Maybe Json.Node.Node)
    -- ^ __Returns:__ the root node
parserStealRoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsParser a) =>
a -> m (Maybe Node)
parserStealRoot a
parser = IO (Maybe Node) -> m (Maybe Node)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Node) -> m (Maybe Node))
-> IO (Maybe Node) -> m (Maybe Node)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Parser
parser' <- a -> IO (Ptr Parser)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parser
    Ptr Node
result <- Ptr Parser -> IO (Ptr Node)
json_parser_steal_root Ptr Parser
parser'
    Maybe Node
maybeResult <- Ptr Node -> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Node
result ((Ptr Node -> IO Node) -> IO (Maybe Node))
-> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. (a -> b) -> a -> b
$ \Ptr Node
result' -> do
        Node
result'' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
result'
        Node -> IO Node
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parser
    Maybe Node -> IO (Maybe Node)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
maybeResult

#if defined(ENABLE_OVERLOADING)
data ParserStealRootMethodInfo
instance (signature ~ (m (Maybe Json.Node.Node)), MonadIO m, IsParser a) => O.OverloadedMethod ParserStealRootMethodInfo a signature where
    overloadedMethod = parserStealRoot

instance O.OverloadedMethodInfo ParserStealRootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Parser.parserStealRoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.2/docs/GI-Json-Objects-Parser.html#v:parserStealRoot"
        })


#endif