    {- |
    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.Interfaces.PollableOutputStream.PollableOutputStream' is implemented by @/GOutputStreams/@ that
    can be polled for readiness to write. This can be used when
    interfacing with a non-GIO API that expects
    UNIX-file-descriptor-style asynchronous I\/O rather than GIO-style.

    /Since: 2.28/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Interfaces.PollableOutputStream
        (

    -- * Exported types
        PollableOutputStream(..)                ,
        noPollableOutputStream                  ,
        IsPollableOutputStream                  ,
        toPollableOutputStream                  ,

     -- * Methods
    -- ** canPoll #method:canPoll#

    #if ENABLE_OVERLOADING
        PollableOutputStreamCanPollMethodInfo   ,
    #endif
        pollableOutputStreamCanPoll             ,

    -- ** createSource #method:createSource#

    #if ENABLE_OVERLOADING
        PollableOutputStreamCreateSourceMethodInfo,
    #endif
        pollableOutputStreamCreateSource        ,

    -- ** isWritable #method:isWritable#

    #if ENABLE_OVERLOADING
        PollableOutputStreamIsWritableMethodInfo,
    #endif
        pollableOutputStreamIsWritable          ,

    -- ** writeNonblocking #method:writeNonblocking#

    #if ENABLE_OVERLOADING
        PollableOutputStreamWriteNonblockingMethodInfo,
    #endif
        pollableOutputStreamWriteNonblocking    ,

    -- ** writevNonblocking #method:writevNonblocking#

    #if ENABLE_OVERLOADING
        PollableOutputStreamWritevNonblockingMethodInfo,
    #endif
        pollableOutputStreamWritevNonblocking   ,

        ) 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.Source as GLib.Source
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
    import {-# SOURCE #-} qualified GI.Gio.Structs.OutputVector as Gio.OutputVector

    -- interface PollableOutputStream
    -- | Memory-managed wrapper type.
    newtype PollableOutputStream = PollableOutputStream (ManagedPtr PollableOutputStream)
    -- | A convenience alias for `Nothing` :: `Maybe` `PollableOutputStream`.
    noPollableOutputStream :: Maybe PollableOutputStream
    noPollableOutputStream = Nothing

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

    #endif

    foreign import ccall "g_pollable_output_stream_get_type"
        c_g_pollable_output_stream_get_type :: IO GType

    instance GObject PollableOutputStream where
        gobjectType _ = c_g_pollable_output_stream_get_type

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

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

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

    #if ENABLE_OVERLOADING
    #endif

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

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolvePollableOutputStreamMethod t PollableOutputStream, O.MethodInfo info PollableOutputStream p) => O.IsLabel t (PollableOutputStream -> 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

    -- method PollableOutputStream::can_poll
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableOutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableOutputStream.", 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_pollable_output_stream_can_poll" g_pollable_output_stream_can_poll ::
        Ptr PollableOutputStream ->             -- stream : TInterface (Name {namespace = "Gio", name = "PollableOutputStream"})
        IO CInt

    {- |
    Checks if /@stream@/ is actually pollable. Some classes may implement
    'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream' but have only certain instances of that
    class be pollable. If this method returns 'False', then the behavior
    of other 'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream' methods is undefined.

    For any given stream, the value returned by this method is constant;
    a stream cannot switch from pollable to non-pollable or vice versa.

    /Since: 2.28/
    -}
    pollableOutputStreamCanPoll ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableOutputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ is pollable, 'False' if not. -}
    pollableOutputStreamCanPoll stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_pollable_output_stream_can_poll stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data PollableOutputStreamCanPollMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsPollableOutputStream a) => O.MethodInfo PollableOutputStreamCanPollMethodInfo a signature where
        overloadedMethod _ = pollableOutputStreamCanPoll

    #endif

    -- method PollableOutputStream::create_source
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableOutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableOutputStream.", 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 "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "Source"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_pollable_output_stream_create_source" g_pollable_output_stream_create_source ::
        Ptr PollableOutputStream ->             -- stream : TInterface (Name {namespace = "Gio", name = "PollableOutputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        IO (Ptr GLib.Source.Source)

    {- |
    Creates a 'GI.GLib.Structs.Source.Source' that triggers when /@stream@/ can be written, or
    /@cancellable@/ is triggered or an error occurs. The callback on the
    source is of the 'GI.Gio.Callbacks.PollableSourceFunc' type.

    As with 'GI.Gio.Interfaces.PollableOutputStream.pollableOutputStreamIsWritable', it is possible that
    the stream may not actually be writable even after the source
    triggers, so you should use 'GI.Gio.Interfaces.PollableOutputStream.pollableOutputStreamWriteNonblocking'
    rather than 'GI.Gio.Objects.OutputStream.outputStreamWrite' from the callback.

    /Since: 2.28/
    -}
    pollableOutputStreamCreateSource ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m GLib.Source.Source
        {- ^ __Returns:__ a new 'GI.GLib.Structs.Source.Source' -}
    pollableOutputStreamCreateSource stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        result <- g_pollable_output_stream_create_source stream' maybeCancellable
        checkUnexpectedReturnNULL "pollableOutputStreamCreateSource" result
        result' <- (wrapBoxed GLib.Source.Source) result
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return result'

    #if ENABLE_OVERLOADING
    data PollableOutputStreamCreateSourceMethodInfo
    instance (signature ~ (Maybe (b) -> m GLib.Source.Source), MonadIO m, IsPollableOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo PollableOutputStreamCreateSourceMethodInfo a signature where
        overloadedMethod _ = pollableOutputStreamCreateSource

    #endif

    -- method PollableOutputStream::is_writable
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableOutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableOutputStream.", 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_pollable_output_stream_is_writable" g_pollable_output_stream_is_writable ::
        Ptr PollableOutputStream ->             -- stream : TInterface (Name {namespace = "Gio", name = "PollableOutputStream"})
        IO CInt

    {- |
    Checks if /@stream@/ can be written.

    Note that some stream types may not be able to implement this 100%
    reliably, and it is possible that a call to 'GI.Gio.Objects.OutputStream.outputStreamWrite'
    after this returns 'True' would still block. To guarantee
    non-blocking behavior, you should always use
    'GI.Gio.Interfaces.PollableOutputStream.pollableOutputStreamWriteNonblocking', which will return a
    'GI.Gio.Enums.IOErrorEnumWouldBlock' error rather than blocking.

    /Since: 2.28/
    -}
    pollableOutputStreamIsWritable ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableOutputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ is writable, 'False' if not. If an error
      has occurred on /@stream@/, this will result in
      'GI.Gio.Interfaces.PollableOutputStream.pollableOutputStreamIsWritable' returning 'True', and the
      next attempt to write will return the error. -}
    pollableOutputStreamIsWritable stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_pollable_output_stream_is_writable stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data PollableOutputStreamIsWritableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsPollableOutputStream a) => O.MethodInfo PollableOutputStreamIsWritableMethodInfo a signature where
        overloadedMethod _ = pollableOutputStreamIsWritable

    #endif

    -- method PollableOutputStream::write_nonblocking
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableOutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableOutputStream", 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 "a buffer to write\n    data from", 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 you want 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 "a #GCancellable, or %NULL", 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 you want 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_pollable_output_stream_write_nonblocking" g_pollable_output_stream_write_nonblocking ::
        Ptr PollableOutputStream ->             -- stream : TInterface (Name {namespace = "Gio", name = "PollableOutputStream"})
        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

    {- |
    Attempts to write up to /@count@/ bytes from /@buffer@/ to /@stream@/, as
    with 'GI.Gio.Objects.OutputStream.outputStreamWrite'. If /@stream@/ is not currently writable,
    this will immediately return 'GI.Gio.Enums.IOErrorEnumWouldBlock', and you can
    use 'GI.Gio.Interfaces.PollableOutputStream.pollableOutputStreamCreateSource' to create a 'GI.GLib.Structs.Source.Source'
    that will be triggered when /@stream@/ is writable.

    Note that since this method never blocks, you cannot actually
    use /@cancellable@/ to cancel it. However, it will return an error
    if /@cancellable@/ has already been cancelled when you call, which
    may happen if you call this method after a source triggers due
    to having been cancelled.

    Also note that if 'GI.Gio.Enums.IOErrorEnumWouldBlock' is returned some underlying
    transports like D\/TLS require that you re-send the same /@buffer@/ and
    /@count@/ in the next write call.
    -}
    pollableOutputStreamWriteNonblocking ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream' -}
        -> Maybe (ByteString)
        {- ^ /@buffer@/: a buffer to write
        data from -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m Int64
        {- ^ __Returns:__ the number of bytes written, or -1 on error (including
      'GI.Gio.Enums.IOErrorEnumWouldBlock'). /(Can throw 'Data.GI.Base.GError.GError')/ -}
    pollableOutputStreamWriteNonblocking stream buffer cancellable = 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'
        onException (do
            result <- propagateGError $ g_pollable_output_stream_write_nonblocking stream' maybeBuffer count maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem maybeBuffer
            return result
         ) (do
            freeMem maybeBuffer
         )

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

    #endif

    -- method PollableOutputStream::writev_nonblocking
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableOutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableOutputStream", 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 "a #GCancellable, or %NULL", 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 (TInterface (Name {namespace = "Gio", name = "PollableReturn"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_pollable_output_stream_writev_nonblocking" g_pollable_output_stream_writev_nonblocking ::
        Ptr PollableOutputStream ->             -- stream : TInterface (Name {namespace = "Gio", name = "PollableOutputStream"})
        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

    {- |
    Attempts to write the bytes contained in the /@nVectors@/ /@vectors@/ to /@stream@/,
    as with 'GI.Gio.Objects.OutputStream.outputStreamWritev'. If /@stream@/ is not currently writable,
    this will immediately return %/@gPOLLABLERETURNWOULDBLOCK@/, and you can
    use 'GI.Gio.Interfaces.PollableOutputStream.pollableOutputStreamCreateSource' to create a 'GI.GLib.Structs.Source.Source'
    that will be triggered when /@stream@/ is writable. /@error@/ will *not* be
    set in that case.

    Note that since this method never blocks, you cannot actually
    use /@cancellable@/ to cancel it. However, it will return an error
    if /@cancellable@/ has already been cancelled when you call, which
    may happen if you call this method after a source triggers due
    to having been cancelled.

    Also note that if 'GI.Gio.Enums.PollableReturnWouldBlock' is returned some underlying
    transports like D\/TLS require that you re-send the same /@vectors@/ and
    /@nVectors@/ in the next write call.

    /Since: 2.60/
    -}
    pollableOutputStreamWritevNonblocking ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableOutputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream' -}
        -> [Gio.OutputVector.OutputVector]
        {- ^ /@vectors@/: the buffer containing the @/GOutputVectors/@ to write. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m ((Gio.Enums.PollableReturn, Word64))
        {- ^ __Returns:__ %/@gPOLLABLERETURNOK@/ on success, 'GI.Gio.Enums.PollableReturnWouldBlock'
    if the stream is not currently writable (and /@error@/ is *not* set), or
    'GI.Gio.Enums.PollableReturnFailed' if there was an error in which case /@error@/ will
    be set. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    pollableOutputStreamWritevNonblocking 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
            result <- propagateGError $ g_pollable_output_stream_writev_nonblocking stream' vectors'' nVectors bytesWritten maybeCancellable
            let result' = (toEnum . fromIntegral) result
            bytesWritten' <- peek bytesWritten
            touchManagedPtr stream
            mapM_ touchManagedPtr vectors
            whenJust cancellable touchManagedPtr
            freeMem vectors''
            freeMem bytesWritten
            return (result', bytesWritten')
         ) (do
            freeMem vectors''
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data PollableOutputStreamWritevNonblockingMethodInfo
    instance (signature ~ ([Gio.OutputVector.OutputVector] -> Maybe (b) -> m ((Gio.Enums.PollableReturn, Word64))), MonadIO m, IsPollableOutputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo PollableOutputStreamWritevNonblockingMethodInfo a signature where
        overloadedMethod _ = pollableOutputStreamWritevNonblocking

    #endif