    {- |
    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.PollableInputStream.PollableInputStream' is implemented by @/GInputStreams/@ that
    can be polled for readiness to read. 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.PollableInputStream
        (

    -- * Exported types
        PollableInputStream(..)                 ,
        noPollableInputStream                   ,
        IsPollableInputStream                   ,
        toPollableInputStream                   ,

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

    #if ENABLE_OVERLOADING
        PollableInputStreamCanPollMethodInfo    ,
    #endif
        pollableInputStreamCanPoll              ,

    -- ** createSource #method:createSource#

    #if ENABLE_OVERLOADING
        PollableInputStreamCreateSourceMethodInfo,
    #endif
        pollableInputStreamCreateSource         ,

    -- ** isReadable #method:isReadable#

    #if ENABLE_OVERLOADING
        PollableInputStreamIsReadableMethodInfo ,
    #endif
        pollableInputStreamIsReadable           ,

    -- ** readNonblocking #method:readNonblocking#

    #if ENABLE_OVERLOADING
        PollableInputStreamReadNonblockingMethodInfo,
    #endif
        pollableInputStreamReadNonblocking      ,

        ) 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.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream

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

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

    #endif

    foreign import ccall "g_pollable_input_stream_get_type"
        c_g_pollable_input_stream_get_type :: IO GType

    instance GObject PollableInputStream where
        gobjectType _ = c_g_pollable_input_stream_get_type

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

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

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

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type family ResolvePollableInputStreamMethod (t :: Symbol) (o :: *) :: * where
        ResolvePollableInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolvePollableInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolvePollableInputStreamMethod "canPoll" o = PollableInputStreamCanPollMethodInfo
        ResolvePollableInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo
        ResolvePollableInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo
        ResolvePollableInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo
        ResolvePollableInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo
        ResolvePollableInputStreamMethod "createSource" o = PollableInputStreamCreateSourceMethodInfo
        ResolvePollableInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolvePollableInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolvePollableInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolvePollableInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo
        ResolvePollableInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo
        ResolvePollableInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolvePollableInputStreamMethod "isReadable" o = PollableInputStreamIsReadableMethodInfo
        ResolvePollableInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolvePollableInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolvePollableInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo
        ResolvePollableInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo
        ResolvePollableInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo
        ResolvePollableInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo
        ResolvePollableInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo
        ResolvePollableInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo
        ResolvePollableInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo
        ResolvePollableInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo
        ResolvePollableInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo
        ResolvePollableInputStreamMethod "readNonblocking" o = PollableInputStreamReadNonblockingMethodInfo
        ResolvePollableInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolvePollableInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolvePollableInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolvePollableInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo
        ResolvePollableInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo
        ResolvePollableInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo
        ResolvePollableInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolvePollableInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolvePollableInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolvePollableInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolvePollableInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolvePollableInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolvePollableInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolvePollableInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolvePollableInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolvePollableInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo
        ResolvePollableInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolvePollableInputStreamMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolvePollableInputStreamMethod t PollableInputStream, O.MethodInfo info PollableInputStream p) => O.IsLabel t (PollableInputStream -> 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 PollableInputStream::can_poll
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableInputStream.", 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_input_stream_can_poll" g_pollable_input_stream_can_poll ::
        Ptr PollableInputStream ->              -- stream : TInterface (Name {namespace = "Gio", name = "PollableInputStream"})
        IO CInt

    {- |
    Checks if /@stream@/ is actually pollable. Some classes may implement
    'GI.Gio.Interfaces.PollableInputStream.PollableInputStream' but have only certain instances of that class
    be pollable. If this method returns 'False', then the behavior of
    other 'GI.Gio.Interfaces.PollableInputStream.PollableInputStream' 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/
    -}
    pollableInputStreamCanPoll ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableInputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableInputStream.PollableInputStream'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@stream@/ is pollable, 'False' if not. -}
    pollableInputStreamCanPoll stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_pollable_input_stream_can_poll stream'
        let result' = (/= 0) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data PollableInputStreamCanPollMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsPollableInputStream a) => O.MethodInfo PollableInputStreamCanPollMethodInfo a signature where
        overloadedMethod _ = pollableInputStreamCanPoll

    #endif

    -- method PollableInputStream::create_source
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableInputStream.", 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_input_stream_create_source" g_pollable_input_stream_create_source ::
        Ptr PollableInputStream ->              -- stream : TInterface (Name {namespace = "Gio", name = "PollableInputStream"})
        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 read, 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.PollableInputStream.pollableInputStreamIsReadable', it is possible that
    the stream may not actually be readable even after the source
    triggers, so you should use 'GI.Gio.Interfaces.PollableInputStream.pollableInputStreamReadNonblocking'
    rather than 'GI.Gio.Objects.InputStream.inputStreamRead' from the callback.

    /Since: 2.28/
    -}
    pollableInputStreamCreateSource ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableInputStream.PollableInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m GLib.Source.Source
        {- ^ __Returns:__ a new 'GI.GLib.Structs.Source.Source' -}
    pollableInputStreamCreateSource 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_input_stream_create_source stream' maybeCancellable
        checkUnexpectedReturnNULL "pollableInputStreamCreateSource" result
        result' <- (wrapBoxed GLib.Source.Source) result
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return result'

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

    #endif

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

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

    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.InputStream.inputStreamRead'
    after this returns 'True' would still block. To guarantee
    non-blocking behavior, you should always use
    'GI.Gio.Interfaces.PollableInputStream.pollableInputStreamReadNonblocking', which will return a
    'GI.Gio.Enums.IOErrorEnumWouldBlock' error rather than blocking.

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

    #if ENABLE_OVERLOADING
    data PollableInputStreamIsReadableMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsPollableInputStream a) => O.MethodInfo PollableInputStreamIsReadableMethodInfo a signature where
        overloadedMethod _ = pollableInputStreamIsReadable

    #endif

    -- method PollableInputStream::read_nonblocking
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "PollableInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPollableInputStream", 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\n    read data into (which should be at least @count bytes long).", 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 read", 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 read", 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_input_stream_read_nonblocking" g_pollable_input_stream_read_nonblocking ::
        Ptr PollableInputStream ->              -- stream : TInterface (Name {namespace = "Gio", name = "PollableInputStream"})
        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 read up to /@count@/ bytes from /@stream@/ into /@buffer@/, as
    with 'GI.Gio.Objects.InputStream.inputStreamRead'. If /@stream@/ is not currently readable,
    this will immediately return 'GI.Gio.Enums.IOErrorEnumWouldBlock', and you can
    use 'GI.Gio.Interfaces.PollableInputStream.pollableInputStreamCreateSource' to create a 'GI.GLib.Structs.Source.Source'
    that will be triggered when /@stream@/ is readable.

    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.
    -}
    pollableInputStreamReadNonblocking ::
        (B.CallStack.HasCallStack, MonadIO m, IsPollableInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Interfaces.PollableInputStream.PollableInputStream' -}
        -> Maybe (ByteString)
        {- ^ /@buffer@/: a buffer to
        read data into (which should be at least /@count@/ bytes long). -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> m Int64
        {- ^ __Returns:__ the number of bytes read, or -1 on error (including
      'GI.Gio.Enums.IOErrorEnumWouldBlock'). /(Can throw 'Data.GI.Base.GError.GError')/ -}
    pollableInputStreamReadNonblocking 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_input_stream_read_nonblocking stream' maybeBuffer count maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem maybeBuffer
            return result
         ) (do
            freeMem maybeBuffer
         )

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

    #endif