{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @JsonReader@ provides a simple, cursor-based API for parsing a JSON DOM.
-- 
-- It is similar, in spirit, to the XML Reader API.
-- 
-- == Using @JsonReader@
-- 
-- 
-- === /c code/
-- >g_autoptr(JsonParser) parser = json_parser_new ();
-- >
-- >// str is defined elsewhere
-- >json_parser_load_from_data (parser, str, -1, NULL);
-- >
-- >g_autoptr(JsonReader) reader = json_reader_new (json_parser_get_root (parser));
-- >
-- >json_reader_read_member (reader, "url");
-- >  const char *url = json_reader_get_string_value (reader);
-- >  json_reader_end_member (reader);
-- >
-- >json_reader_read_member (reader, "size");
-- >  json_reader_read_element (reader, 0);
-- >    int width = json_reader_get_int_value (reader);
-- >    json_reader_end_element (reader);
-- >  json_reader_read_element (reader, 1);
-- >    int height = json_reader_get_int_value (reader);
-- >    json_reader_end_element (reader);
-- >  json_reader_end_member (reader);
-- 
-- 
-- == Error handling
-- 
-- In case of error, @JsonReader@ will be set in an error state; all subsequent
-- calls will simply be ignored until a function that resets the error state is
-- called, e.g.:
-- 
-- 
-- === /c code/
-- >// ask for the 7th element; if the element does not exist, the
-- >// reader will be put in an error state
-- >json_reader_read_element (reader, 6);
-- >
-- >// in case of error, this will return NULL, otherwise it will
-- >// return the value of the element
-- >str = json_reader_get_string_value (value);
-- >
-- >// this function resets the error state if any was set
-- >json_reader_end_element (reader);
-- 
-- 
-- If you want to detect the error state as soon as possible, you can use
-- 'GI.Json.Objects.Reader.readerGetError':
-- 
-- 
-- === /c code/
-- >// like the example above, but in this case we print out the
-- >// error immediately
-- >if (!json_reader_read_element (reader, 6))
-- >  {
-- >    const GError *error = json_reader_get_error (reader);
-- >    g_print ("Unable to read the element: %s", error->message);
-- >  }
-- 
-- 
-- /Since: 0.12/

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

module GI.Json.Objects.Reader
    ( 

-- * Exported types
    Reader(..)                              ,
    IsReader                                ,
    toReader                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [countElements]("GI.Json.Objects.Reader#g:method:countElements"), [countMembers]("GI.Json.Objects.Reader#g:method:countMembers"), [endElement]("GI.Json.Objects.Reader#g:method:endElement"), [endMember]("GI.Json.Objects.Reader#g:method:endMember"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isArray]("GI.Json.Objects.Reader#g:method:isArray"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isObject]("GI.Json.Objects.Reader#g:method:isObject"), [isValue]("GI.Json.Objects.Reader#g:method:isValue"), [listMembers]("GI.Json.Objects.Reader#g:method:listMembers"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [readElement]("GI.Json.Objects.Reader#g:method:readElement"), [readMember]("GI.Json.Objects.Reader#g:method:readMember"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBooleanValue]("GI.Json.Objects.Reader#g:method:getBooleanValue"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDoubleValue]("GI.Json.Objects.Reader#g:method:getDoubleValue"), [getError]("GI.Json.Objects.Reader#g:method:getError"), [getIntValue]("GI.Json.Objects.Reader#g:method:getIntValue"), [getMemberName]("GI.Json.Objects.Reader#g:method:getMemberName"), [getNullValue]("GI.Json.Objects.Reader#g:method:getNullValue"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getStringValue]("GI.Json.Objects.Reader#g:method:getStringValue"), [getValue]("GI.Json.Objects.Reader#g:method:getValue").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRoot]("GI.Json.Objects.Reader#g:method:setRoot").

#if defined(ENABLE_OVERLOADING)
    ResolveReaderMethod                     ,
#endif

-- ** countElements #method:countElements#

#if defined(ENABLE_OVERLOADING)
    ReaderCountElementsMethodInfo           ,
#endif
    readerCountElements                     ,


-- ** countMembers #method:countMembers#

#if defined(ENABLE_OVERLOADING)
    ReaderCountMembersMethodInfo            ,
#endif
    readerCountMembers                      ,


-- ** endElement #method:endElement#

#if defined(ENABLE_OVERLOADING)
    ReaderEndElementMethodInfo              ,
#endif
    readerEndElement                        ,


-- ** endMember #method:endMember#

#if defined(ENABLE_OVERLOADING)
    ReaderEndMemberMethodInfo               ,
#endif
    readerEndMember                         ,


-- ** getBooleanValue #method:getBooleanValue#

#if defined(ENABLE_OVERLOADING)
    ReaderGetBooleanValueMethodInfo         ,
#endif
    readerGetBooleanValue                   ,


-- ** getDoubleValue #method:getDoubleValue#

#if defined(ENABLE_OVERLOADING)
    ReaderGetDoubleValueMethodInfo          ,
#endif
    readerGetDoubleValue                    ,


-- ** getError #method:getError#

#if defined(ENABLE_OVERLOADING)
    ReaderGetErrorMethodInfo                ,
#endif
    readerGetError                          ,


-- ** getIntValue #method:getIntValue#

#if defined(ENABLE_OVERLOADING)
    ReaderGetIntValueMethodInfo             ,
#endif
    readerGetIntValue                       ,


-- ** getMemberName #method:getMemberName#

#if defined(ENABLE_OVERLOADING)
    ReaderGetMemberNameMethodInfo           ,
#endif
    readerGetMemberName                     ,


-- ** getNullValue #method:getNullValue#

#if defined(ENABLE_OVERLOADING)
    ReaderGetNullValueMethodInfo            ,
#endif
    readerGetNullValue                      ,


-- ** getStringValue #method:getStringValue#

#if defined(ENABLE_OVERLOADING)
    ReaderGetStringValueMethodInfo          ,
#endif
    readerGetStringValue                    ,


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    ReaderGetValueMethodInfo                ,
#endif
    readerGetValue                          ,


-- ** isArray #method:isArray#

#if defined(ENABLE_OVERLOADING)
    ReaderIsArrayMethodInfo                 ,
#endif
    readerIsArray                           ,


-- ** isObject #method:isObject#

#if defined(ENABLE_OVERLOADING)
    ReaderIsObjectMethodInfo                ,
#endif
    readerIsObject                          ,


-- ** isValue #method:isValue#

#if defined(ENABLE_OVERLOADING)
    ReaderIsValueMethodInfo                 ,
#endif
    readerIsValue                           ,


-- ** listMembers #method:listMembers#

#if defined(ENABLE_OVERLOADING)
    ReaderListMembersMethodInfo             ,
#endif
    readerListMembers                       ,


-- ** new #method:new#

    readerNew                               ,


-- ** readElement #method:readElement#

#if defined(ENABLE_OVERLOADING)
    ReaderReadElementMethodInfo             ,
#endif
    readerReadElement                       ,


-- ** readMember #method:readMember#

#if defined(ENABLE_OVERLOADING)
    ReaderReadMemberMethodInfo              ,
#endif
    readerReadMember                        ,


-- ** setRoot #method:setRoot#

#if defined(ENABLE_OVERLOADING)
    ReaderSetRootMethodInfo                 ,
#endif
    readerSetRoot                           ,




 -- * Properties


-- ** root #attr:root#
-- | The root of the JSON tree that the reader should read.
-- 
-- /Since: 0.12/

#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

-- | Memory-managed wrapper type.
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

-- | Type class for types which can be safely cast to `Reader`, for instance with `toReader`.
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]

-- | Cast to `Reader`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- | Convert 'Reader' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe 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

-- VVV Prop "root"
   -- Type: TInterface (Name {namespace = "Json", name = "Node"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@root@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' reader #root
-- @
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

-- | Set the value of the “@root@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' reader [ #root 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Construct a `GValueConstruct` with valid value for the “@root@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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)

-- | Set the value of the “@root@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #root
-- @
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

-- method Reader::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "Json" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the root node" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Reader" })
-- throws : False
-- Skip return : False

foreign import ccall "json_reader_new" json_reader_new :: 
    Ptr Json.Node.Node ->                   -- node : TInterface (Name {namespace = "Json", name = "Node"})
    IO (Ptr Reader)

-- | Creates a new reader.
-- 
-- You can use this object to read the contents of the JSON tree starting
-- from the given node.
-- 
-- /Since: 0.12/
readerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (Json.Node.Node)
    -- ^ /@node@/: the root node
    -> m Reader
    -- ^ __Returns:__ the newly created 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

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

foreign import ccall "json_reader_count_elements" json_reader_count_elements :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO Int32

-- | Counts the elements of the current position, if the reader is
-- positioned on an array.
-- 
-- In case of failure, the reader is set to an error state.
-- 
-- /Since: 0.12/
readerCountElements ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Int32
    -- ^ __Returns:__ the number of elements, or -1.
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

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

foreign import ccall "json_reader_count_members" json_reader_count_members :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO Int32

-- | Counts the members of the current position, if the reader is
-- positioned on an object.
-- 
-- In case of failure, the reader is set to an error state.
-- 
-- /Since: 0.12/
readerCountMembers ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Int32
    -- ^ __Returns:__ the number of members, or -1
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

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

foreign import ccall "json_reader_end_element" json_reader_end_element :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO ()

-- | Moves the cursor back to the previous node after being positioned
-- inside an array.
-- 
-- This function resets the error state of the reader, if any was set.
-- 
-- /Since: 0.12/
readerEndElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> 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

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

foreign import ccall "json_reader_end_member" json_reader_end_member :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO ()

-- | Moves the cursor back to the previous node after being positioned
-- inside an object.
-- 
-- This function resets the error state of the reader, if any was set.
-- 
-- /Since: 0.12/
readerEndMember ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> 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

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

foreign import ccall "json_reader_get_boolean_value" json_reader_get_boolean_value :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CInt

-- | Retrieves the boolean value of the current position of the reader.
-- 
-- See also: 'GI.Json.Objects.Reader.readerGetValue'
-- 
-- /Since: 0.12/
readerGetBooleanValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Bool
    -- ^ __Returns:__ the boolean value
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

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

foreign import ccall "json_reader_get_double_value" json_reader_get_double_value :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CDouble

-- | Retrieves the floating point value of the current position of the reader.
-- 
-- See also: 'GI.Json.Objects.Reader.readerGetValue'
-- 
-- /Since: 0.12/
readerGetDoubleValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Double
    -- ^ __Returns:__ the floating point value
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

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

foreign import ccall "json_reader_get_error" json_reader_get_error :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO (Ptr GError)

-- | Retrieves the error currently set on the reader.
-- 
-- /Since: 0.12/
readerGetError ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m (Maybe GError)
    -- ^ __Returns:__ the current error
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

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

foreign import ccall "json_reader_get_int_value" json_reader_get_int_value :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO Int64

-- | Retrieves the integer value of the current position of the reader.
-- 
-- See also: 'GI.Json.Objects.Reader.readerGetValue'
-- 
-- /Since: 0.12/
readerGetIntValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Int64
    -- ^ __Returns:__ the integer value
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

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

foreign import ccall "json_reader_get_member_name" json_reader_get_member_name :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CString

-- | Retrieves the name of the current member.
-- 
-- In case of failure, the reader is set to an error state.
-- 
-- /Since: 0.14/
readerGetMemberName ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the member
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

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

foreign import ccall "json_reader_get_null_value" json_reader_get_null_value :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CInt

-- | Checks whether the value of the current position of the reader is @null@.
-- 
-- See also: 'GI.Json.Objects.Reader.readerGetValue'
-- 
-- /Since: 0.12/
readerGetNullValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if @null@ is set, and @FALSE@ otherwise
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

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

foreign import ccall "json_reader_get_string_value" json_reader_get_string_value :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CString

-- | Retrieves the string value of the current position of the reader.
-- 
-- See also: 'GI.Json.Objects.Reader.readerGetValue'
-- 
-- /Since: 0.12/
readerGetStringValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m T.Text
    -- ^ __Returns:__ the string value
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

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

foreign import ccall "json_reader_get_value" json_reader_get_value :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO (Ptr Json.Node.Node)

-- | Retrieves the value node at the current position of the reader.
-- 
-- If the current position does not contain a scalar value, the reader
-- is set to an error state.
-- 
-- /Since: 0.12/
readerGetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m (Maybe Json.Node.Node)
    -- ^ __Returns:__ the current value 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

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

foreign import ccall "json_reader_is_array" json_reader_is_array :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CInt

-- | Checks whether the reader is currently on an array.
-- 
-- /Since: 0.12/
readerIsArray ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if the reader is on an array
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

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

foreign import ccall "json_reader_is_object" json_reader_is_object :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CInt

-- | Checks whether the reader is currently on an object.
-- 
-- /Since: 0.12/
readerIsObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if the reader is on an object
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

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

foreign import ccall "json_reader_is_value" json_reader_is_value :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO CInt

-- | Checks whether the reader is currently on a value.
-- 
-- /Since: 0.12/
readerIsValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if the reader is on a value
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

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

foreign import ccall "json_reader_list_members" json_reader_list_members :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    IO (Ptr CString)

-- | Retrieves a list of member names from the current position, if the reader
-- is positioned on an object.
-- 
-- In case of failure, the reader is set to an error state.
-- 
-- /Since: 0.14/
readerListMembers ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> m [T.Text]
    -- ^ __Returns:__ the members of
    --   the object
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

-- method Reader::read_element
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "reader"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Reader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a reader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index of the element"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "json_reader_read_element" json_reader_read_element :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    Word32 ->                               -- index_ : TBasicType TUInt
    IO CInt

-- | Advances the cursor of the reader to the element of the array or
-- the member of the object at the given position.
-- 
-- You can use 'GI.Json.Objects.Reader.readerGetValue' and its wrapper functions to
-- retrieve the value of the element; for instance, the following code will
-- read the first element of the array at the current cursor position:
-- 
-- 
-- === /c code/
-- >json_reader_read_element (reader, 0);
-- >int_value = json_reader_get_int_value (reader);
-- 
-- 
-- After reading the value, you should call 'GI.Json.Objects.Reader.readerEndElement'
-- to reposition the cursor inside the reader, e.g.:
-- 
-- 
-- === /c code/
-- >const char *str_value = NULL;
-- >
-- >json_reader_read_element (reader, 1);
-- >str_value = json_reader_get_string_value (reader);
-- >json_reader_end_element (reader);
-- >
-- >json_reader_read_element (reader, 2);
-- >str_value = json_reader_get_string_value (reader);
-- >json_reader_end_element (reader);
-- 
-- 
-- If the reader is not currently on an array or an object, or if the index is
-- bigger than the size of the array or the object, the reader will be
-- put in an error state until 'GI.Json.Objects.Reader.readerEndElement' is called. This
-- means that, if used conditionally, 'GI.Json.Objects.Reader.readerEndElement' must be
-- called on all branches:
-- 
-- 
-- === /c code/
-- >if (!json_reader_read_element (reader, 1))
-- >  {
-- >    g_propagate_error (error, json_reader_get_error (reader));
-- >    json_reader_end_element (reader);
-- >    return FALSE;
-- >  }
-- >else
-- >  {
-- >    const char *str_value = json_reader_get_string_value (reader);
-- >    json_reader_end_element (reader);
-- >
-- >    // use str_value
-- >
-- >    return TRUE;
-- >  }
-- c
-- 
-- /Since: 0.12/
readerReadElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> Word32
    -- ^ /@index_@/: the index of the element
    -> m Bool
    -- ^ __Returns:__ @TRUE@ on success, and @FALSE@ otherwise
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

-- method Reader::read_member
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "reader"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Reader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a reader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "member_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the member to read"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "json_reader_read_member" json_reader_read_member :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    CString ->                              -- member_name : TBasicType TUTF8
    IO CInt

-- | Advances the cursor of the reader to the @member_name@ of the object at
-- the current position.
-- 
-- You can use 'GI.Json.Objects.Reader.readerGetValue' and its wrapper functions to
-- retrieve the value of the member; for instance:
-- 
-- 
-- === /c code/
-- >json_reader_read_member (reader, "width");
-- >width = json_reader_get_int_value (reader);
-- 
-- 
-- After reading the value, @json_reader_end_member()@ should be called to
-- reposition the cursor inside the reader, e.g.:
-- 
-- 
-- === /c code/
-- >json_reader_read_member (reader, "author");
-- >author = json_reader_get_string_value (reader);
-- >json_reader_end_member (reader);
-- >
-- >json_reader_read_member (reader, "title");
-- >title = json_reader_get_string_value (reader);
-- >json_reader_end_member (reader);
-- 
-- 
-- If the reader is not currently on an object, or if the @member_name@ is not
-- defined in the object, the reader will be put in an error state until
-- 'GI.Json.Objects.Reader.readerEndMember' is called. This means that if used
-- conditionally, 'GI.Json.Objects.Reader.readerEndMember' must be called on all branches:
-- 
-- 
-- === /c code/
-- >if (!json_reader_read_member (reader, "title"))
-- >  {
-- >    g_propagate_error (error, json_reader_get_error (reader));
-- >    json_reader_end_member (reader);
-- >    return FALSE;
-- >  }
-- >else
-- >  {
-- >    const char *str_value = json_reader_get_string_value (reader);
-- >    json_reader_end_member (reader);
-- >
-- >    // use str_value
-- >
-- >    return TRUE;
-- >  }
-- 
-- 
-- /Since: 0.12/
readerReadMember ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> T.Text
    -- ^ /@memberName@/: the name of the member to read
    -> m Bool
    -- ^ __Returns:__ @TRUE@ on success, and @FALSE@ otherwise
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

-- method Reader::set_root
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "reader"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Reader" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a reader" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "root"
--           , argType = TInterface Name { namespace = "Json" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the root node" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "json_reader_set_root" json_reader_set_root :: 
    Ptr Reader ->                           -- reader : TInterface (Name {namespace = "Json", name = "Reader"})
    Ptr Json.Node.Node ->                   -- root : TInterface (Name {namespace = "Json", name = "Node"})
    IO ()

-- | Sets the root node of the JSON tree to be read by /@reader@/.
-- 
-- The reader will take a copy of the node.
-- 
-- /Since: 0.12/
readerSetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsReader a) =>
    a
    -- ^ /@reader@/: a reader
    -> Maybe (Json.Node.Node)
    -- ^ /@root@/: the root 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