{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Json.Objects.Reader
(
Reader(..) ,
IsReader ,
toReader ,
#if defined(ENABLE_OVERLOADING)
ResolveReaderMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ReaderCountElementsMethodInfo ,
#endif
readerCountElements ,
#if defined(ENABLE_OVERLOADING)
ReaderCountMembersMethodInfo ,
#endif
readerCountMembers ,
#if defined(ENABLE_OVERLOADING)
ReaderEndElementMethodInfo ,
#endif
readerEndElement ,
#if defined(ENABLE_OVERLOADING)
ReaderEndMemberMethodInfo ,
#endif
readerEndMember ,
#if defined(ENABLE_OVERLOADING)
ReaderGetBooleanValueMethodInfo ,
#endif
readerGetBooleanValue ,
#if defined(ENABLE_OVERLOADING)
ReaderGetDoubleValueMethodInfo ,
#endif
readerGetDoubleValue ,
#if defined(ENABLE_OVERLOADING)
ReaderGetErrorMethodInfo ,
#endif
readerGetError ,
#if defined(ENABLE_OVERLOADING)
ReaderGetIntValueMethodInfo ,
#endif
readerGetIntValue ,
#if defined(ENABLE_OVERLOADING)
ReaderGetMemberNameMethodInfo ,
#endif
readerGetMemberName ,
#if defined(ENABLE_OVERLOADING)
ReaderGetNullValueMethodInfo ,
#endif
readerGetNullValue ,
#if defined(ENABLE_OVERLOADING)
ReaderGetStringValueMethodInfo ,
#endif
readerGetStringValue ,
#if defined(ENABLE_OVERLOADING)
ReaderGetValueMethodInfo ,
#endif
readerGetValue ,
#if defined(ENABLE_OVERLOADING)
ReaderIsArrayMethodInfo ,
#endif
readerIsArray ,
#if defined(ENABLE_OVERLOADING)
ReaderIsObjectMethodInfo ,
#endif
readerIsObject ,
#if defined(ENABLE_OVERLOADING)
ReaderIsValueMethodInfo ,
#endif
readerIsValue ,
#if defined(ENABLE_OVERLOADING)
ReaderListMembersMethodInfo ,
#endif
readerListMembers ,
readerNew ,
#if defined(ENABLE_OVERLOADING)
ReaderReadElementMethodInfo ,
#endif
readerReadElement ,
#if defined(ENABLE_OVERLOADING)
ReaderReadMemberMethodInfo ,
#endif
readerReadMember ,
#if defined(ENABLE_OVERLOADING)
ReaderSetRootMethodInfo ,
#endif
readerSetRoot ,
#if defined(ENABLE_OVERLOADING)
ReaderRootPropertyInfo ,
#endif
clearReaderRoot ,
constructReaderRoot ,
getReaderRoot ,
#if defined(ENABLE_OVERLOADING)
readerRoot ,
#endif
setReaderRoot ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.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 {-# SOURCE #-} qualified GI.Json.Structs.Node as Json.Node
newtype Reader = Reader (SP.ManagedPtr Reader)
deriving (Reader -> Reader -> Bool
(Reader -> Reader -> Bool)
-> (Reader -> Reader -> Bool) -> Eq Reader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Reader -> Reader -> Bool
== :: Reader -> Reader -> Bool
$c/= :: Reader -> Reader -> Bool
/= :: Reader -> Reader -> Bool
Eq)
instance SP.ManagedPtrNewtype Reader where
toManagedPtr :: Reader -> ManagedPtr Reader
toManagedPtr (Reader ManagedPtr Reader
p) = ManagedPtr Reader
p
foreign import ccall "json_reader_get_type"
c_json_reader_get_type :: IO B.Types.GType
instance B.Types.TypedObject Reader where
glibType :: IO GType
glibType = IO GType
c_json_reader_get_type
instance B.Types.GObject Reader
class (SP.GObject o, O.IsDescendantOf Reader o) => IsReader o
instance (SP.GObject o, O.IsDescendantOf Reader o) => IsReader o
instance O.HasParentTypes Reader
type instance O.ParentTypes Reader = '[GObject.Object.Object]
toReader :: (MIO.MonadIO m, IsReader o) => o -> m Reader
toReader :: forall (m :: * -> *) o. (MonadIO m, IsReader o) => o -> m Reader
toReader = IO Reader -> m Reader
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Reader -> m Reader) -> (o -> IO Reader) -> o -> m Reader
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Reader -> Reader) -> o -> IO Reader
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Reader -> Reader
Reader
instance B.GValue.IsGValue (Maybe Reader) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_json_reader_get_type
gvalueSet_ :: Ptr GValue -> Maybe Reader -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Reader
P.Nothing = Ptr GValue -> Ptr Reader -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Reader
forall a. Ptr a
FP.nullPtr :: FP.Ptr Reader)
gvalueSet_ Ptr GValue
gv (P.Just Reader
obj) = Reader -> (Ptr Reader -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Reader
obj (Ptr GValue -> Ptr Reader -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Reader)
gvalueGet_ Ptr GValue
gv = do
Ptr Reader
ptr <- Ptr GValue -> IO (Ptr Reader)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Reader)
if Ptr Reader
ptr Ptr Reader -> Ptr Reader -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Reader
forall a. Ptr a
FP.nullPtr
then Reader -> Maybe Reader
forall a. a -> Maybe a
P.Just (Reader -> Maybe Reader) -> IO Reader -> IO (Maybe Reader)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Reader -> Reader) -> Ptr Reader -> IO Reader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Reader -> Reader
Reader Ptr Reader
ptr
else Maybe Reader -> IO (Maybe Reader)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Reader
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveReaderMethod (t :: Symbol) (o :: *) :: * where
ResolveReaderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveReaderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveReaderMethod "countElements" o = ReaderCountElementsMethodInfo
ResolveReaderMethod "countMembers" o = ReaderCountMembersMethodInfo
ResolveReaderMethod "endElement" o = ReaderEndElementMethodInfo
ResolveReaderMethod "endMember" o = ReaderEndMemberMethodInfo
ResolveReaderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveReaderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveReaderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveReaderMethod "isArray" o = ReaderIsArrayMethodInfo
ResolveReaderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveReaderMethod "isObject" o = ReaderIsObjectMethodInfo
ResolveReaderMethod "isValue" o = ReaderIsValueMethodInfo
ResolveReaderMethod "listMembers" o = ReaderListMembersMethodInfo
ResolveReaderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveReaderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveReaderMethod "readElement" o = ReaderReadElementMethodInfo
ResolveReaderMethod "readMember" o = ReaderReadMemberMethodInfo
ResolveReaderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveReaderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveReaderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveReaderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveReaderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveReaderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveReaderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveReaderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveReaderMethod "getBooleanValue" o = ReaderGetBooleanValueMethodInfo
ResolveReaderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveReaderMethod "getDoubleValue" o = ReaderGetDoubleValueMethodInfo
ResolveReaderMethod "getError" o = ReaderGetErrorMethodInfo
ResolveReaderMethod "getIntValue" o = ReaderGetIntValueMethodInfo
ResolveReaderMethod "getMemberName" o = ReaderGetMemberNameMethodInfo
ResolveReaderMethod "getNullValue" o = ReaderGetNullValueMethodInfo
ResolveReaderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveReaderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveReaderMethod "getStringValue" o = ReaderGetStringValueMethodInfo
ResolveReaderMethod "getValue" o = ReaderGetValueMethodInfo
ResolveReaderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveReaderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveReaderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveReaderMethod "setRoot" o = ReaderSetRootMethodInfo
ResolveReaderMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveReaderMethod t Reader, O.OverloadedMethod info Reader p) => OL.IsLabel t (Reader -> 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 ~ ResolveReaderMethod t Reader, O.OverloadedMethod info Reader p, R.HasField t Reader p) => R.HasField t Reader p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveReaderMethod t Reader, O.OverloadedMethodInfo info Reader) => OL.IsLabel t (O.MethodProxy info Reader) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getReaderRoot :: (MonadIO m, IsReader o) => o -> m (Maybe Json.Node.Node)
getReaderRoot :: forall (m :: * -> *) o.
(MonadIO m, IsReader o) =>
o -> m (Maybe Node)
getReaderRoot o
obj = IO (Maybe Node) -> m (Maybe Node)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Node) -> m (Maybe Node))
-> IO (Maybe Node) -> m (Maybe Node)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Node -> Node) -> IO (Maybe Node)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"root" ManagedPtr Node -> Node
Json.Node.Node
setReaderRoot :: (MonadIO m, IsReader o) => o -> Json.Node.Node -> m ()
setReaderRoot :: forall (m :: * -> *) o.
(MonadIO m, IsReader o) =>
o -> Node -> m ()
setReaderRoot o
obj Node
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Node -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"root" (Node -> Maybe Node
forall a. a -> Maybe a
Just Node
val)
constructReaderRoot :: (IsReader o, MIO.MonadIO m) => Json.Node.Node -> m (GValueConstruct o)
constructReaderRoot :: forall o (m :: * -> *).
(IsReader o, MonadIO m) =>
Node -> m (GValueConstruct o)
constructReaderRoot Node
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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 -> Maybe Node -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"root" (Node -> Maybe Node
forall a. a -> Maybe a
P.Just Node
val)
clearReaderRoot :: (MonadIO m, IsReader o) => o -> m ()
clearReaderRoot :: forall (m :: * -> *) o. (MonadIO m, IsReader o) => o -> m ()
clearReaderRoot o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Node -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"root" (Maybe Node
forall a. Maybe a
Nothing :: Maybe Json.Node.Node)
#if defined(ENABLE_OVERLOADING)
data ReaderRootPropertyInfo
instance AttrInfo ReaderRootPropertyInfo where
type AttrAllowedOps ReaderRootPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ReaderRootPropertyInfo = IsReader
type AttrSetTypeConstraint ReaderRootPropertyInfo = (~) Json.Node.Node
type AttrTransferTypeConstraint ReaderRootPropertyInfo = (~) Json.Node.Node
type AttrTransferType ReaderRootPropertyInfo = Json.Node.Node
type AttrGetType ReaderRootPropertyInfo = (Maybe Json.Node.Node)
type AttrLabel ReaderRootPropertyInfo = "root"
type AttrOrigin ReaderRootPropertyInfo = Reader
attrGet = getReaderRoot
attrSet = setReaderRoot
attrTransfer _ v = do
return v
attrConstruct = constructReaderRoot
attrClear = clearReaderRoot
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.root"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#g:attr:root"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Reader
type instance O.AttributeList Reader = ReaderAttributeList
type ReaderAttributeList = ('[ '("root", ReaderRootPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
readerRoot :: AttrLabelProxy "root"
readerRoot = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Reader = ReaderSignalList
type ReaderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "json_reader_new" json_reader_new ::
Ptr Json.Node.Node ->
IO (Ptr Reader)
readerNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (Json.Node.Node)
-> m Reader
readerNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Node -> m Reader
readerNew Maybe Node
node = IO Reader -> m Reader
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Reader -> m Reader) -> IO Reader -> m Reader
forall a b. (a -> b) -> a -> b
$ do
Ptr Node
maybeNode <- case Maybe Node
node of
Maybe Node
Nothing -> Ptr Node -> IO (Ptr Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Node
forall a. Ptr a
nullPtr
Just Node
jNode -> do
Ptr Node
jNode' <- Node -> IO (Ptr Node)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
jNode
Ptr Node -> IO (Ptr Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Node
jNode'
Ptr Reader
result <- Ptr Node -> IO (Ptr Reader)
json_reader_new Ptr Node
maybeNode
Text -> Ptr Reader -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"readerNew" Ptr Reader
result
Reader
result' <- ((ManagedPtr Reader -> Reader) -> Ptr Reader -> IO Reader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Reader -> Reader
Reader) Ptr Reader
result
Maybe Node -> (Node -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Node
node Node -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Reader -> IO Reader
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Reader
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "json_reader_count_elements" json_reader_count_elements ::
Ptr Reader ->
IO Int32
readerCountElements ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Int32
readerCountElements :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Int32
readerCountElements a
reader = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Int32
result <- Ptr Reader -> IO Int32
json_reader_count_elements Ptr Reader
reader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data ReaderCountElementsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsReader a) => O.OverloadedMethod ReaderCountElementsMethodInfo a signature where
overloadedMethod = readerCountElements
instance O.OverloadedMethodInfo ReaderCountElementsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerCountElements",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerCountElements"
})
#endif
foreign import ccall "json_reader_count_members" json_reader_count_members ::
Ptr Reader ->
IO Int32
readerCountMembers ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Int32
readerCountMembers :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Int32
readerCountMembers a
reader = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Int32
result <- Ptr Reader -> IO Int32
json_reader_count_members Ptr Reader
reader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data ReaderCountMembersMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsReader a) => O.OverloadedMethod ReaderCountMembersMethodInfo a signature where
overloadedMethod = readerCountMembers
instance O.OverloadedMethodInfo ReaderCountMembersMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerCountMembers",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerCountMembers"
})
#endif
foreign import ccall "json_reader_end_element" json_reader_end_element ::
Ptr Reader ->
IO ()
readerEndElement ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m ()
readerEndElement :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m ()
readerEndElement a
reader = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Ptr Reader -> IO ()
json_reader_end_element Ptr Reader
reader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ReaderEndElementMethodInfo
instance (signature ~ (m ()), MonadIO m, IsReader a) => O.OverloadedMethod ReaderEndElementMethodInfo a signature where
overloadedMethod = readerEndElement
instance O.OverloadedMethodInfo ReaderEndElementMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerEndElement",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerEndElement"
})
#endif
foreign import ccall "json_reader_end_member" json_reader_end_member ::
Ptr Reader ->
IO ()
readerEndMember ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m ()
readerEndMember :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m ()
readerEndMember a
reader = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Ptr Reader -> IO ()
json_reader_end_member Ptr Reader
reader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ReaderEndMemberMethodInfo
instance (signature ~ (m ()), MonadIO m, IsReader a) => O.OverloadedMethod ReaderEndMemberMethodInfo a signature where
overloadedMethod = readerEndMember
instance O.OverloadedMethodInfo ReaderEndMemberMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerEndMember",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerEndMember"
})
#endif
foreign import ccall "json_reader_get_boolean_value" json_reader_get_boolean_value ::
Ptr Reader ->
IO CInt
readerGetBooleanValue ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Bool
readerGetBooleanValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Bool
readerGetBooleanValue a
reader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CInt
result <- Ptr Reader -> IO CInt
json_reader_get_boolean_value Ptr Reader
reader'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ReaderGetBooleanValueMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetBooleanValueMethodInfo a signature where
overloadedMethod = readerGetBooleanValue
instance O.OverloadedMethodInfo ReaderGetBooleanValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetBooleanValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetBooleanValue"
})
#endif
foreign import ccall "json_reader_get_double_value" json_reader_get_double_value ::
Ptr Reader ->
IO CDouble
readerGetDoubleValue ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Double
readerGetDoubleValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Double
readerGetDoubleValue a
reader = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CDouble
result <- Ptr Reader -> IO CDouble
json_reader_get_double_value Ptr Reader
reader'
let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'
#if defined(ENABLE_OVERLOADING)
data ReaderGetDoubleValueMethodInfo
instance (signature ~ (m Double), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetDoubleValueMethodInfo a signature where
overloadedMethod = readerGetDoubleValue
instance O.OverloadedMethodInfo ReaderGetDoubleValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetDoubleValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetDoubleValue"
})
#endif
foreign import ccall "json_reader_get_error" json_reader_get_error ::
Ptr Reader ->
IO (Ptr GError)
readerGetError ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m (Maybe GError)
readerGetError :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m (Maybe GError)
readerGetError a
reader = IO (Maybe GError) -> m (Maybe GError)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GError) -> m (Maybe GError))
-> IO (Maybe GError) -> m (Maybe GError)
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Ptr GError
result <- Ptr Reader -> IO (Ptr GError)
json_reader_get_error Ptr Reader
reader'
Maybe GError
maybeResult <- Ptr GError -> (Ptr GError -> IO GError) -> IO (Maybe GError)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GError
result ((Ptr GError -> IO GError) -> IO (Maybe GError))
-> (Ptr GError -> IO GError) -> IO (Maybe GError)
forall a b. (a -> b) -> a -> b
$ \Ptr GError
result' -> do
GError
result'' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GError -> GError
GError) Ptr GError
result'
GError -> IO GError
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GError
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Maybe GError -> IO (Maybe GError)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GError
maybeResult
#if defined(ENABLE_OVERLOADING)
data ReaderGetErrorMethodInfo
instance (signature ~ (m (Maybe GError)), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetErrorMethodInfo a signature where
overloadedMethod = readerGetError
instance O.OverloadedMethodInfo ReaderGetErrorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetError",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetError"
})
#endif
foreign import ccall "json_reader_get_int_value" json_reader_get_int_value ::
Ptr Reader ->
IO Int64
readerGetIntValue ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Int64
readerGetIntValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Int64
readerGetIntValue a
reader = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Int64
result <- Ptr Reader -> IO Int64
json_reader_get_int_value Ptr Reader
reader'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
data ReaderGetIntValueMethodInfo
instance (signature ~ (m Int64), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetIntValueMethodInfo a signature where
overloadedMethod = readerGetIntValue
instance O.OverloadedMethodInfo ReaderGetIntValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetIntValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetIntValue"
})
#endif
foreign import ccall "json_reader_get_member_name" json_reader_get_member_name ::
Ptr Reader ->
IO CString
readerGetMemberName ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m (Maybe T.Text)
readerGetMemberName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m (Maybe Text)
readerGetMemberName a
reader = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CString
result <- Ptr Reader -> IO CString
json_reader_get_member_name Ptr Reader
reader'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data ReaderGetMemberNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetMemberNameMethodInfo a signature where
overloadedMethod = readerGetMemberName
instance O.OverloadedMethodInfo ReaderGetMemberNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetMemberName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetMemberName"
})
#endif
foreign import ccall "json_reader_get_null_value" json_reader_get_null_value ::
Ptr Reader ->
IO CInt
readerGetNullValue ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Bool
readerGetNullValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Bool
readerGetNullValue a
reader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CInt
result <- Ptr Reader -> IO CInt
json_reader_get_null_value Ptr Reader
reader'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ReaderGetNullValueMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetNullValueMethodInfo a signature where
overloadedMethod = readerGetNullValue
instance O.OverloadedMethodInfo ReaderGetNullValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetNullValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetNullValue"
})
#endif
foreign import ccall "json_reader_get_string_value" json_reader_get_string_value ::
Ptr Reader ->
IO CString
readerGetStringValue ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m T.Text
readerGetStringValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Text
readerGetStringValue a
reader = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CString
result <- Ptr Reader -> IO CString
json_reader_get_string_value Ptr Reader
reader'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"readerGetStringValue" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ReaderGetStringValueMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetStringValueMethodInfo a signature where
overloadedMethod = readerGetStringValue
instance O.OverloadedMethodInfo ReaderGetStringValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetStringValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetStringValue"
})
#endif
foreign import ccall "json_reader_get_value" json_reader_get_value ::
Ptr Reader ->
IO (Ptr Json.Node.Node)
readerGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m (Maybe Json.Node.Node)
readerGetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m (Maybe Node)
readerGetValue a
reader = IO (Maybe Node) -> m (Maybe Node)
forall a. IO a -> m a
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 Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Ptr Node
result <- Ptr Reader -> IO (Ptr Node)
json_reader_get_value Ptr Reader
reader'
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Maybe Node -> IO (Maybe Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
maybeResult
#if defined(ENABLE_OVERLOADING)
data ReaderGetValueMethodInfo
instance (signature ~ (m (Maybe Json.Node.Node)), MonadIO m, IsReader a) => O.OverloadedMethod ReaderGetValueMethodInfo a signature where
overloadedMethod = readerGetValue
instance O.OverloadedMethodInfo ReaderGetValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerGetValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerGetValue"
})
#endif
foreign import ccall "json_reader_is_array" json_reader_is_array ::
Ptr Reader ->
IO CInt
readerIsArray ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Bool
readerIsArray :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Bool
readerIsArray a
reader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CInt
result <- Ptr Reader -> IO CInt
json_reader_is_array Ptr Reader
reader'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ReaderIsArrayMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsReader a) => O.OverloadedMethod ReaderIsArrayMethodInfo a signature where
overloadedMethod = readerIsArray
instance O.OverloadedMethodInfo ReaderIsArrayMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerIsArray",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerIsArray"
})
#endif
foreign import ccall "json_reader_is_object" json_reader_is_object ::
Ptr Reader ->
IO CInt
readerIsObject ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Bool
readerIsObject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Bool
readerIsObject a
reader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CInt
result <- Ptr Reader -> IO CInt
json_reader_is_object Ptr Reader
reader'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ReaderIsObjectMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsReader a) => O.OverloadedMethod ReaderIsObjectMethodInfo a signature where
overloadedMethod = readerIsObject
instance O.OverloadedMethodInfo ReaderIsObjectMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerIsObject",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerIsObject"
})
#endif
foreign import ccall "json_reader_is_value" json_reader_is_value ::
Ptr Reader ->
IO CInt
readerIsValue ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m Bool
readerIsValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m Bool
readerIsValue a
reader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CInt
result <- Ptr Reader -> IO CInt
json_reader_is_value Ptr Reader
reader'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ReaderIsValueMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsReader a) => O.OverloadedMethod ReaderIsValueMethodInfo a signature where
overloadedMethod = readerIsValue
instance O.OverloadedMethodInfo ReaderIsValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerIsValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerIsValue"
})
#endif
foreign import ccall "json_reader_list_members" json_reader_list_members ::
Ptr Reader ->
IO (Ptr CString)
readerListMembers ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> m [T.Text]
readerListMembers :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> m [Text]
readerListMembers a
reader = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Ptr CString
result <- Ptr Reader -> IO (Ptr CString)
json_reader_list_members Ptr Reader
reader'
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"readerListMembers" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
#if defined(ENABLE_OVERLOADING)
data ReaderListMembersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsReader a) => O.OverloadedMethod ReaderListMembersMethodInfo a signature where
overloadedMethod = readerListMembers
instance O.OverloadedMethodInfo ReaderListMembersMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerListMembers",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerListMembers"
})
#endif
foreign import ccall "json_reader_read_element" json_reader_read_element ::
Ptr Reader ->
Word32 ->
IO CInt
readerReadElement ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> Word32
-> m Bool
readerReadElement :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> Word32 -> m Bool
readerReadElement a
reader Word32
index_ = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CInt
result <- Ptr Reader -> Word32 -> IO CInt
json_reader_read_element Ptr Reader
reader' Word32
index_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ReaderReadElementMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m, IsReader a) => O.OverloadedMethod ReaderReadElementMethodInfo a signature where
overloadedMethod = readerReadElement
instance O.OverloadedMethodInfo ReaderReadElementMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerReadElement",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerReadElement"
})
#endif
foreign import ccall "json_reader_read_member" json_reader_read_member ::
Ptr Reader ->
CString ->
IO CInt
readerReadMember ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> T.Text
-> m Bool
readerReadMember :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> Text -> m Bool
readerReadMember a
reader Text
memberName = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
CString
memberName' <- Text -> IO CString
textToCString Text
memberName
CInt
result <- Ptr Reader -> CString -> IO CInt
json_reader_read_member Ptr Reader
reader' CString
memberName'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
memberName'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ReaderReadMemberMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsReader a) => O.OverloadedMethod ReaderReadMemberMethodInfo a signature where
overloadedMethod = readerReadMember
instance O.OverloadedMethodInfo ReaderReadMemberMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerReadMember",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerReadMember"
})
#endif
foreign import ccall "json_reader_set_root" json_reader_set_root ::
Ptr Reader ->
Ptr Json.Node.Node ->
IO ()
readerSetRoot ::
(B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
a
-> Maybe (Json.Node.Node)
-> m ()
readerSetRoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsReader a) =>
a -> Maybe Node -> m ()
readerSetRoot a
reader Maybe Node
root = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Reader
reader' <- a -> IO (Ptr Reader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
reader
Ptr Node
maybeRoot <- case Maybe Node
root of
Maybe Node
Nothing -> Ptr Node -> IO (Ptr Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Node
forall a. Ptr a
nullPtr
Just Node
jRoot -> do
Ptr Node
jRoot' <- Node -> IO (Ptr Node)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
jRoot
Ptr Node -> IO (Ptr Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Node
jRoot'
Ptr Reader -> Ptr Node -> IO ()
json_reader_set_root Ptr Reader
reader' Ptr Node
maybeRoot
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
reader
Maybe Node -> (Node -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Node
root Node -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ReaderSetRootMethodInfo
instance (signature ~ (Maybe (Json.Node.Node) -> m ()), MonadIO m, IsReader a) => O.OverloadedMethod ReaderSetRootMethodInfo a signature where
overloadedMethod = readerSetRoot
instance O.OverloadedMethodInfo ReaderSetRootMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Json.Objects.Reader.readerSetRoot",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Reader.html#v:readerSetRoot"
})
#endif