{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Json.Objects.Parser
(
Parser(..) ,
IsParser ,
toParser ,
#if defined(ENABLE_OVERLOADING)
ResolveParserMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ParserGetCurrentLineMethodInfo ,
#endif
parserGetCurrentLine ,
#if defined(ENABLE_OVERLOADING)
ParserGetCurrentPosMethodInfo ,
#endif
parserGetCurrentPos ,
#if defined(ENABLE_OVERLOADING)
ParserGetRootMethodInfo ,
#endif
parserGetRoot ,
#if defined(ENABLE_OVERLOADING)
ParserHasAssignmentMethodInfo ,
#endif
parserHasAssignment ,
#if defined(ENABLE_OVERLOADING)
ParserLoadFromDataMethodInfo ,
#endif
parserLoadFromData ,
#if defined(ENABLE_OVERLOADING)
ParserLoadFromFileMethodInfo ,
#endif
parserLoadFromFile ,
#if defined(ENABLE_OVERLOADING)
ParserLoadFromMappedFileMethodInfo ,
#endif
parserLoadFromMappedFile ,
#if defined(ENABLE_OVERLOADING)
ParserLoadFromStreamMethodInfo ,
#endif
parserLoadFromStream ,
#if defined(ENABLE_OVERLOADING)
ParserLoadFromStreamAsyncMethodInfo ,
#endif
parserLoadFromStreamAsync ,
#if defined(ENABLE_OVERLOADING)
ParserLoadFromStreamFinishMethodInfo ,
#endif
parserLoadFromStreamFinish ,
parserNew ,
parserNewImmutable ,
#if defined(ENABLE_OVERLOADING)
ParserStealRootMethodInfo ,
#endif
parserStealRoot ,
#if defined(ENABLE_OVERLOADING)
ParserImmutablePropertyInfo ,
#endif
constructParserImmutable ,
getParserImmutable ,
#if defined(ENABLE_OVERLOADING)
parserImmutable ,
#endif
ParserArrayElementCallback ,
#if defined(ENABLE_OVERLOADING)
ParserArrayElementSignalInfo ,
#endif
afterParserArrayElement ,
onParserArrayElement ,
ParserArrayEndCallback ,
#if defined(ENABLE_OVERLOADING)
ParserArrayEndSignalInfo ,
#endif
afterParserArrayEnd ,
onParserArrayEnd ,
ParserArrayStartCallback ,
#if defined(ENABLE_OVERLOADING)
ParserArrayStartSignalInfo ,
#endif
afterParserArrayStart ,
onParserArrayStart ,
ParserErrorCallback ,
#if defined(ENABLE_OVERLOADING)
ParserErrorSignalInfo ,
#endif
afterParserError ,
onParserError ,
ParserObjectEndCallback ,
#if defined(ENABLE_OVERLOADING)
ParserObjectEndSignalInfo ,
#endif
afterParserObjectEnd ,
onParserObjectEnd ,
ParserObjectMemberCallback ,
#if defined(ENABLE_OVERLOADING)
ParserObjectMemberSignalInfo ,
#endif
afterParserObjectMember ,
onParserObjectMember ,
ParserObjectStartCallback ,
#if defined(ENABLE_OVERLOADING)
ParserObjectStartSignalInfo ,
#endif
afterParserObjectStart ,
onParserObjectStart ,
ParserParseEndCallback ,
#if defined(ENABLE_OVERLOADING)
ParserParseEndSignalInfo ,
#endif
afterParserParseEnd ,
onParserParseEnd ,
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
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
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]
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
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
type ParserArrayElementCallback =
Json.Array.Array
-> Int32
-> IO ()
type C_ParserArrayElementCallback =
Ptr Parser ->
Ptr Json.Array.Array ->
Int32 ->
Ptr () ->
IO ()
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_
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
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
type ParserArrayEndCallback =
Json.Array.Array
-> IO ()
type C_ParserArrayEndCallback =
Ptr Parser ->
Ptr Json.Array.Array ->
Ptr () ->
IO ()
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'
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
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
type ParserArrayStartCallback =
IO ()
type C_ParserArrayStartCallback =
Ptr Parser ->
Ptr () ->
IO ()
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)
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
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
type ParserErrorCallback =
Ptr ()
-> IO ()
type C_ParserErrorCallback =
Ptr Parser ->
Ptr () ->
Ptr () ->
IO ()
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_
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
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
type ParserObjectEndCallback =
Json.Object.Object
-> IO ()
type C_ParserObjectEndCallback =
Ptr Parser ->
Ptr Json.Object.Object ->
Ptr () ->
IO ()
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'
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
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
type ParserObjectMemberCallback =
Json.Object.Object
-> T.Text
-> IO ()
type C_ParserObjectMemberCallback =
Ptr Parser ->
Ptr Json.Object.Object ->
CString ->
Ptr () ->
IO ()
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'
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
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
type ParserObjectStartCallback =
IO ()
type C_ParserObjectStartCallback =
Ptr Parser ->
Ptr () ->
IO ()
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)
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
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
type ParserParseEndCallback =
IO ()
type C_ParserParseEndCallback =
Ptr Parser ->
Ptr () ->
IO ()
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)
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
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
type ParserParseStartCallback =
IO ()
type C_ParserParseStartCallback =
Ptr Parser ->
Ptr () ->
IO ()
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)
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
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
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"
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
foreign import ccall "json_parser_new" json_parser_new ::
IO (Ptr Parser)
parserNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m 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
foreign import ccall "json_parser_new_immutable" json_parser_new_immutable ::
IO (Ptr Parser)
parserNewImmutable ::
(B.CallStack.HasCallStack, MonadIO m) =>
m 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
foreign import ccall "json_parser_get_current_line" json_parser_get_current_line ::
Ptr Parser ->
IO Word32
parserGetCurrentLine ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> m Word32
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
foreign import ccall "json_parser_get_current_pos" json_parser_get_current_pos ::
Ptr Parser ->
IO Word32
parserGetCurrentPos ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> m Word32
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
foreign import ccall "json_parser_get_root" json_parser_get_root ::
Ptr Parser ->
IO (Ptr Json.Node.Node)
parserGetRoot ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> m (Maybe Json.Node.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
foreign import ccall "json_parser_has_assignment" json_parser_has_assignment ::
Ptr Parser ->
Ptr CString ->
IO CInt
parserHasAssignment ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> m ((Bool, T.Text))
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
foreign import ccall "json_parser_load_from_data" json_parser_load_from_data ::
Ptr Parser ->
CString ->
Int64 ->
Ptr (Ptr GError) ->
IO CInt
parserLoadFromData ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> T.Text
-> Int64
-> m ()
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
foreign import ccall "json_parser_load_from_file" json_parser_load_from_file ::
Ptr Parser ->
CString ->
Ptr (Ptr GError) ->
IO CInt
parserLoadFromFile ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> [Char]
-> m ()
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
foreign import ccall "json_parser_load_from_mapped_file" json_parser_load_from_mapped_file ::
Ptr Parser ->
CString ->
Ptr (Ptr GError) ->
IO CInt
parserLoadFromMappedFile ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> [Char]
-> m ()
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
foreign import ccall "json_parser_load_from_stream" json_parser_load_from_stream ::
Ptr Parser ->
Ptr Gio.InputStream.InputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
parserLoadFromStream ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
a
-> b
-> Maybe (c)
-> m ()
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
foreign import ccall "json_parser_load_from_stream_async" json_parser_load_from_stream_async ::
Ptr Parser ->
Ptr Gio.InputStream.InputStream ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
parserLoadFromStreamAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
a
-> b
-> Maybe (c)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> 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
foreign import ccall "json_parser_load_from_stream_finish" json_parser_load_from_stream_finish ::
Ptr Parser ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO CInt
parserLoadFromStreamFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ()
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
foreign import ccall "json_parser_steal_root" json_parser_steal_root ::
Ptr Parser ->
IO (Ptr Json.Node.Node)
parserStealRoot ::
(B.CallStack.HasCallStack, MonadIO m, IsParser a) =>
a
-> m (Maybe Json.Node.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