{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Objects.ContentSerializer
(
ContentSerializer(..) ,
IsContentSerializer ,
toContentSerializer ,
#if defined(ENABLE_OVERLOADING)
ResolveContentSerializerMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetCancellableMethodInfo,
#endif
contentSerializerGetCancellable ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetGtypeMethodInfo ,
#endif
contentSerializerGetGtype ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetMimeTypeMethodInfo ,
#endif
contentSerializerGetMimeType ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetOutputStreamMethodInfo,
#endif
contentSerializerGetOutputStream ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetPriorityMethodInfo ,
#endif
contentSerializerGetPriority ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetTaskDataMethodInfo ,
#endif
contentSerializerGetTaskData ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetUserDataMethodInfo ,
#endif
contentSerializerGetUserData ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerGetValueMethodInfo ,
#endif
contentSerializerGetValue ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerReturnErrorMethodInfo ,
#endif
contentSerializerReturnError ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerReturnSuccessMethodInfo,
#endif
contentSerializerReturnSuccess ,
#if defined(ENABLE_OVERLOADING)
ContentSerializerSetTaskDataMethodInfo ,
#endif
contentSerializerSetTaskData ,
) 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.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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
newtype ContentSerializer = ContentSerializer (SP.ManagedPtr ContentSerializer)
deriving (ContentSerializer -> ContentSerializer -> Bool
(ContentSerializer -> ContentSerializer -> Bool)
-> (ContentSerializer -> ContentSerializer -> Bool)
-> Eq ContentSerializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ContentSerializer -> ContentSerializer -> Bool
$c/= :: ContentSerializer -> ContentSerializer -> Bool
== :: ContentSerializer -> ContentSerializer -> Bool
$c== :: ContentSerializer -> ContentSerializer -> Bool
Eq)
instance SP.ManagedPtrNewtype ContentSerializer where
toManagedPtr :: ContentSerializer -> ManagedPtr ContentSerializer
toManagedPtr (ContentSerializer ManagedPtr ContentSerializer
p) = ManagedPtr ContentSerializer
p
foreign import ccall "gdk_content_serializer_get_type"
c_gdk_content_serializer_get_type :: IO B.Types.GType
instance B.Types.TypedObject ContentSerializer where
glibType :: IO GType
glibType = IO GType
c_gdk_content_serializer_get_type
instance B.Types.GObject ContentSerializer
class (SP.GObject o, O.IsDescendantOf ContentSerializer o) => IsContentSerializer o
instance (SP.GObject o, O.IsDescendantOf ContentSerializer o) => IsContentSerializer o
instance O.HasParentTypes ContentSerializer
type instance O.ParentTypes ContentSerializer = '[GObject.Object.Object, Gio.AsyncResult.AsyncResult]
toContentSerializer :: (MIO.MonadIO m, IsContentSerializer o) => o -> m ContentSerializer
toContentSerializer :: forall (m :: * -> *) o.
(MonadIO m, IsContentSerializer o) =>
o -> m ContentSerializer
toContentSerializer = IO ContentSerializer -> m ContentSerializer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ContentSerializer -> m ContentSerializer)
-> (o -> IO ContentSerializer) -> o -> m ContentSerializer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ContentSerializer -> ContentSerializer)
-> o -> IO ContentSerializer
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ContentSerializer -> ContentSerializer
ContentSerializer
instance B.GValue.IsGValue (Maybe ContentSerializer) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gdk_content_serializer_get_type
gvalueSet_ :: Ptr GValue -> Maybe ContentSerializer -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ContentSerializer
P.Nothing = Ptr GValue -> Ptr ContentSerializer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ContentSerializer
forall a. Ptr a
FP.nullPtr :: FP.Ptr ContentSerializer)
gvalueSet_ Ptr GValue
gv (P.Just ContentSerializer
obj) = ContentSerializer -> (Ptr ContentSerializer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ContentSerializer
obj (Ptr GValue -> Ptr ContentSerializer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ContentSerializer)
gvalueGet_ Ptr GValue
gv = do
Ptr ContentSerializer
ptr <- Ptr GValue -> IO (Ptr ContentSerializer)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ContentSerializer)
if Ptr ContentSerializer
ptr Ptr ContentSerializer -> Ptr ContentSerializer -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ContentSerializer
forall a. Ptr a
FP.nullPtr
then ContentSerializer -> Maybe ContentSerializer
forall a. a -> Maybe a
P.Just (ContentSerializer -> Maybe ContentSerializer)
-> IO ContentSerializer -> IO (Maybe ContentSerializer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ContentSerializer -> ContentSerializer)
-> Ptr ContentSerializer -> IO ContentSerializer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ContentSerializer -> ContentSerializer
ContentSerializer Ptr ContentSerializer
ptr
else Maybe ContentSerializer -> IO (Maybe ContentSerializer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContentSerializer
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveContentSerializerMethod (t :: Symbol) (o :: *) :: * where
ResolveContentSerializerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveContentSerializerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveContentSerializerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveContentSerializerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveContentSerializerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveContentSerializerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveContentSerializerMethod "isTagged" o = Gio.AsyncResult.AsyncResultIsTaggedMethodInfo
ResolveContentSerializerMethod "legacyPropagateError" o = Gio.AsyncResult.AsyncResultLegacyPropagateErrorMethodInfo
ResolveContentSerializerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveContentSerializerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveContentSerializerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveContentSerializerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveContentSerializerMethod "returnError" o = ContentSerializerReturnErrorMethodInfo
ResolveContentSerializerMethod "returnSuccess" o = ContentSerializerReturnSuccessMethodInfo
ResolveContentSerializerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveContentSerializerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveContentSerializerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveContentSerializerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveContentSerializerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveContentSerializerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveContentSerializerMethod "getCancellable" o = ContentSerializerGetCancellableMethodInfo
ResolveContentSerializerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveContentSerializerMethod "getGtype" o = ContentSerializerGetGtypeMethodInfo
ResolveContentSerializerMethod "getMimeType" o = ContentSerializerGetMimeTypeMethodInfo
ResolveContentSerializerMethod "getOutputStream" o = ContentSerializerGetOutputStreamMethodInfo
ResolveContentSerializerMethod "getPriority" o = ContentSerializerGetPriorityMethodInfo
ResolveContentSerializerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveContentSerializerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveContentSerializerMethod "getSourceObject" o = Gio.AsyncResult.AsyncResultGetSourceObjectMethodInfo
ResolveContentSerializerMethod "getTaskData" o = ContentSerializerGetTaskDataMethodInfo
ResolveContentSerializerMethod "getUserData" o = ContentSerializerGetUserDataMethodInfo
ResolveContentSerializerMethod "getValue" o = ContentSerializerGetValueMethodInfo
ResolveContentSerializerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveContentSerializerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveContentSerializerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveContentSerializerMethod "setTaskData" o = ContentSerializerSetTaskDataMethodInfo
ResolveContentSerializerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveContentSerializerMethod t ContentSerializer, O.OverloadedMethod info ContentSerializer p) => OL.IsLabel t (ContentSerializer -> 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 ~ ResolveContentSerializerMethod t ContentSerializer, O.OverloadedMethod info ContentSerializer p, R.HasField t ContentSerializer p) => R.HasField t ContentSerializer p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveContentSerializerMethod t ContentSerializer, O.OverloadedMethodInfo info ContentSerializer) => OL.IsLabel t (O.MethodProxy info ContentSerializer) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ContentSerializer
type instance O.AttributeList ContentSerializer = ContentSerializerAttributeList
type ContentSerializerAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ContentSerializer = ContentSerializerSignalList
type ContentSerializerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gdk_content_serializer_get_cancellable" gdk_content_serializer_get_cancellable ::
Ptr ContentSerializer ->
IO (Ptr Gio.Cancellable.Cancellable)
contentSerializerGetCancellable ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m Gio.Cancellable.Cancellable
contentSerializerGetCancellable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m Cancellable
contentSerializerGetCancellable a
serializer = IO Cancellable -> m Cancellable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Cancellable -> m Cancellable)
-> IO Cancellable -> m Cancellable
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr Cancellable
result <- Ptr ContentSerializer -> IO (Ptr Cancellable)
gdk_content_serializer_get_cancellable Ptr ContentSerializer
serializer'
Text -> Ptr Cancellable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"contentSerializerGetCancellable" Ptr Cancellable
result
Cancellable
result' <- ((ManagedPtr Cancellable -> Cancellable)
-> Ptr Cancellable -> IO Cancellable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Cancellable -> Cancellable
Gio.Cancellable.Cancellable) Ptr Cancellable
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Cancellable -> IO Cancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Cancellable
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetCancellableMethodInfo
instance (signature ~ (m Gio.Cancellable.Cancellable), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetCancellableMethodInfo a signature where
overloadedMethod = contentSerializerGetCancellable
instance O.OverloadedMethodInfo ContentSerializerGetCancellableMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetCancellable",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetCancellable"
}
#endif
foreign import ccall "gdk_content_serializer_get_gtype" gdk_content_serializer_get_gtype ::
Ptr ContentSerializer ->
IO CGType
contentSerializerGetGtype ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m GType
contentSerializerGetGtype :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m GType
contentSerializerGetGtype a
serializer = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
CGType
result <- Ptr ContentSerializer -> IO CGType
gdk_content_serializer_get_gtype Ptr ContentSerializer
serializer'
let result' :: GType
result' = CGType -> GType
GType CGType
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetGtypeMethodInfo
instance (signature ~ (m GType), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetGtypeMethodInfo a signature where
overloadedMethod = contentSerializerGetGtype
instance O.OverloadedMethodInfo ContentSerializerGetGtypeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetGtype",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetGtype"
}
#endif
foreign import ccall "gdk_content_serializer_get_mime_type" gdk_content_serializer_get_mime_type ::
Ptr ContentSerializer ->
IO CString
contentSerializerGetMimeType ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m T.Text
contentSerializerGetMimeType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m Text
contentSerializerGetMimeType a
serializer = 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 ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
CString
result <- Ptr ContentSerializer -> IO CString
gdk_content_serializer_get_mime_type Ptr ContentSerializer
serializer'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"contentSerializerGetMimeType" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetMimeTypeMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetMimeTypeMethodInfo a signature where
overloadedMethod = contentSerializerGetMimeType
instance O.OverloadedMethodInfo ContentSerializerGetMimeTypeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetMimeType",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetMimeType"
}
#endif
foreign import ccall "gdk_content_serializer_get_output_stream" gdk_content_serializer_get_output_stream ::
Ptr ContentSerializer ->
IO (Ptr Gio.OutputStream.OutputStream)
contentSerializerGetOutputStream ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m Gio.OutputStream.OutputStream
contentSerializerGetOutputStream :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m OutputStream
contentSerializerGetOutputStream a
serializer = IO OutputStream -> m OutputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO OutputStream -> m OutputStream)
-> IO OutputStream -> m OutputStream
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr OutputStream
result <- Ptr ContentSerializer -> IO (Ptr OutputStream)
gdk_content_serializer_get_output_stream Ptr ContentSerializer
serializer'
Text -> Ptr OutputStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"contentSerializerGetOutputStream" Ptr OutputStream
result
OutputStream
result' <- ((ManagedPtr OutputStream -> OutputStream)
-> Ptr OutputStream -> IO OutputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr OutputStream -> OutputStream
Gio.OutputStream.OutputStream) Ptr OutputStream
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
OutputStream -> IO OutputStream
forall (m :: * -> *) a. Monad m => a -> m a
return OutputStream
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetOutputStreamMethodInfo
instance (signature ~ (m Gio.OutputStream.OutputStream), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetOutputStreamMethodInfo a signature where
overloadedMethod = contentSerializerGetOutputStream
instance O.OverloadedMethodInfo ContentSerializerGetOutputStreamMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetOutputStream",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetOutputStream"
}
#endif
foreign import ccall "gdk_content_serializer_get_priority" gdk_content_serializer_get_priority ::
Ptr ContentSerializer ->
IO Int32
contentSerializerGetPriority ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m Int32
contentSerializerGetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m Int32
contentSerializerGetPriority a
serializer = 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
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Int32
result <- Ptr ContentSerializer -> IO Int32
gdk_content_serializer_get_priority Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetPriorityMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetPriorityMethodInfo a signature where
overloadedMethod = contentSerializerGetPriority
instance O.OverloadedMethodInfo ContentSerializerGetPriorityMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetPriority",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetPriority"
}
#endif
foreign import ccall "gdk_content_serializer_get_task_data" gdk_content_serializer_get_task_data ::
Ptr ContentSerializer ->
IO (Ptr ())
contentSerializerGetTaskData ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m (Ptr ())
contentSerializerGetTaskData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m (Ptr ())
contentSerializerGetTaskData a
serializer = 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
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr ()
result <- Ptr ContentSerializer -> IO (Ptr ())
gdk_content_serializer_get_task_data Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetTaskDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetTaskDataMethodInfo a signature where
overloadedMethod = contentSerializerGetTaskData
instance O.OverloadedMethodInfo ContentSerializerGetTaskDataMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetTaskData",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetTaskData"
}
#endif
foreign import ccall "gdk_content_serializer_get_user_data" gdk_content_serializer_get_user_data ::
Ptr ContentSerializer ->
IO (Ptr ())
contentSerializerGetUserData ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m (Ptr ())
contentSerializerGetUserData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m (Ptr ())
contentSerializerGetUserData a
serializer = 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
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr ()
result <- Ptr ContentSerializer -> IO (Ptr ())
gdk_content_serializer_get_user_data Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetUserDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetUserDataMethodInfo a signature where
overloadedMethod = contentSerializerGetUserData
instance O.OverloadedMethodInfo ContentSerializerGetUserDataMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetUserData",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetUserData"
}
#endif
foreign import ccall "gdk_content_serializer_get_value" gdk_content_serializer_get_value ::
Ptr ContentSerializer ->
IO (Ptr GValue)
contentSerializerGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m GValue
contentSerializerGetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m GValue
contentSerializerGetValue a
serializer = IO GValue -> m GValue
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr GValue
result <- Ptr ContentSerializer -> IO (Ptr GValue)
gdk_content_serializer_get_value Ptr ContentSerializer
serializer'
Text -> Ptr GValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"contentSerializerGetValue" Ptr GValue
result
GValue
result' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
GValue -> IO GValue
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result'
#if defined(ENABLE_OVERLOADING)
data ContentSerializerGetValueMethodInfo
instance (signature ~ (m GValue), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerGetValueMethodInfo a signature where
overloadedMethod = contentSerializerGetValue
instance O.OverloadedMethodInfo ContentSerializerGetValueMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerGetValue",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerGetValue"
}
#endif
foreign import ccall "gdk_content_serializer_return_error" gdk_content_serializer_return_error ::
Ptr ContentSerializer ->
Ptr GError ->
IO ()
contentSerializerReturnError ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> GError
-> m ()
contentSerializerReturnError :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> GError -> m ()
contentSerializerReturnError a
serializer GError
error_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
Ptr ContentSerializer -> Ptr GError -> IO ()
gdk_content_serializer_return_error Ptr ContentSerializer
serializer' Ptr GError
error_'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContentSerializerReturnErrorMethodInfo
instance (signature ~ (GError -> m ()), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerReturnErrorMethodInfo a signature where
overloadedMethod = contentSerializerReturnError
instance O.OverloadedMethodInfo ContentSerializerReturnErrorMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerReturnError",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerReturnError"
}
#endif
foreign import ccall "gdk_content_serializer_return_success" gdk_content_serializer_return_success ::
Ptr ContentSerializer ->
IO ()
contentSerializerReturnSuccess ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> m ()
contentSerializerReturnSuccess :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> m ()
contentSerializerReturnSuccess a
serializer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr ContentSerializer -> IO ()
gdk_content_serializer_return_success Ptr ContentSerializer
serializer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContentSerializerReturnSuccessMethodInfo
instance (signature ~ (m ()), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerReturnSuccessMethodInfo a signature where
overloadedMethod = contentSerializerReturnSuccess
instance O.OverloadedMethodInfo ContentSerializerReturnSuccessMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerReturnSuccess",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerReturnSuccess"
}
#endif
foreign import ccall "gdk_content_serializer_set_task_data" gdk_content_serializer_set_task_data ::
Ptr ContentSerializer ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
contentSerializerSetTaskData ::
(B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
a
-> Ptr ()
-> GLib.Callbacks.DestroyNotify
-> m ()
contentSerializerSetTaskData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
a -> Ptr () -> DestroyNotify -> m ()
contentSerializerSetTaskData a
serializer Ptr ()
data_ DestroyNotify
notify = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
Ptr (FunPtr DestroyNotify)
ptrnotify <- IO (Ptr (FunPtr DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
notify' <- DestroyNotify -> IO (FunPtr DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr DestroyNotify))
-> DestroyNotify -> DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr DestroyNotify) -> Maybe (Ptr (FunPtr DestroyNotify))
forall a. a -> Maybe a
Just Ptr (FunPtr DestroyNotify)
ptrnotify) DestroyNotify
notify)
Ptr (FunPtr DestroyNotify) -> FunPtr DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrnotify FunPtr DestroyNotify
notify'
Ptr ContentSerializer -> Ptr () -> FunPtr DestroyNotify -> IO ()
gdk_content_serializer_set_task_data Ptr ContentSerializer
serializer' Ptr ()
data_ FunPtr DestroyNotify
notify'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ContentSerializerSetTaskDataMethodInfo
instance (signature ~ (Ptr () -> GLib.Callbacks.DestroyNotify -> m ()), MonadIO m, IsContentSerializer a) => O.OverloadedMethod ContentSerializerSetTaskDataMethodInfo a signature where
overloadedMethod = contentSerializerSetTaskData
instance O.OverloadedMethodInfo ContentSerializerSetTaskDataMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gdk.Objects.ContentSerializer.contentSerializerSetTaskData",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gdk-4.0.3/docs/GI-Gdk-Objects-ContentSerializer.html#v:contentSerializerSetTaskData"
}
#endif