{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A GdkContentSerializer is used to serialize content for inter-application
-- data transfers.

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

module GI.Gdk.Objects.ContentSerializer
    ( 

-- * Exported types
    ContentSerializer(..)                   ,
    IsContentSerializer                     ,
    toContentSerializer                     ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveContentSerializerMethod          ,
#endif


-- ** getCancellable #method:getCancellable#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetCancellableMethodInfo,
#endif
    contentSerializerGetCancellable         ,


-- ** getGtype #method:getGtype#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetGtypeMethodInfo     ,
#endif
    contentSerializerGetGtype               ,


-- ** getMimeType #method:getMimeType#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetMimeTypeMethodInfo  ,
#endif
    contentSerializerGetMimeType            ,


-- ** getOutputStream #method:getOutputStream#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetOutputStreamMethodInfo,
#endif
    contentSerializerGetOutputStream        ,


-- ** getPriority #method:getPriority#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetPriorityMethodInfo  ,
#endif
    contentSerializerGetPriority            ,


-- ** getTaskData #method:getTaskData#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetTaskDataMethodInfo  ,
#endif
    contentSerializerGetTaskData            ,


-- ** getUserData #method:getUserData#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetUserDataMethodInfo  ,
#endif
    contentSerializerGetUserData            ,


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerGetValueMethodInfo     ,
#endif
    contentSerializerGetValue               ,


-- ** returnError #method:returnError#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerReturnErrorMethodInfo  ,
#endif
    contentSerializerReturnError            ,


-- ** returnSuccess #method:returnSuccess#

#if defined(ENABLE_OVERLOADING)
    ContentSerializerReturnSuccessMethodInfo,
#endif
    contentSerializerReturnSuccess          ,


-- ** setTaskData #method:setTaskData#

#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.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 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

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

-- | Convert 'ContentSerializer' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue ContentSerializer where
    toGValue :: ContentSerializer -> IO GValue
toGValue ContentSerializer
o = do
        GType
gtype <- IO GType
c_gdk_content_serializer_get_type
        ContentSerializer
-> (Ptr ContentSerializer -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ContentSerializer
o (GType
-> (GValue -> Ptr ContentSerializer -> IO ())
-> Ptr ContentSerializer
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ContentSerializer -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO ContentSerializer
fromGValue GValue
gv = do
        Ptr ContentSerializer
ptr <- GValue -> IO (Ptr ContentSerializer)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr ContentSerializer)
        (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
        
    

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

-- | Cast to `ContentSerializer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toContentSerializer :: (MonadIO m, IsContentSerializer o) => o -> m ContentSerializer
toContentSerializer :: o -> m ContentSerializer
toContentSerializer = IO ContentSerializer -> m ContentSerializer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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'
unsafeCastTo ManagedPtr ContentSerializer -> ContentSerializer
ContentSerializer

#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.MethodInfo 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

#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

-- method ContentSerializer::get_cancellable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Cancellable" })
-- throws : False
-- Skip return : False

foreign import ccall "gdk_content_serializer_get_cancellable" gdk_content_serializer_get_cancellable :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO (Ptr Gio.Cancellable.Cancellable)

-- | Gets the cancellable that was passed to 'GI.Gdk.Functions.contentSerializeAsync'.
contentSerializerGetCancellable ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m Gio.Cancellable.Cancellable
    -- ^ __Returns:__ the cancellable for the current operation
contentSerializerGetCancellable :: 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.MethodInfo ContentSerializerGetCancellableMethodInfo a signature where
    overloadedMethod = contentSerializerGetCancellable

#endif

-- method ContentSerializer::get_gtype
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_content_serializer_get_gtype" gdk_content_serializer_get_gtype :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO CGType

-- | Gets the GType to of the object to serialize.
contentSerializerGetGtype ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m GType
    -- ^ __Returns:__ the GType for the current operation
contentSerializerGetGtype :: 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.MethodInfo ContentSerializerGetGtypeMethodInfo a signature where
    overloadedMethod = contentSerializerGetGtype

#endif

-- method ContentSerializer::get_mime_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , 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 "gdk_content_serializer_get_mime_type" gdk_content_serializer_get_mime_type :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO CString

-- | Gets the mime type to serialize to.
contentSerializerGetMimeType ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m T.Text
    -- ^ __Returns:__ the mime type for the current operation
contentSerializerGetMimeType :: 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.MethodInfo ContentSerializerGetMimeTypeMethodInfo a signature where
    overloadedMethod = contentSerializerGetMimeType

#endif

-- method ContentSerializer::get_output_stream
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "OutputStream" })
-- throws : False
-- Skip return : False

foreign import ccall "gdk_content_serializer_get_output_stream" gdk_content_serializer_get_output_stream :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO (Ptr Gio.OutputStream.OutputStream)

-- | Gets the output stream that was passed to 'GI.Gdk.Functions.contentSerializeAsync'.
contentSerializerGetOutputStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m Gio.OutputStream.OutputStream
    -- ^ __Returns:__ the output stream for the current operation
contentSerializerGetOutputStream :: 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.MethodInfo ContentSerializerGetOutputStreamMethodInfo a signature where
    overloadedMethod = contentSerializerGetOutputStream

#endif

-- method ContentSerializer::get_priority
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , 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 "gdk_content_serializer_get_priority" gdk_content_serializer_get_priority :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO Int32

-- | Gets the io priority that was passed to 'GI.Gdk.Functions.contentSerializeAsync'.
contentSerializerGetPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m Int32
    -- ^ __Returns:__ the io priority for the current operation
contentSerializerGetPriority :: 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.MethodInfo ContentSerializerGetPriorityMethodInfo a signature where
    overloadedMethod = contentSerializerGetPriority

#endif

-- method ContentSerializer::get_task_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_content_serializer_get_task_data" gdk_content_serializer_get_task_data :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO (Ptr ())

-- | Gets the data that was associated with /@serializer@/ via 'GI.Gdk.Objects.ContentSerializer.contentSerializerSetTaskData'.
contentSerializerGetTaskData ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m (Ptr ())
    -- ^ __Returns:__ the task data for /@serializer@/
contentSerializerGetTaskData :: 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.MethodInfo ContentSerializerGetTaskDataMethodInfo a signature where
    overloadedMethod = contentSerializerGetTaskData

#endif

-- method ContentSerializer::get_user_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_content_serializer_get_user_data" gdk_content_serializer_get_user_data :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO (Ptr ())

-- | Gets the user data that was passed when the serializer was registered.
contentSerializerGetUserData ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m (Ptr ())
    -- ^ __Returns:__ the user data for this serializer
contentSerializerGetUserData :: 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.MethodInfo ContentSerializerGetUserDataMethodInfo a signature where
    overloadedMethod = contentSerializerGetUserData

#endif

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

foreign import ccall "gdk_content_serializer_get_value" gdk_content_serializer_get_value :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO (Ptr GValue)

-- | Gets the t'GI.GObject.Structs.Value.Value' to read the object to serialize from.
contentSerializerGetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m GValue
    -- ^ __Returns:__ the t'GI.GObject.Structs.Value.Value' for the current operation
contentSerializerGetValue :: 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.MethodInfo ContentSerializerGetValueMethodInfo a signature where
    overloadedMethod = contentSerializerGetValue

#endif

-- method ContentSerializer::return_error
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "error"
--           , argType = TError
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GError" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_content_serializer_return_error" gdk_content_serializer_return_error :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    Ptr GError ->                           -- error : TError
    IO ()

-- | Indicate that the serialization has ended with an error.
-- This function consumes /@error@/.
contentSerializerReturnError ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> GError
    -- ^ /@error@/: a t'GError'
    -> m ()
contentSerializerReturnError :: 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.MethodInfo ContentSerializerReturnErrorMethodInfo a signature where
    overloadedMethod = contentSerializerReturnError

#endif

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

foreign import ccall "gdk_content_serializer_return_success" gdk_content_serializer_return_success :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    IO ()

-- | Indicate that the serialization has been successfully completed.
contentSerializerReturnSuccess ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m ()
contentSerializerReturnSuccess :: 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.MethodInfo ContentSerializerReturnSuccessMethodInfo a signature where
    overloadedMethod = contentSerializerReturnSuccess

#endif

-- method ContentSerializer::set_task_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to associate with this operation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "notify"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "destroy notify for @data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_content_serializer_set_task_data" gdk_content_serializer_set_task_data :: 
    Ptr ContentSerializer ->                -- serializer : TInterface (Name {namespace = "Gdk", name = "ContentSerializer"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Associate data with the current serialization operation.
contentSerializerSetTaskData ::
    (B.CallStack.HasCallStack, MonadIO m, IsContentSerializer a) =>
    a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> Ptr ()
    -- ^ /@data@/: data to associate with this operation
    -> GLib.Callbacks.DestroyNotify
    -- ^ /@notify@/: destroy notify for /@data@/
    -> m ()
contentSerializerSetTaskData :: 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.MethodInfo ContentSerializerSetTaskDataMethodInfo a signature where
    overloadedMethod = contentSerializerSetTaskData

#endif