FileInputStream.hs


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

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 (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.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, O.IsDescendantOf FileInputStream o) => IsFileInputStream o
instance (GObject o, O.IsDescendantOf FileInputStream o) => IsFileInputStream o

instance O.HasParentTypes FileInputStream
type instance O.ParentTypes FileInputStream = '[Gio.InputStream.InputStream, GObject.Object.Object, Gio.Seekable.Seekable]

-- | 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) => OL.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

#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