    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    'GI.Gio.Objects.OutputStream.OutputStream' has functions to write to a stream ('GI.Gio.Objects.OutputStream.outputStreamWrite'),
    to close a stream ('GI.Gio.Objects.OutputStream.outputStreamClose') and to flush pending writes
    ('GI.Gio.Objects.OutputStream.outputStreamFlush').

    To copy the content of an input stream to an output stream without
    manually handling the reads and writes, use 'GI.Gio.Objects.OutputStream.outputStreamSplice'.

    See the documentation for 'GI.Gio.Objects.IOStream.IOStream' for details of thread safety of
    streaming APIs.

    All of these functions have async variants too.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.OutputStream
        (

    -- * Exported types
        OutputStream(..)                        ,
        IsOutputStream                          ,
        toOutputStream                          ,
        noOutputStream                          ,

     -- * Methods
    -- ** clearPending #method:clearPending#

    #if ENABLE_OVERLOADING
        OutputStreamClearPendingMethodInfo      ,
    #endif
        outputStreamClearPending                ,

    -- ** close #method:close#

    #if ENABLE_OVERLOADING
        OutputStreamCloseMethodInfo             ,
    #endif
        outputStreamClose                       ,

    -- ** closeAsync #method:closeAsync#

    #if ENABLE_OVERLOADING
        OutputStreamCloseAsyncMethodInfo        ,
    #endif
        outputStreamCloseAsync                  ,

    -- ** closeFinish #method:closeFinish#

    #if ENABLE_OVERLOADING
        OutputStreamCloseFinishMethodInfo       ,
    #endif
        outputStreamCloseFinish                 ,

    -- ** flush #method:flush#

    #if ENABLE_OVERLOADING
        OutputStreamFlushMethodInfo             ,
    #endif
        outputStreamFlush                       ,

    -- ** flushAsync #method:flushAsync#

    #if ENABLE_OVERLOADING
        OutputStreamFlushAsyncMethodInfo        ,
    #endif
        outputStreamFlushAsync                  ,

    -- ** flushFinish #method:flushFinish#

    #if ENABLE_OVERLOADING
        OutputStreamFlushFinishMethodInfo       ,
    #endif
        outputStreamFlushFinish                 ,

    -- ** hasPending #method:hasPending#

    #if ENABLE_OVERLOADING
        OutputStreamHasPendingMethodInfo        ,
    #endif
        outputStreamHasPending                  ,

    -- ** isClosed #method:isClosed#

    #if ENABLE_OVERLOADING
        OutputStreamIsClosedMethodInfo          ,
    #endif
        outputStreamIsClosed                    ,

    -- ** isClosing #method:isClosing#

    #if ENABLE_OVERLOADING
        OutputStreamIsClosingMethodInfo         ,
    #endif
        outputStreamIsClosing                   ,

    -- ** setPending #method:setPending#

    #if ENABLE_OVERLOADING
        OutputStreamSetPendingMethodInfo        ,
    #endif
        outputStreamSetPending                  ,

    -- ** splice #method:splice#

    #if ENABLE_OVERLOADING
        OutputStreamSpliceMethodInfo            ,
    #endif
        outputStreamSplice                      ,

    -- ** spliceAsync #method:spliceAsync#

    #if ENABLE_OVERLOADING
        OutputStreamSpliceAsyncMethodInfo       ,
    #endif
        outputStreamSpliceAsync                 ,

    -- ** spliceFinish #method:spliceFinish#

    #if ENABLE_OVERLOADING
        OutputStreamSpliceFinishMethodInfo      ,
    #endif
        outputStreamSpliceFinish                ,

    -- ** write #method:write#

    #if ENABLE_OVERLOADING
        OutputStreamWriteMethodInfo             ,
    #endif
        outputStreamWrite                       ,

    -- ** writeAll #method:writeAll#

    #if ENABLE_OVERLOADING
        OutputStreamWriteAllMethodInfo          ,
    #endif
        outputStreamWriteAll                    ,

    -- ** writeAllAsync #method:writeAllAsync#

    #if ENABLE_OVERLOADING
        OutputStreamWriteAllAsyncMethodInfo     ,
    #endif
        outputStreamWriteAllAsync               ,

    -- ** writeAllFinish #method:writeAllFinish#

    #if ENABLE_OVERLOADING
        OutputStreamWriteAllFinishMethodInfo    ,
    #endif
        outputStreamWriteAllFinish              ,

    -- ** writeAsync #method:writeAsync#

    #if ENABLE_OVERLOADING
        OutputStreamWriteAsyncMethodInfo        ,
    #endif
        outputStreamWriteAsync                  ,

    -- ** writeBytes #method:writeBytes#

    #if ENABLE_OVERLOADING
        OutputStreamWriteBytesMethodInfo        ,
    #endif
        outputStreamWriteBytes                  ,

    -- ** writeBytesAsync #method:writeBytesAsync#

    #if ENABLE_OVERLOADING
        OutputStreamWriteBytesAsyncMethodInfo   ,
    #endif
        outputStreamWriteBytesAsync             ,

    -- ** writeBytesFinish #method:writeBytesFinish#

    #if ENABLE_OVERLOADING
        OutputStreamWriteBytesFinishMethodInfo  ,
    #endif
        outputStreamWriteBytesFinish            ,

    -- ** writeFinish #method:writeFinish#

    #if ENABLE_OVERLOADING
        OutputStreamWriteFinishMethodInfo       ,
    #endif
        outputStreamWriteFinish                 ,

    -- ** writev #method:writev#

    #if ENABLE_OVERLOADING
        OutputStreamWritevMethodInfo            ,
    #endif
        outputStreamWritev                      ,

    -- ** writevAll #method:writevAll#

    #if ENABLE_OVERLOADING
        OutputStreamWritevAllMethodInfo         ,
    #endif
        outputStreamWritevAll                   ,

    -- ** writevAllAsync #method:writevAllAsync#

    #if ENABLE_OVERLOADING
        OutputStreamWritevAllAsyncMethodInfo    ,
    #endif
        outputStreamWritevAllAsync              ,

    -- ** writevAllFinish #method:writevAllFinish#

    #if ENABLE_OVERLOADING
        OutputStreamWritevAllFinishMethodInfo   ,
    #endif
        outputStreamWritevAllFinish             ,

    -- ** writevAsync #method:writevAsync#

    #if ENABLE_OVERLOADING
        OutputStreamWritevAsyncMethodInfo       ,
    #endif
        outputStreamWritevAsync                 ,

    -- ** writevFinish #method:writevFinish#

    #if ENABLE_OVERLOADING
        OutputStreamWritevFinishMethodInfo      ,
    #endif
        outputStreamWritevFinish                ,

        ) 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.ManagedPtr as B.ManagedPtr
    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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
    import {-# SOURCE #-} qualified GI.Gio.Structs.OutputVector as Gio.OutputVector

    -- | Memory-managed wrapper type.
    newtype OutputStream = OutputStream (ManagedPtr OutputStream)
    foreign import ccall "g_output_stream_get_type"
        c_g_output_stream_get_type :: IO GType

    instance GObject OutputStream where
        gobjectType _ = c_g_output_stream_get_type

    -- | Type class for types which can be safely cast to `OutputStream`, for instance with `toOutputStream`.
    class GObject o => IsOutputStream o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError OutputStream a) =>
        IsOutputStream a
    #endif
    instance IsOutputStream OutputStream
    instance GObject.Object.IsObject OutputStream

    -- | Cast to `OutputStream`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toOutputStream :: (MonadIO m, IsOutputStream o) => o -> m OutputStream
    toOutputStream = liftIO . unsafeCastTo OutputStream

    -- | A convenience alias for `Nothing` :: `Maybe` `OutputStream`.
    noOutputStream :: Maybe OutputStream
    noOutputStream = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveOutputStreamMethod (t :: Symbol) (o :: *) :: * where
        ResolveOutputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveOutputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveOutputStreamMethod "clearPending" o = OutputStreamClearPendingMethodInfo
        ResolveOutputStreamMethod "close" o = OutputStreamCloseMethodInfo
        ResolveOutputStreamMethod "closeAsync" o = OutputStreamCloseAsyncMethodInfo
        ResolveOutputStreamMethod "closeFinish" o = OutputStreamCloseFinishMethodInfo
        ResolveOutputStreamMethod "flush" o = OutputStreamFlushMethodInfo
        ResolveOutputStreamMethod "flushAsync" o = OutputStreamFlushAsyncMethodInfo
        ResolveOutputStreamMethod "flushFinish" o = OutputStreamFlushFinishMethodInfo
        ResolveOutputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveOutputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveOutputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveOutputStreamMethod "hasPending" o = OutputStreamHasPendingMethodInfo
        ResolveOutputStreamMethod "isClosed" o = OutputStreamIsClosedMethodInfo
        ResolveOutputStreamMethod "isClosing" o = OutputStreamIsClosingMethodInfo
        ResolveOutputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveOutputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveOutputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveOutputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveOutputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveOutputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveOutputStreamMethod "splice" o = OutputStreamSpliceMethodInfo
        ResolveOutputStreamMethod "spliceAsync" o = OutputStreamSpliceAsyncMethodInfo
        ResolveOutputStreamMethod "spliceFinish" o = OutputStreamSpliceFinishMethodInfo
        ResolveOutputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveOutputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveOutputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveOutputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveOutputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveOutputStreamMethod "write" o = OutputStreamWriteMethodInfo
        ResolveOutputStreamMethod "writeAll" o = OutputStreamWriteAllMethodInfo
        ResolveOutputStreamMethod "writeAllAsync" o = OutputStreamWriteAllAsyncMethodInfo
        ResolveOutputStreamMethod "writeAllFinish" o = OutputStreamWriteAllFinishMethodInfo
        ResolveOutputStreamMethod "writeAsync" o = OutputStreamWriteAsyncMethodInfo
        ResolveOutputStreamMethod "writeBytes" o = OutputStreamWriteBytesMethodInfo
        ResolveOutputStreamMethod "writeBytesAsync" o = OutputStreamWriteBytesAsyncMethodInfo
        ResolveOutputStreamMethod "writeBytesFinish" o = OutputStreamWriteBytesFinishMethodInfo
        ResolveOutputStreamMethod "writeFinish" o = OutputStreamWriteFinishMethodInfo
        ResolveOutputStreamMethod "writev" o = OutputStreamWritevMethodInfo
        ResolveOutputStreamMethod "writevAll" o = OutputStreamWritevAllMethodInfo
        ResolveOutputStreamMethod "writevAllAsync" o = OutputStreamWritevAllAsyncMethodInfo
        ResolveOutputStreamMethod "writevAllFinish" o = OutputStreamWritevAllFinishMethodInfo
        ResolveOutputStreamMethod "writevAsync" o = OutputStreamWritevAsyncMethodInfo
        ResolveOutputStreamMethod "writevFinish" o = OutputStreamWritevFinishMethodInfo
        ResolveOutputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveOutputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveOutputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveOutputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveOutputStreamMethod "setPending" o = OutputStreamSetPendingMethodInfo
        ResolveOutputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveOutputStreamMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveOutputStreamMethod t OutputStream, O.MethodInfo info OutputStream p) => O.IsLabelProxy t (OutputStream -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveOutputStreamMethod t OutputStream, O.MethodInfo info OutputStream p) => O.IsLabel t (OutputStream -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList OutputStream
    type instance O.AttributeList OutputStream = OutputStreamAttributeList
    type OutputStreamAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList OutputStream = OutputStreamSignalList
    type OutputStreamSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

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

    foreign import ccall "g_output_stream_clear_pending" g_output_stream_clear_pending ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        IO ()

    {- |
    Clears the pending flag on /@stream@/.
    -}
    outputStreamClearPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        {- ^ /@stream@/: output stream -}
        -> m ()
    outputStreamClearPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        g_output_stream_clear_pending stream'
        touchManagedPtr stream
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamClearPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsOutputStream a) => O.MethodInfo OutputStreamClearPendingMethodInfo a signature where
        overloadedMethod _ = outputStreamClearPending

    #endif

    -- method OutputStream::close
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional cancellable object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_close" g_output_stream_close ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Closes the stream, releasing resources related to it.

    Once the stream is closed, all other operations will return 'GI.Gio.Enums.IOErrorEnumClosed'.
    Closing a stream multiple times will not return an error.

    Closing a stream will automatically flush any outstanding buffers in the
    stream.

    Streams will be automatically closed when the last reference
    is dropped, but you might want to call this function to make sure
    resources are released as early as possible.

    Some streams might keep the backing store of the stream (e.g. a file descriptor)
    open after the stream is closed. See the documentation for the individual
    stream for details.

    On failure the first error that happened will be reported, but the close
    operation will finish as much as possible. A stream that failed to
    close will still return 'GI.Gio.Enums.IOErrorEnumClosed' for all operations. Still, it
    is important to check and report the error to the user, otherwise
    there might be a loss of data as all data might not be written.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    Cancelling a close will still leave the stream closed, but there some streams
    can use a faster close that doesn\'t block to e.g. check errors. On
    cancellation (as with any error) there is no guarantee that all written
    data will reach the target.
    -}
    outputStreamClose ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional cancellable object -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamClose stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_close stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamCloseMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamCloseMethodInfo a signature where
        overloadedMethod _ = outputStreamClose

    #endif

    -- method OutputStream::close_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the io priority of the request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional cancellable object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_close_async" g_output_stream_close_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Requests an asynchronous close of the stream, releasing resources
    related to it. When the operation is finished /@callback@/ will be
    called. You can then call 'GI.Gio.Objects.OutputStream.outputStreamCloseFinish' to get
    the result of the operation.

    For behaviour details see 'GI.Gio.Objects.OutputStream.outputStreamClose'.

    The asynchronous methods have a default fallback that uses threads
    to implement asynchronicity, so they are optional for inheriting
    classes. However, if you override one you must override all.
    -}
    outputStreamCloseAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional cancellable object -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    outputStreamCloseAsync stream ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_close_async stream' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamCloseAsyncMethodInfo
    instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamCloseAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamCloseAsync

    #endif

    -- method OutputStream::close_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_close_finish" g_output_stream_close_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Closes an output stream.
    -}
    outputStreamCloseFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamCloseFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_output_stream_close_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamCloseFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamCloseFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamCloseFinish

    #endif

    -- method OutputStream::flush
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional cancellable object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_flush" g_output_stream_flush ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Forces a write of all user-space buffered data for the given
    /@stream@/. Will block during the operation. Closing the stream will
    implicitly cause a flush.

    This function is optional for inherited classes.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    -}
    outputStreamFlush ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional cancellable object -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamFlush stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_flush stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamFlushMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamFlushMethodInfo a signature where
        overloadedMethod _ = outputStreamFlush

    #endif

    -- method OutputStream::flush_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the io priority of the request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_flush_async" g_output_stream_flush_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Forces an asynchronous write of all user-space buffered data for
    the given /@stream@/.
    For behaviour details see 'GI.Gio.Objects.OutputStream.outputStreamFlush'.

    When the operation is finished /@callback@/ will be
    called. You can then call 'GI.Gio.Objects.OutputStream.outputStreamFlushFinish' to get the
    result of the operation.
    -}
    outputStreamFlushAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
        -> m ()
    outputStreamFlushAsync stream ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_flush_async stream' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamFlushAsyncMethodInfo
    instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamFlushAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamFlushAsync

    #endif

    -- method OutputStream::flush_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_flush_finish" g_output_stream_flush_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finishes flushing an output stream.
    -}
    outputStreamFlushFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@result@/: a GAsyncResult. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamFlushFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_output_stream_flush_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamFlushFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamFlushFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamFlushFinish

    #endif

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

    foreign import ccall "g_output_stream_has_pending" g_output_stream_has_pending ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        IO CInt

    {- |
    Checks if an output stream has pending actions.
    -}
    outputStreamHasPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ has pending actions. -}
    outputStreamHasPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_output_stream_has_pending stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data OutputStreamHasPendingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsOutputStream a) => O.MethodInfo OutputStreamHasPendingMethodInfo a signature where
        overloadedMethod _ = outputStreamHasPending

    #endif

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

    foreign import ccall "g_output_stream_is_closed" g_output_stream_is_closed ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        IO CInt

    {- |
    Checks if an output stream has already been closed.
    -}
    outputStreamIsClosed ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ is closed. 'False' otherwise. -}
    outputStreamIsClosed stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_output_stream_is_closed stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data OutputStreamIsClosedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsOutputStream a) => O.MethodInfo OutputStreamIsClosedMethodInfo a signature where
        overloadedMethod _ = outputStreamIsClosed

    #endif

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

    foreign import ccall "g_output_stream_is_closing" g_output_stream_is_closing ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        IO CInt

    {- |
    Checks if an output stream is being closed. This can be
    used inside e.g. a flush implementation to see if the
    flush (or other i\/o operation) is called from within
    the closing operation.

    /Since: 2.24/
    -}
    outputStreamIsClosing ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ is being closed. 'False' otherwise. -}
    outputStreamIsClosing stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_output_stream_is_closing stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data OutputStreamIsClosingMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsOutputStream a) => O.MethodInfo OutputStreamIsClosingMethodInfo a signature where
        overloadedMethod _ = outputStreamIsClosing

    #endif

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

    foreign import ccall "g_output_stream_set_pending" g_output_stream_set_pending ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Sets /@stream@/ to have actions pending. If the pending flag is
    already set or /@stream@/ is closed, it will return 'False' and set
    /@error@/.
    -}
    outputStreamSetPending ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamSetPending stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        onException (do
            _ <- propagateGError $ g_output_stream_set_pending stream'
            touchManagedPtr stream
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamSetPendingMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsOutputStream a) => O.MethodInfo OutputStreamSetPendingMethodInfo a signature where
        overloadedMethod _ = outputStreamSetPending

    #endif

    -- method OutputStream::splice
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "OutputStreamSpliceFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a set of #GOutputStreamSpliceFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_splice" g_output_stream_splice ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.InputStream.InputStream ->      -- source : TInterface (Name {namespace = "Gio", name = "InputStream"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "OutputStreamSpliceFlags"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Splices an input stream into an output stream.
    -}
    outputStreamSplice ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@source@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> [Gio.Flags.OutputStreamSpliceFlags]
        {- ^ /@flags@/: a set of 'GI.Gio.Flags.OutputStreamSpliceFlags'. -}
        -> Maybe (c)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Int64
        {- ^ __Returns:__ a @/gssize/@ containing the size of the data spliced, or
        -1 if an error occurred. Note that if the number of bytes
        spliced is greater than @/G_MAXSSIZE/@, then that will be
        returned, and there is no way to determine the actual number
        of bytes spliced. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamSplice stream source flags cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        source' <- unsafeManagedPtrCastPtr source
        let flags' = gflagsToWord flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_output_stream_splice stream' source' flags' maybeCancellable
            touchManagedPtr stream
            touchManagedPtr source
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamSpliceMethodInfo
    instance (signature ~ (b -> [Gio.Flags.OutputStreamSpliceFlags] -> Maybe (c) -> m Int64), MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo OutputStreamSpliceMethodInfo a signature where
        overloadedMethod _ = outputStreamSplice

    #endif

    -- method OutputStream::splice_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "OutputStreamSpliceFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a set of #GOutputStreamSpliceFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the io priority of the request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_splice_async" g_output_stream_splice_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.InputStream.InputStream ->      -- source : TInterface (Name {namespace = "Gio", name = "InputStream"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "OutputStreamSpliceFlags"})
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Splices a stream asynchronously.
    When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.OutputStream.outputStreamSpliceFinish' to get the
    result of the operation.

    For the synchronous, blocking version of this function, see
    'GI.Gio.Objects.OutputStream.outputStreamSplice'.
    -}
    outputStreamSpliceAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@source@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> [Gio.Flags.OutputStreamSpliceFlags]
        {- ^ /@flags@/: a set of 'GI.Gio.Flags.OutputStreamSpliceFlags'. -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request. -}
        -> Maybe (c)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback'. -}
        -> m ()
    outputStreamSpliceAsync stream source flags ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        source' <- unsafeManagedPtrCastPtr source
        let flags' = gflagsToWord flags
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_splice_async stream' source' flags' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        touchManagedPtr source
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamSpliceAsyncMethodInfo
    instance (signature ~ (b -> [Gio.Flags.OutputStreamSpliceFlags] -> Int32 -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo OutputStreamSpliceAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamSpliceAsync

    #endif

    -- method OutputStream::splice_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_splice_finish" g_output_stream_splice_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Finishes an asynchronous stream splice operation.
    -}
    outputStreamSpliceFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Int64
        {- ^ __Returns:__ a @/gssize/@ of the number of bytes spliced. Note that if the
        number of bytes spliced is greater than @/G_MAXSSIZE/@, then that
        will be returned, and there is no way to determine the actual
        number of bytes spliced. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamSpliceFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_output_stream_splice_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamSpliceFinishMethodInfo
    instance (signature ~ (b -> m Int64), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamSpliceFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamSpliceFinish

    #endif

    -- method OutputStream::write
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the data to write.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional cancellable object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write" g_output_stream_write ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Tries to write /@count@/ bytes from /@buffer@/ into the stream. Will block
    during the operation.

    If count is 0, returns 0 and does nothing. A value of /@count@/
    larger than @/G_MAXSSIZE/@ will cause a 'GI.Gio.Enums.IOErrorEnumInvalidArgument' error.

    On success, the number of bytes written to the stream is returned.
    It is not an error if this is not the same as the requested size, as it
    can happen e.g. on a partial I\/O error, or if there is not enough
    storage in the stream. All writes block until at least one byte
    is written or an error occurs; 0 is never returned (unless
    /@count@/ is 0).

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned. If an
    operation was partially finished when the operation was cancelled the
    partial result will be returned, without an error.

    On error -1 is returned and /@error@/ is set accordingly.
    -}
    outputStreamWrite ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> ByteString
        {- ^ /@buffer@/: the buffer containing the data to write. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional cancellable object -}
        -> m Int64
        {- ^ __Returns:__ Number of bytes written, or -1 on error /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWrite stream buffer cancellable = liftIO $ do
        let count = fromIntegral $ B.length buffer
        stream' <- unsafeManagedPtrCastPtr stream
        buffer' <- packByteString buffer
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_output_stream_write stream' buffer' count maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem buffer'
            return result
         ) (do
            freeMem buffer'
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWriteMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> m Int64), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWriteMethodInfo a signature where
        overloadedMethod _ = outputStreamWrite

    #endif

    -- method OutputStream::write_all
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the data to write.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that was\n    written to the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_all" g_output_stream_write_all ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Tries to write /@count@/ bytes from /@buffer@/ into the stream. Will block
    during the operation.

    This function is similar to 'GI.Gio.Objects.OutputStream.outputStreamWrite', except it tries to
    write as many bytes as requested, only stopping on an error.

    On a successful write of /@count@/ bytes, 'True' is returned, and /@bytesWritten@/
    is set to /@count@/.

    If there is an error during the operation 'False' is returned and /@error@/
    is set to indicate the error status.

    As a special exception to the normal conventions for functions that
    use 'GError', if this function returns 'False' (and sets /@error@/) then
    /@bytesWritten@/ will be set to the number of bytes that were
    successfully written before the error was encountered.  This
    functionality is only available from C.  If you need it from another
    language then you must write your own loop around
    'GI.Gio.Objects.OutputStream.outputStreamWrite'.
    -}
    outputStreamWriteAll ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> ByteString
        {- ^ /@buffer@/: the buffer containing the data to write. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWriteAll stream buffer cancellable = liftIO $ do
        let count = fromIntegral $ B.length buffer
        stream' <- unsafeManagedPtrCastPtr stream
        buffer' <- packByteString buffer
        bytesWritten <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_write_all stream' buffer' count bytesWritten maybeCancellable
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem buffer'
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem buffer'
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWriteAllMethodInfo
    instance (signature ~ (ByteString -> Maybe (b) -> m (Word64)), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWriteAllMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteAll

    #endif

    -- method OutputStream::write_all_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GOutputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the data to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the io priority of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_write_all_async" g_output_stream_write_all_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Request an asynchronous write of /@count@/ bytes from /@buffer@/ into
    the stream. When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.OutputStream.outputStreamWriteAllFinish' to get the result of the
    operation.

    This is the asynchronous version of 'GI.Gio.Objects.OutputStream.outputStreamWriteAll'.

    Call 'GI.Gio.Objects.OutputStream.outputStreamWriteAllFinish' to collect the result.

    Any outstanding I\/O request with higher priority (lower numerical
    value) will be executed before an outstanding request with lower
    priority. Default priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    Note that no copy of /@buffer@/ will be made, so it must stay valid
    until /@callback@/ is called.

    /Since: 2.44/
    -}
    outputStreamWriteAllAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.OutputStream.OutputStream' -}
        -> ByteString
        {- ^ /@buffer@/: the buffer containing the data to write -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    outputStreamWriteAllAsync stream buffer ioPriority cancellable callback = liftIO $ do
        let count = fromIntegral $ B.length buffer
        stream' <- unsafeManagedPtrCastPtr stream
        buffer' <- packByteString buffer
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_write_all_async stream' buffer' count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem buffer'
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamWriteAllAsyncMethodInfo
    instance (signature ~ (ByteString -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWriteAllAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteAllAsync

    #endif

    -- method OutputStream::write_all_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that was written to the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_all_finish" g_output_stream_write_all_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finishes an asynchronous stream write operation started with
    'GI.Gio.Objects.OutputStream.outputStreamWriteAllAsync'.

    As a special exception to the normal conventions for functions that
    use 'GError', if this function returns 'False' (and sets /@error@/) then
    /@bytesWritten@/ will be set to the number of bytes that were
    successfully written before the error was encountered.  This
    functionality is only available from C.  If you need it from another
    language then you must write your own loop around
    'GI.Gio.Objects.OutputStream.outputStreamWriteAsync'.

    /Since: 2.44/
    -}
    outputStreamWriteAllFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWriteAllFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        bytesWritten <- allocMem :: IO (Ptr Word64)
        onException (do
            _ <- propagateGError $ g_output_stream_write_all_finish stream' result_' bytesWritten
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWriteAllFinishMethodInfo
    instance (signature ~ (b -> m (Word64)), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamWriteAllFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteAllFinish

    #endif

    -- method OutputStream::write_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the buffer containing the data to write.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the io priority of the request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_write_async" g_output_stream_write_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Request an asynchronous write of /@count@/ bytes from /@buffer@/ into
    the stream. When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.OutputStream.outputStreamWriteFinish' to get the result of the
    operation.

    During an async request no other sync and async calls are allowed,
    and will result in 'GI.Gio.Enums.IOErrorEnumPending' errors.

    A value of /@count@/ larger than @/G_MAXSSIZE/@ will cause a
    'GI.Gio.Enums.IOErrorEnumInvalidArgument' error.

    On success, the number of bytes written will be passed to the
    /@callback@/. It is not an error if this is not the same as the
    requested size, as it can happen e.g. on a partial I\/O error,
    but generally we try to write as many bytes as requested.

    You are guaranteed that this method will never fail with
    'GI.Gio.Enums.IOErrorEnumWouldBlock' - if /@stream@/ can\'t accept more data, the
    method will just wait until this changes.

    Any outstanding I\/O request with higher priority (lower numerical
    value) will be executed before an outstanding request with lower
    priority. Default priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    The asynchronous methods have a default fallback that uses threads
    to implement asynchronicity, so they are optional for inheriting
    classes. However, if you override one you must override all.

    For the synchronous, blocking version of this function, see
    'GI.Gio.Objects.OutputStream.outputStreamWrite'.

    Note that no copy of /@buffer@/ will be made, so it must stay valid
    until /@callback@/ is called. See 'GI.Gio.Objects.OutputStream.outputStreamWriteBytesAsync'
    for a 'GI.GLib.Structs.Bytes.Bytes' version that will automatically hold a reference to
    the contents (without copying) for the duration of the call.
    -}
    outputStreamWriteAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> Maybe (ByteString)
        {- ^ /@buffer@/: the buffer containing the data to write. -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    outputStreamWriteAsync stream buffer ioPriority cancellable callback = liftIO $ do
        let count = case buffer of
                Nothing -> 0
                Just jBuffer -> fromIntegral $ B.length jBuffer
        stream' <- unsafeManagedPtrCastPtr stream
        maybeBuffer <- case buffer of
            Nothing -> return nullPtr
            Just jBuffer -> do
                jBuffer' <- packByteString jBuffer
                return jBuffer'
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_write_async stream' maybeBuffer count ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem maybeBuffer
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamWriteAsyncMethodInfo
    instance (signature ~ (Maybe (ByteString) -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWriteAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteAsync

    #endif

    -- method OutputStream::write_bytes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GBytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional cancellable object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_bytes" g_output_stream_write_bytes ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    A wrapper function for 'GI.Gio.Objects.OutputStream.outputStreamWrite' which takes a
    'GI.GLib.Structs.Bytes.Bytes' as input.  This can be more convenient for use by language
    bindings or in other cases where the refcounted nature of 'GI.GLib.Structs.Bytes.Bytes'
    is helpful over a bare pointer interface.

    However, note that this function may still perform partial writes,
    just like 'GI.Gio.Objects.OutputStream.outputStreamWrite'.  If that occurs, to continue
    writing, you will need to create a new 'GI.GLib.Structs.Bytes.Bytes' containing just the
    remaining bytes, using 'GI.GLib.Structs.Bytes.bytesNewFromBytes'. Passing the same
    'GI.GLib.Structs.Bytes.Bytes' instance multiple times potentially can result in duplicated
    data in the output stream.
    -}
    outputStreamWriteBytes ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> GLib.Bytes.Bytes
        {- ^ /@bytes@/: the 'GI.GLib.Structs.Bytes.Bytes' to write -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional cancellable object -}
        -> m Int64
        {- ^ __Returns:__ Number of bytes written, or -1 on error /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWriteBytes stream bytes cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        bytes' <- unsafeManagedPtrGetPtr bytes
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_output_stream_write_bytes stream' bytes' maybeCancellable
            touchManagedPtr stream
            touchManagedPtr bytes
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWriteBytesMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> Maybe (b) -> m Int64), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWriteBytesMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteBytes

    #endif

    -- method OutputStream::write_bytes_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the io priority of the request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_write_bytes_async" g_output_stream_write_bytes_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    This function is similar to 'GI.Gio.Objects.OutputStream.outputStreamWriteAsync', but
    takes a 'GI.GLib.Structs.Bytes.Bytes' as input.  Due to the refcounted nature of 'GI.GLib.Structs.Bytes.Bytes',
    this allows the stream to avoid taking a copy of the data.

    However, note that this function may still perform partial writes,
    just like 'GI.Gio.Objects.OutputStream.outputStreamWriteAsync'. If that occurs, to continue
    writing, you will need to create a new 'GI.GLib.Structs.Bytes.Bytes' containing just the
    remaining bytes, using 'GI.GLib.Structs.Bytes.bytesNewFromBytes'. Passing the same
    'GI.GLib.Structs.Bytes.Bytes' instance multiple times potentially can result in duplicated
    data in the output stream.

    For the synchronous, blocking version of this function, see
    'GI.Gio.Objects.OutputStream.outputStreamWriteBytes'.
    -}
    outputStreamWriteBytesAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> GLib.Bytes.Bytes
        {- ^ /@bytes@/: The bytes to write -}
        -> Int32
        {- ^ /@ioPriority@/: the io priority of the request. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    outputStreamWriteBytesAsync stream bytes ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        bytes' <- unsafeManagedPtrGetPtr bytes
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_write_bytes_async stream' bytes' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        touchManagedPtr bytes
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamWriteBytesAsyncMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWriteBytesAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteBytesAsync

    #endif

    -- method OutputStream::write_bytes_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_bytes_finish" g_output_stream_write_bytes_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Finishes a stream write-from-'GI.GLib.Structs.Bytes.Bytes' operation.
    -}
    outputStreamWriteBytesFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Int64
        {- ^ __Returns:__ a @/gssize/@ containing the number of bytes written to the stream. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWriteBytesFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_output_stream_write_bytes_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWriteBytesFinishMethodInfo
    instance (signature ~ (b -> m Int64), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamWriteBytesFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteBytesFinish

    #endif

    -- method OutputStream::write_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_write_finish" g_output_stream_write_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Finishes a stream write operation.
    -}
    outputStreamWriteFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Int64
        {- ^ __Returns:__ a @/gssize/@ containing the number of bytes written to the stream. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWriteFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_output_stream_write_finish stream' result_'
            touchManagedPtr stream
            touchManagedPtr result_
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWriteFinishMethodInfo
    instance (signature ~ (b -> m Int64), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamWriteFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamWriteFinish

    #endif

    -- method OutputStream::writev
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vectors", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the #GOutputVectors to write.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that were\n    written to the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional cancellable object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev" g_output_stream_writev ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        Word64 ->                               -- n_vectors : TBasicType TUInt64
        Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Tries to write the bytes contained in the /@nVectors@/ /@vectors@/ into the
    stream. Will block during the operation.

    If /@nVectors@/ is 0 or the sum of all bytes in /@vectors@/ is 0, returns 0 and
    does nothing.

    On success, the number of bytes written to the stream is returned.
    It is not an error if this is not the same as the requested size, as it
    can happen e.g. on a partial I\/O error, or if there is not enough
    storage in the stream. All writes block until at least one byte
    is written or an error occurs; 0 is never returned (unless
    /@nVectors@/ is 0 or the sum of all bytes in /@vectors@/ is 0).

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned. If an
    operation was partially finished when the operation was cancelled the
    partial result will be returned, without an error.

    Some implementations of 'GI.Gio.Objects.OutputStream.outputStreamWritev' may have limitations on the
    aggregate buffer size, and will return 'GI.Gio.Enums.IOErrorEnumInvalidArgument' if these
    are exceeded. For example, when writing to a local file on UNIX platforms,
    the aggregate buffer size must not exceed @/G_MAXSSIZE/@ bytes.

    /Since: 2.60/
    -}
    outputStreamWritev ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> [Gio.OutputVector.OutputVector]
        {- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional cancellable object -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWritev stream vectors cancellable = liftIO $ do
        let nVectors = fromIntegral $ length vectors
        stream' <- unsafeManagedPtrCastPtr stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        bytesWritten <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_writev stream' vectors'' nVectors bytesWritten maybeCancellable
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            mapM_ touchManagedPtr vectors
            whenJust cancellable touchManagedPtr
            freeMem vectors''
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem vectors''
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWritevMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Maybe (b) -> m (Word64)), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWritevMethodInfo a signature where
        overloadedMethod _ = outputStreamWritev

    #endif

    -- method OutputStream::writev_all
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vectors", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the #GOutputVectors to write.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that were\n    written to the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_all" g_output_stream_writev_all ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        Word64 ->                               -- n_vectors : TBasicType TUInt64
        Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Tries to write the bytes contained in the /@nVectors@/ /@vectors@/ into the
    stream. Will block during the operation.

    This function is similar to 'GI.Gio.Objects.OutputStream.outputStreamWritev', except it tries to
    write as many bytes as requested, only stopping on an error.

    On a successful write of all /@nVectors@/ vectors, 'True' is returned, and
    /@bytesWritten@/ is set to the sum of all the sizes of /@vectors@/.

    If there is an error during the operation 'False' is returned and /@error@/
    is set to indicate the error status.

    As a special exception to the normal conventions for functions that
    use 'GError', if this function returns 'False' (and sets /@error@/) then
    /@bytesWritten@/ will be set to the number of bytes that were
    successfully written before the error was encountered.  This
    functionality is only available from C. If you need it from another
    language then you must write your own loop around
    'GI.Gio.Objects.OutputStream.outputStreamWrite'.

    The content of the individual elements of /@vectors@/ might be changed by this
    function.

    /Since: 2.60/
    -}
    outputStreamWritevAll ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> [Gio.OutputVector.OutputVector]
        {- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWritevAll stream vectors cancellable = liftIO $ do
        let nVectors = fromIntegral $ length vectors
        stream' <- unsafeManagedPtrCastPtr stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        bytesWritten <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_output_stream_writev_all stream' vectors'' nVectors bytesWritten maybeCancellable
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            mapM_ touchManagedPtr vectors
            whenJust cancellable touchManagedPtr
            freeMem vectors''
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem vectors''
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWritevAllMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Maybe (b) -> m (Word64)), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWritevAllMethodInfo a signature where
        overloadedMethod _ = outputStreamWritevAll

    #endif

    -- method OutputStream::writev_all_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GOutputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vectors", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the #GOutputVectors to write.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the I/O priority of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_all_async" g_output_stream_writev_all_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        Word64 ->                               -- n_vectors : TBasicType TUInt64
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Request an asynchronous write of the bytes contained in the /@nVectors@/ /@vectors@/ into
    the stream. When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.OutputStream.outputStreamWritevAllFinish' to get the result of the
    operation.

    This is the asynchronous version of 'GI.Gio.Objects.OutputStream.outputStreamWritevAll'.

    Call 'GI.Gio.Objects.OutputStream.outputStreamWritevAllFinish' to collect the result.

    Any outstanding I\/O request with higher priority (lower numerical
    value) will be executed before an outstanding request with lower
    priority. Default priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    Note that no copy of /@vectors@/ will be made, so it must stay valid
    until /@callback@/ is called. The content of the individual elements
    of /@vectors@/ might be changed by this function.

    /Since: 2.60/
    -}
    outputStreamWritevAllAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.OutputStream.OutputStream' -}
        -> [Gio.OutputVector.OutputVector]
        {- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write. -}
        -> Int32
        {- ^ /@ioPriority@/: the I\/O priority of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    outputStreamWritevAllAsync stream vectors ioPriority cancellable callback = liftIO $ do
        let nVectors = fromIntegral $ length vectors
        stream' <- unsafeManagedPtrCastPtr stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_writev_all_async stream' vectors'' nVectors ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        mapM_ touchManagedPtr vectors
        whenJust cancellable touchManagedPtr
        freeMem vectors''
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamWritevAllAsyncMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWritevAllAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamWritevAllAsync

    #endif

    -- method OutputStream::writev_all_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that were written to the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_all_finish" g_output_stream_writev_all_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finishes an asynchronous stream write operation started with
    'GI.Gio.Objects.OutputStream.outputStreamWritevAllAsync'.

    As a special exception to the normal conventions for functions that
    use 'GError', if this function returns 'False' (and sets /@error@/) then
    /@bytesWritten@/ will be set to the number of bytes that were
    successfully written before the error was encountered.  This
    functionality is only available from C.  If you need it from another
    language then you must write your own loop around
    'GI.Gio.Objects.OutputStream.outputStreamWritevAsync'.

    /Since: 2.60/
    -}
    outputStreamWritevAllFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream' -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWritevAllFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        bytesWritten <- allocMem :: IO (Ptr Word64)
        onException (do
            _ <- propagateGError $ g_output_stream_writev_all_finish stream' result_' bytesWritten
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWritevAllFinishMethodInfo
    instance (signature ~ (b -> m (Word64)), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamWritevAllFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamWritevAllFinish

    #endif

    -- method OutputStream::writev_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vectors", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the #GOutputVectors to write.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the I/O priority of the request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "n_vectors", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of vectors to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_async" g_output_stream_writev_async ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.OutputVector.OutputVector ->    -- vectors : TCArray False (-1) 2 (TInterface (Name {namespace = "Gio", name = "OutputVector"}))
        Word64 ->                               -- n_vectors : TBasicType TUInt64
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Request an asynchronous write of the bytes contained in /@nVectors@/ /@vectors@/ into
    the stream. When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.OutputStream.outputStreamWritevFinish' to get the result of the
    operation.

    During an async request no other sync and async calls are allowed,
    and will result in 'GI.Gio.Enums.IOErrorEnumPending' errors.

    On success, the number of bytes written will be passed to the
    /@callback@/. It is not an error if this is not the same as the
    requested size, as it can happen e.g. on a partial I\/O error,
    but generally we try to write as many bytes as requested.

    You are guaranteed that this method will never fail with
    'GI.Gio.Enums.IOErrorEnumWouldBlock' — if /@stream@/ can\'t accept more data, the
    method will just wait until this changes.

    Any outstanding I\/O request with higher priority (lower numerical
    value) will be executed before an outstanding request with lower
    priority. Default priority is 'GI.GLib.Constants.PRIORITY_DEFAULT'.

    The asynchronous methods have a default fallback that uses threads
    to implement asynchronicity, so they are optional for inheriting
    classes. However, if you override one you must override all.

    For the synchronous, blocking version of this function, see
    'GI.Gio.Objects.OutputStream.outputStreamWritev'.

    Note that no copy of /@vectors@/ will be made, so it must stay valid
    until /@callback@/ is called.

    /Since: 2.60/
    -}
    outputStreamWritevAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: A 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> [Gio.OutputVector.OutputVector]
        {- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write. -}
        -> Int32
        {- ^ /@ioPriority@/: the I\/O priority of the request. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    outputStreamWritevAsync stream vectors ioPriority cancellable callback = liftIO $ do
        let nVectors = fromIntegral $ length vectors
        stream' <- unsafeManagedPtrCastPtr stream
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_output_stream_writev_async stream' vectors'' nVectors ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        mapM_ touchManagedPtr vectors
        whenJust cancellable touchManagedPtr
        freeMem vectors''
        return ()

    #if ENABLE_OVERLOADING
    data OutputStreamWritevAsyncMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo OutputStreamWritevAsyncMethodInfo a signature where
        overloadedMethod _ = outputStreamWritevAsync

    #endif

    -- method OutputStream::writev_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of bytes that were written to the stream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_output_stream_writev_finish" g_output_stream_writev_finish ::
        Ptr OutputStream ->                     -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Finishes a stream writev operation.

    /Since: 2.60/
    -}
    outputStreamWritevFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m (Word64)
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    outputStreamWritevFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        bytesWritten <- allocMem :: IO (Ptr Word64)
        onException (do
            _ <- propagateGError $ g_output_stream_writev_finish stream' result_' bytesWritten
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem bytesWritten
            return bytesWritten'
         ) (do
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data OutputStreamWritevFinishMethodInfo
    instance (signature ~ (b -> m (Word64)), MonadIO m, IsOutputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo OutputStreamWritevFinishMethodInfo a signature where
        overloadedMethod _ = outputStreamWritevFinish

    #endif