#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Json.Functions
(
boxedCanDeserialize ,
boxedCanSerialize ,
boxedDeserialize ,
boxedSerialize ,
constructGobject ,
fromString ,
gobjectDeserialize ,
gobjectFromData ,
gobjectSerialize ,
gobjectToData ,
gvariantDeserialize ,
gvariantDeserializeData ,
gvariantSerialize ,
gvariantSerializeData ,
serializeGobject ,
stringCompare ,
stringEqual ,
stringHash ,
toString ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Json.Enums as Json.Enums
import {-# SOURCE #-} qualified GI.Json.Structs.Node as Json.Node
foreign import ccall "json_to_string" json_to_string ::
Ptr Json.Node.Node ->
CInt ->
IO CString
toString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Json.Node.Node
-> Bool
-> m T.Text
toString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Node -> Bool -> m Text
toString Node
node Bool
pretty = IO Text -> m Text
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 Node
node' <- Node -> IO (Ptr Node)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
let pretty' :: CInt
pretty' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
pretty
CString
result <- Ptr Node -> CInt -> IO CString
json_to_string Ptr Node
node' CInt
pretty'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"toString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Node -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "json_string_hash" json_string_hash ::
CString ->
IO Word32
stringHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Word32
stringHash :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Word32
stringHash Text
key = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
CString
key' <- Text -> IO CString
textToCString Text
key
Word32
result <- CString -> IO Word32
json_string_hash CString
key'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "json_string_equal" json_string_equal ::
CString ->
CString ->
IO CInt
stringEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m Bool
stringEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> m Bool
stringEqual Text
a Text
b = IO Bool -> m Bool
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
CString
a' <- Text -> IO CString
textToCString Text
a
CString
b' <- Text -> IO CString
textToCString Text
b
CInt
result <- CString -> CString -> IO CInt
json_string_equal CString
a' CString
b'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
a'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
b'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "json_string_compare" json_string_compare ::
CString ->
CString ->
IO Int32
stringCompare ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m Int32
stringCompare :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> m Int32
stringCompare Text
a Text
b = IO Int32 -> m Int32
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
CString
a' <- Text -> IO CString
textToCString Text
a
CString
b' <- Text -> IO CString
textToCString Text
b
Int32
result <- CString -> CString -> IO Int32
json_string_compare CString
a' CString
b'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
a'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
b'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "json_serialize_gobject" json_serialize_gobject ::
Ptr GObject.Object.Object ->
Ptr Word64 ->
IO CString
{-# DEPRECATED serializeGobject ["(Since version 0.10)","Use [func/@json@/.gobject_to_data] instead"] #-}
serializeGobject ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
a
-> m ((T.Text, Word64))
serializeGobject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m (Text, Word64)
serializeGobject a
gobject = IO (Text, Word64) -> m (Text, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word64) -> m (Text, Word64))
-> IO (Text, Word64) -> m (Text, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
gobject' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gobject
Ptr Word64
length_ <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CString
result <- Ptr Object -> Ptr Word64 -> IO CString
json_serialize_gobject Ptr Object
gobject' Ptr Word64
length_
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serializeGobject" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Word64
length_' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
length_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gobject
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
length_
(Text, Word64) -> IO (Text, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Word64
length_')
foreign import ccall "json_gvariant_serialize_data" json_gvariant_serialize_data ::
Ptr GVariant ->
Ptr Word64 ->
IO CString
gvariantSerializeData ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m ((T.Text, Word64))
gvariantSerializeData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m (Text, Word64)
gvariantSerializeData GVariant
variant = IO (Text, Word64) -> m (Text, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word64) -> m (Text, Word64))
-> IO (Text, Word64) -> m (Text, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
variant' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
variant
Ptr Word64
length_ <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CString
result <- Ptr GVariant -> Ptr Word64 -> IO CString
json_gvariant_serialize_data Ptr GVariant
variant' Ptr Word64
length_
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gvariantSerializeData" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Word64
length_' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
length_
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
variant
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
length_
(Text, Word64) -> IO (Text, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Word64
length_')
foreign import ccall "json_gvariant_serialize" json_gvariant_serialize ::
Ptr GVariant ->
IO (Ptr Json.Node.Node)
gvariantSerialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m Json.Node.Node
gvariantSerialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GVariant -> m Node
gvariantSerialize GVariant
variant = IO Node -> m Node
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Node -> m Node) -> IO Node -> m Node
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
variant' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
variant
Ptr Node
result <- Ptr GVariant -> IO (Ptr Node)
json_gvariant_serialize Ptr GVariant
variant'
Text -> Ptr Node -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gvariantSerialize" Ptr Node
result
Node
result' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
variant
Node -> IO Node
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result'
foreign import ccall "json_gvariant_deserialize_data" json_gvariant_deserialize_data ::
CString ->
Int64 ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GVariant)
gvariantDeserializeData ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int64
-> Maybe (T.Text)
-> m (Maybe GVariant)
gvariantDeserializeData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Int64 -> Maybe Text -> m (Maybe GVariant)
gvariantDeserializeData Text
json Int64
length_ Maybe Text
signature = IO (Maybe GVariant) -> m (Maybe GVariant)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
CString
json' <- Text -> IO CString
textToCString Text
json
CString
maybeSignature <- case Maybe Text
signature of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jSignature -> do
CString
jSignature' <- Text -> IO CString
textToCString Text
jSignature
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jSignature'
IO (Maybe GVariant) -> IO () -> IO (Maybe GVariant)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr GVariant
result <- (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant))
-> (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a b. (a -> b) -> a -> b
$ CString
-> Int64 -> CString -> Ptr (Ptr GError) -> IO (Ptr GVariant)
json_gvariant_deserialize_data CString
json' Int64
length_ CString
maybeSignature
Maybe GVariant
maybeResult <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result'
GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
json'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeSignature
Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
json'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeSignature
)
foreign import ccall "json_gvariant_deserialize" json_gvariant_deserialize ::
Ptr Json.Node.Node ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GVariant)
gvariantDeserialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Json.Node.Node
-> Maybe (T.Text)
-> m (Maybe GVariant)
gvariantDeserialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Node -> Maybe Text -> m (Maybe GVariant)
gvariantDeserialize Node
jsonNode Maybe Text
signature = IO (Maybe GVariant) -> m (Maybe GVariant)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
Ptr Node
jsonNode' <- Node -> IO (Ptr Node)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
jsonNode
CString
maybeSignature <- case Maybe Text
signature of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jSignature -> do
CString
jSignature' <- Text -> IO CString
textToCString Text
jSignature
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jSignature'
IO (Maybe GVariant) -> IO () -> IO (Maybe GVariant)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr GVariant
result <- (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant))
-> (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a b. (a -> b) -> a -> b
$ Ptr Node -> CString -> Ptr (Ptr GError) -> IO (Ptr GVariant)
json_gvariant_deserialize Ptr Node
jsonNode' CString
maybeSignature
Maybe GVariant
maybeResult <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result'
GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
Node -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
jsonNode
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeSignature
Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeSignature
)
foreign import ccall "json_gobject_to_data" json_gobject_to_data ::
Ptr GObject.Object.Object ->
Ptr Word64 ->
IO CString
gobjectToData ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
a
-> m ((T.Text, Word64))
gobjectToData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m (Text, Word64)
gobjectToData a
gobject = IO (Text, Word64) -> m (Text, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word64) -> m (Text, Word64))
-> IO (Text, Word64) -> m (Text, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
gobject' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gobject
Ptr Word64
length_ <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CString
result <- Ptr Object -> Ptr Word64 -> IO CString
json_gobject_to_data Ptr Object
gobject' Ptr Word64
length_
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gobjectToData" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Word64
length_' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
length_
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gobject
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
length_
(Text, Word64) -> IO (Text, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', Word64
length_')
foreign import ccall "json_gobject_serialize" json_gobject_serialize ::
Ptr GObject.Object.Object ->
IO (Ptr Json.Node.Node)
gobjectSerialize ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
a
-> m Json.Node.Node
gobjectSerialize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Node
gobjectSerialize a
gobject = IO Node -> m Node
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Node -> m Node) -> IO Node -> m Node
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
gobject' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gobject
Ptr Node
result <- Ptr Object -> IO (Ptr Node)
json_gobject_serialize Ptr Object
gobject'
Text -> Ptr Node -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gobjectSerialize" Ptr Node
result
Node
result' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gobject
Node -> IO Node
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result'
foreign import ccall "json_gobject_from_data" json_gobject_from_data ::
CGType ->
CString ->
Int64 ->
Ptr (Ptr GError) ->
IO (Ptr GObject.Object.Object)
gobjectFromData ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> T.Text
-> Int64
-> m (Maybe GObject.Object.Object)
gobjectFromData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Text -> Int64 -> m (Maybe Object)
gobjectFromData GType
gtype Text
data_ Int64
length_ = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
let gtype' :: Word64
gtype' = GType -> Word64
gtypeToCGType GType
gtype
CString
data_' <- Text -> IO CString
textToCString Text
data_
IO (Maybe Object) -> IO () -> IO (Maybe Object)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Object
result <- (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object))
-> (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
forall a b. (a -> b) -> a -> b
$ Word64 -> CString -> Int64 -> Ptr (Ptr GError) -> IO (Ptr Object)
json_gobject_from_data Word64
gtype' CString
data_' Int64
length_
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
)
foreign import ccall "json_gobject_deserialize" json_gobject_deserialize ::
CGType ->
Ptr Json.Node.Node ->
IO (Ptr GObject.Object.Object)
gobjectDeserialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Json.Node.Node
-> m GObject.Object.Object
gobjectDeserialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Node -> m Object
gobjectDeserialize GType
gtype Node
node = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
let gtype' :: Word64
gtype' = GType -> Word64
gtypeToCGType GType
gtype
Ptr Node
node' <- Node -> IO (Ptr Node)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
Ptr Object
result <- Word64 -> Ptr Node -> IO (Ptr Object)
json_gobject_deserialize Word64
gtype' Ptr Node
node'
Text -> Ptr Object -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gobjectDeserialize" Ptr Object
result
Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result
Node -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'
foreign import ccall "json_from_string" json_from_string ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr Json.Node.Node)
fromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe Json.Node.Node)
fromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Node)
fromString Text
str = IO (Maybe Node) -> m (Maybe Node)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Node) -> m (Maybe Node))
-> IO (Maybe Node) -> m (Maybe Node)
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
IO (Maybe Node) -> IO () -> IO (Maybe Node)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Node
result <- (Ptr (Ptr GError) -> IO (Ptr Node)) -> IO (Ptr Node)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Node)) -> IO (Ptr Node))
-> (Ptr (Ptr GError) -> IO (Ptr Node)) -> IO (Ptr Node)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr Node)
json_from_string CString
str'
Maybe Node
maybeResult <- Ptr Node -> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Node
result ((Ptr Node -> IO Node) -> IO (Maybe Node))
-> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. (a -> b) -> a -> b
$ \Ptr Node
result' -> do
Node
result'' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
result'
Node -> IO Node
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Maybe Node -> IO (Maybe Node)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
)
foreign import ccall "json_construct_gobject" json_construct_gobject ::
CGType ->
CString ->
Word64 ->
Ptr (Ptr GError) ->
IO (Ptr GObject.Object.Object)
{-# DEPRECATED constructGobject ["(Since version 0.10)","Use [func/@json@/.gobject_from_data] instead"] #-}
constructGobject ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> T.Text
-> Word64
-> m (Maybe GObject.Object.Object)
constructGobject :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Text -> Word64 -> m (Maybe Object)
constructGobject GType
gtype Text
data_ Word64
length_ = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
let gtype' :: Word64
gtype' = GType -> Word64
gtypeToCGType GType
gtype
CString
data_' <- Text -> IO CString
textToCString Text
data_
IO (Maybe Object) -> IO () -> IO (Maybe Object)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Object
result <- (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object))
-> (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
forall a b. (a -> b) -> a -> b
$ Word64 -> CString -> Word64 -> Ptr (Ptr GError) -> IO (Ptr Object)
json_construct_gobject Word64
gtype' CString
data_' Word64
length_
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
data_'
)
foreign import ccall "json_boxed_serialize" json_boxed_serialize ::
CGType ->
Ptr () ->
IO (Ptr Json.Node.Node)
boxedSerialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Ptr ()
-> m (Maybe Json.Node.Node)
boxedSerialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Ptr () -> m (Maybe Node)
boxedSerialize GType
gboxedType Ptr ()
boxed = IO (Maybe Node) -> m (Maybe Node)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Node) -> m (Maybe Node))
-> IO (Maybe Node) -> m (Maybe Node)
forall a b. (a -> b) -> a -> b
$ do
let gboxedType' :: Word64
gboxedType' = GType -> Word64
gtypeToCGType GType
gboxedType
Ptr Node
result <- Word64 -> Ptr () -> IO (Ptr Node)
json_boxed_serialize Word64
gboxedType' Ptr ()
boxed
Maybe Node
maybeResult <- Ptr Node -> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Node
result ((Ptr Node -> IO Node) -> IO (Maybe Node))
-> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. (a -> b) -> a -> b
$ \Ptr Node
result' -> do
Node
result'' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
result'
Node -> IO Node
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result''
Maybe Node -> IO (Maybe Node)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
maybeResult
foreign import ccall "json_boxed_deserialize" json_boxed_deserialize ::
CGType ->
Ptr Json.Node.Node ->
IO (Ptr ())
boxedDeserialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Json.Node.Node
-> m (Ptr ())
boxedDeserialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> Node -> m (Ptr ())
boxedDeserialize GType
gboxedType Node
node = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
let gboxedType' :: Word64
gboxedType' = GType -> Word64
gtypeToCGType GType
gboxedType
Ptr Node
node' <- Node -> IO (Ptr Node)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
Ptr ()
result <- Word64 -> Ptr Node -> IO (Ptr ())
json_boxed_deserialize Word64
gboxedType' Ptr Node
node'
Node -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
foreign import ccall "json_boxed_can_serialize" json_boxed_can_serialize ::
CGType ->
Ptr CUInt ->
IO CInt
boxedCanSerialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m ((Bool, Json.Enums.NodeType))
boxedCanSerialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> m (Bool, NodeType)
boxedCanSerialize GType
gboxedType = IO (Bool, NodeType) -> m (Bool, NodeType)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, NodeType) -> m (Bool, NodeType))
-> IO (Bool, NodeType) -> m (Bool, NodeType)
forall a b. (a -> b) -> a -> b
$ do
let gboxedType' :: Word64
gboxedType' = GType -> Word64
gtypeToCGType GType
gboxedType
Ptr CUInt
nodeType <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
CInt
result <- Word64 -> Ptr CUInt -> IO CInt
json_boxed_can_serialize Word64
gboxedType' Ptr CUInt
nodeType
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CUInt
nodeType' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
nodeType
let nodeType'' :: NodeType
nodeType'' = (Int -> NodeType
forall a. Enum a => Int -> a
toEnum (Int -> NodeType) -> (CUInt -> Int) -> CUInt -> NodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
nodeType'
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
nodeType
(Bool, NodeType) -> IO (Bool, NodeType)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', NodeType
nodeType'')
foreign import ccall "json_boxed_can_deserialize" json_boxed_can_deserialize ::
CGType ->
CUInt ->
IO CInt
boxedCanDeserialize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Json.Enums.NodeType
-> m Bool
boxedCanDeserialize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> NodeType -> m Bool
boxedCanDeserialize GType
gboxedType NodeType
nodeType = IO Bool -> m Bool
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
let gboxedType' :: Word64
gboxedType' = GType -> Word64
gtypeToCGType GType
gboxedType
let nodeType' :: CUInt
nodeType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (NodeType -> Int) -> NodeType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NodeType -> Int
forall a. Enum a => a -> Int
fromEnum) NodeType
nodeType
CInt
result <- Word64 -> CUInt -> IO CInt
json_boxed_can_deserialize Word64
gboxedType' CUInt
nodeType'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'