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

    GFileInputStream provides input streams that take their
    content from a file.

    GFileInputStream implements 'GI.Gio.Interfaces.Seekable.Seekable', which allows the input
    stream to jump to arbitrary positions in the file, provided the
    filesystem of the file allows it. To find the position of a file
    input stream, use 'GI.Gio.Interfaces.Seekable.seekableTell'. To find out if a file input
    stream supports seeking, use 'GI.Gio.Interfaces.Seekable.seekableCanSeek'.
    To position a file input stream, use 'GI.Gio.Interfaces.Seekable.seekableSeek'.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.FileInputStream
        (

    -- * Exported types
        FileInputStream(..)                     ,
        IsFileInputStream                       ,
        toFileInputStream                       ,
        noFileInputStream                       ,

     -- * Methods
    -- ** queryInfo #method:queryInfo#

    #if ENABLE_OVERLOADING
        FileInputStreamQueryInfoMethodInfo      ,
    #endif
        fileInputStreamQueryInfo                ,

    -- ** queryInfoAsync #method:queryInfoAsync#

    #if ENABLE_OVERLOADING
        FileInputStreamQueryInfoAsyncMethodInfo ,
    #endif
        fileInputStreamQueryInfoAsync           ,

    -- ** queryInfoFinish #method:queryInfoFinish#

    #if ENABLE_OVERLOADING
        FileInputStreamQueryInfoFinishMethodInfo,
    #endif
        fileInputStreamQueryInfoFinish          ,

        ) 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.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
    import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream

    -- | Memory-managed wrapper type.
    newtype FileInputStream = FileInputStream (ManagedPtr FileInputStream)
    foreign import ccall "g_file_input_stream_get_type"
        c_g_file_input_stream_get_type :: IO GType

    instance GObject FileInputStream where
        gobjectType _ = c_g_file_input_stream_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `FileInputStream`.
    noFileInputStream :: Maybe FileInputStream
    noFileInputStream = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveFileInputStreamMethod (t :: Symbol) (o :: *) :: * where
        ResolveFileInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveFileInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveFileInputStreamMethod "canSeek" o = Gio.Seekable.SeekableCanSeekMethodInfo
        ResolveFileInputStreamMethod "canTruncate" o = Gio.Seekable.SeekableCanTruncateMethodInfo
        ResolveFileInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo
        ResolveFileInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo
        ResolveFileInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo
        ResolveFileInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo
        ResolveFileInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveFileInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveFileInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveFileInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo
        ResolveFileInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo
        ResolveFileInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveFileInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveFileInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveFileInputStreamMethod "queryInfo" o = FileInputStreamQueryInfoMethodInfo
        ResolveFileInputStreamMethod "queryInfoAsync" o = FileInputStreamQueryInfoAsyncMethodInfo
        ResolveFileInputStreamMethod "queryInfoFinish" o = FileInputStreamQueryInfoFinishMethodInfo
        ResolveFileInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo
        ResolveFileInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo
        ResolveFileInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo
        ResolveFileInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo
        ResolveFileInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo
        ResolveFileInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo
        ResolveFileInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo
        ResolveFileInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo
        ResolveFileInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo
        ResolveFileInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveFileInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveFileInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveFileInputStreamMethod "seek" o = Gio.Seekable.SeekableSeekMethodInfo
        ResolveFileInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo
        ResolveFileInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo
        ResolveFileInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo
        ResolveFileInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveFileInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveFileInputStreamMethod "tell" o = Gio.Seekable.SeekableTellMethodInfo
        ResolveFileInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveFileInputStreamMethod "truncate" o = Gio.Seekable.SeekableTruncateMethodInfo
        ResolveFileInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveFileInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveFileInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveFileInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveFileInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveFileInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveFileInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo
        ResolveFileInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveFileInputStreamMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveFileInputStreamMethod t FileInputStream, O.MethodInfo info FileInputStream p) => O.IsLabel t (FileInputStream -> 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 FileInputStream
    type instance O.AttributeList FileInputStream = FileInputStreamAttributeList
    type FileInputStreamAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    #endif

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

    #endif

    -- method FileInputStream::query_info
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "FileInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a file attribute query string.", 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 (TInterface (Name {namespace = "Gio", name = "FileInfo"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_file_input_stream_query_info" g_file_input_stream_query_info ::
        Ptr FileInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "FileInputStream"})
        CString ->                              -- attributes : TBasicType TUTF8
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.FileInfo.FileInfo)

    {- |
    Queries a file input stream the given /@attributes@/. This function blocks
    while querying the stream. For the asynchronous (non-blocking) version
    of this function, see 'GI.Gio.Objects.FileInputStream.fileInputStreamQueryInfoAsync'. While the
    stream is blocked, the stream will set the pending flag internally, and
    any other operations on the stream will fail with 'GI.Gio.Enums.IOErrorEnumPending'.
    -}
    fileInputStreamQueryInfo ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.FileInputStream.FileInputStream'. -}
        -> T.Text
        {- ^ /@attributes@/: a file attribute query string. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Gio.FileInfo.FileInfo
        {- ^ __Returns:__ a 'GI.Gio.Objects.FileInfo.FileInfo', or 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    fileInputStreamQueryInfo stream attributes cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        attributes' <- textToCString attributes
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_file_input_stream_query_info stream' attributes' maybeCancellable
            checkUnexpectedReturnNULL "fileInputStreamQueryInfo" result
            result' <- (wrapObject Gio.FileInfo.FileInfo) result
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem attributes'
            return result'
         ) (do
            freeMem attributes'
         )

    #if ENABLE_OVERLOADING
    data FileInputStreamQueryInfoMethodInfo
    instance (signature ~ (T.Text -> Maybe (b) -> m Gio.FileInfo.FileInfo), MonadIO m, IsFileInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileInputStreamQueryInfoMethodInfo a signature where
        overloadedMethod _ = fileInputStreamQueryInfo

    #endif

    -- method FileInputStream::query_info_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "FileInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a file attribute query string.", 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][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_file_input_stream_query_info_async" g_file_input_stream_query_info_async ::
        Ptr FileInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "FileInputStream"})
        CString ->                              -- attributes : TBasicType TUTF8
        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 ()

    {- |
    Queries the stream information asynchronously.
    When the operation is finished /@callback@/ will be called.
    You can then call 'GI.Gio.Objects.FileInputStream.fileInputStreamQueryInfoFinish'
    to get the result of the operation.

    For the synchronous version of this function,
    see 'GI.Gio.Objects.FileInputStream.fileInputStreamQueryInfo'.

    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 set
    -}
    fileInputStreamQueryInfoAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.FileInputStream.FileInputStream'. -}
        -> T.Text
        {- ^ /@attributes@/: a file attribute query string. -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][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 ()
    fileInputStreamQueryInfoAsync stream attributes ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        attributes' <- textToCString attributes
        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_file_input_stream_query_info_async stream' attributes' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem attributes'
        return ()

    #if ENABLE_OVERLOADING
    data FileInputStreamQueryInfoAsyncMethodInfo
    instance (signature ~ (T.Text -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFileInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileInputStreamQueryInfoAsyncMethodInfo a signature where
        overloadedMethod _ = fileInputStreamQueryInfoAsync

    #endif

    -- method FileInputStream::query_info_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "FileInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFileInputStream.", 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 (TInterface (Name {namespace = "Gio", name = "FileInfo"}))
    -- throws : True
    -- Skip return : False

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

    {- |
    Finishes an asynchronous info query operation.
    -}
    fileInputStreamQueryInfoFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsFileInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.FileInputStream.FileInputStream'. -}
        -> b
        {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
        -> m Gio.FileInfo.FileInfo
        {- ^ __Returns:__ 'GI.Gio.Objects.FileInfo.FileInfo'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    fileInputStreamQueryInfoFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            result <- propagateGError $ g_file_input_stream_query_info_finish stream' result_'
            checkUnexpectedReturnNULL "fileInputStreamQueryInfoFinish" result
            result' <- (wrapObject Gio.FileInfo.FileInfo) result
            touchManagedPtr stream
            touchManagedPtr result_
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data FileInputStreamQueryInfoFinishMethodInfo
    instance (signature ~ (b -> m Gio.FileInfo.FileInfo), MonadIO m, IsFileInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo FileInputStreamQueryInfoFinishMethodInfo a signature where
        overloadedMethod _ = fileInputStreamQueryInfoFinish

    #endif