{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Provides a base class for implementing asynchronous function results.
-- 
-- Asynchronous operations are broken up into two separate operations
-- which are chained together by a t'GI.Gio.Callbacks.AsyncReadyCallback'. To begin
-- an asynchronous operation, provide a t'GI.Gio.Callbacks.AsyncReadyCallback' to the
-- asynchronous function. This callback will be triggered when the
-- operation has completed, and must be run in a later iteration of
-- the [thread-default main context][g-main-context-push-thread-default]
-- from where the operation was initiated. It will be passed a
-- t'GI.Gio.Interfaces.AsyncResult.AsyncResult' instance filled with the details of the operation\'s
-- success or failure, the object the asynchronous function was
-- started for and any error codes returned. The asynchronous callback
-- function is then expected to call the corresponding \"@/_finish()/@\"
-- function, passing the object the function was called for, the
-- t'GI.Gio.Interfaces.AsyncResult.AsyncResult' instance, and (optionally) an /@error@/ to grab any
-- error conditions that may have occurred.
-- 
-- The \"@/_finish()/@\" function for an operation takes the generic result
-- (of type t'GI.Gio.Interfaces.AsyncResult.AsyncResult') and returns the specific result that the
-- operation in question yields (e.g. a t'GI.Gio.Objects.FileEnumerator.FileEnumerator' for a
-- \"enumerate children\" operation). If the result or error status of the
-- operation is not needed, there is no need to call the \"@/_finish()/@\"
-- function; GIO will take care of cleaning up the result and error
-- information after the t'GI.Gio.Callbacks.AsyncReadyCallback' returns. You can pass
-- 'P.Nothing' for the t'GI.Gio.Callbacks.AsyncReadyCallback' if you don\'t need to take any
-- action at all after the operation completes. Applications may also
-- take a reference to the t'GI.Gio.Interfaces.AsyncResult.AsyncResult' and call \"@/_finish()/@\" later;
-- however, the \"@/_finish()/@\" function may be called at most once.
-- 
-- Example of a typical asynchronous operation flow:
-- 
-- === /C code/
-- >
-- >void _theoretical_frobnitz_async (Theoretical         *t,
-- >                                  GCancellable        *c,
-- >                                  GAsyncReadyCallback  cb,
-- >                                  gpointer             u);
-- >
-- >gboolean _theoretical_frobnitz_finish (Theoretical   *t,
-- >                                       GAsyncResult  *res,
-- >                                       GError       **e);
-- >
-- >static void
-- >frobnitz_result_func (GObject      *source_object,
-- >		 GAsyncResult *res,
-- >		 gpointer      user_data)
-- >{
-- >  gboolean success = FALSE;
-- >
-- >  success = _theoretical_frobnitz_finish (source_object, res, NULL);
-- >
-- >  if (success)
-- >    g_printf ("Hurray!\n");
-- >  else
-- >    g_printf ("Uh oh!\n");
-- >
-- >  ...
-- >
-- >}
-- >
-- >int main (int argc, void *argv[])
-- >{
-- >   ...
-- >
-- >   _theoretical_frobnitz_async (theoretical_data,
-- >                                NULL,
-- >                                frobnitz_result_func,
-- >                                NULL);
-- >
-- >   ...
-- >}
-- 
-- 
-- The callback for an asynchronous operation is called only once, and is
-- always called, even in the case of a cancelled operation. On cancellation
-- the result is a 'GI.Gio.Enums.IOErrorEnumCancelled' error.
-- 
-- ## I\/O Priority # {@/io/@-priority}
-- 
-- Many I\/O-related asynchronous operations have a priority parameter,
-- which is used in certain cases to determine the order in which
-- operations are executed. They are not used to determine system-wide
-- I\/O scheduling. Priorities are integers, with lower numbers indicating
-- higher priority. It is recommended to choose priorities between
-- 'GI.GLib.Constants.PRIORITY_LOW' and 'GI.GLib.Constants.PRIORITY_HIGH', with 'GI.GLib.Constants.PRIORITY_DEFAULT'
-- as a default.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gio.Interfaces.AsyncResult
    ( 

-- * Exported types
    AsyncResult(..)                         ,
    IsAsyncResult                           ,
    toAsyncResult                           ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveAsyncResultMethod                ,
#endif


-- ** getSourceObject #method:getSourceObject#

#if defined(ENABLE_OVERLOADING)
    AsyncResultGetSourceObjectMethodInfo    ,
#endif
    asyncResultGetSourceObject              ,


-- ** getUserData #method:getUserData#

#if defined(ENABLE_OVERLOADING)
    AsyncResultGetUserDataMethodInfo        ,
#endif
    asyncResultGetUserData                  ,


-- ** isTagged #method:isTagged#

#if defined(ENABLE_OVERLOADING)
    AsyncResultIsTaggedMethodInfo           ,
#endif
    asyncResultIsTagged                     ,


-- ** legacyPropagateError #method:legacyPropagateError#

#if defined(ENABLE_OVERLOADING)
    AsyncResultLegacyPropagateErrorMethodInfo,
#endif
    asyncResultLegacyPropagateError         ,




    ) 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.BasicTypes as B.Types
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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

-- interface AsyncResult 
-- | Memory-managed wrapper type.
newtype AsyncResult = AsyncResult (SP.ManagedPtr AsyncResult)
    deriving (AsyncResult -> AsyncResult -> Bool
(AsyncResult -> AsyncResult -> Bool)
-> (AsyncResult -> AsyncResult -> Bool) -> Eq AsyncResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AsyncResult -> AsyncResult -> Bool
$c/= :: AsyncResult -> AsyncResult -> Bool
== :: AsyncResult -> AsyncResult -> Bool
$c== :: AsyncResult -> AsyncResult -> Bool
Eq)

instance SP.ManagedPtrNewtype AsyncResult where
    toManagedPtr :: AsyncResult -> ManagedPtr AsyncResult
toManagedPtr (AsyncResult ManagedPtr AsyncResult
p) = ManagedPtr AsyncResult
p

foreign import ccall "g_async_result_get_type"
    c_g_async_result_get_type :: IO B.Types.GType

instance B.Types.TypedObject AsyncResult where
    glibType :: IO GType
glibType = IO GType
c_g_async_result_get_type

instance B.Types.GObject AsyncResult

-- | Convert 'AsyncResult' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue AsyncResult where
    toGValue :: AsyncResult -> IO GValue
toGValue AsyncResult
o = do
        GType
gtype <- IO GType
c_g_async_result_get_type
        AsyncResult -> (Ptr AsyncResult -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AsyncResult
o (GType
-> (GValue -> Ptr AsyncResult -> IO ())
-> Ptr AsyncResult
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr AsyncResult -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO AsyncResult
fromGValue GValue
gv = do
        Ptr AsyncResult
ptr <- GValue -> IO (Ptr AsyncResult)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr AsyncResult)
        (ManagedPtr AsyncResult -> AsyncResult)
-> Ptr AsyncResult -> IO AsyncResult
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr AsyncResult -> AsyncResult
AsyncResult Ptr AsyncResult
ptr
        
    

-- | Type class for types which can be safely cast to `AsyncResult`, for instance with `toAsyncResult`.
class (SP.GObject o, O.IsDescendantOf AsyncResult o) => IsAsyncResult o
instance (SP.GObject o, O.IsDescendantOf AsyncResult o) => IsAsyncResult o

instance O.HasParentTypes AsyncResult
type instance O.ParentTypes AsyncResult = '[GObject.Object.Object]

-- | Cast to `AsyncResult`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toAsyncResult :: (MonadIO m, IsAsyncResult o) => o -> m AsyncResult
toAsyncResult :: o -> m AsyncResult
toAsyncResult = IO AsyncResult -> m AsyncResult
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AsyncResult -> m AsyncResult)
-> (o -> IO AsyncResult) -> o -> m AsyncResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr AsyncResult -> AsyncResult) -> o -> IO AsyncResult
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr AsyncResult -> AsyncResult
AsyncResult

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveAsyncResultMethod (t :: Symbol) (o :: *) :: * where
    ResolveAsyncResultMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAsyncResultMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAsyncResultMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAsyncResultMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAsyncResultMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveAsyncResultMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAsyncResultMethod "isTagged" o = AsyncResultIsTaggedMethodInfo
    ResolveAsyncResultMethod "legacyPropagateError" o = AsyncResultLegacyPropagateErrorMethodInfo
    ResolveAsyncResultMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAsyncResultMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAsyncResultMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveAsyncResultMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAsyncResultMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAsyncResultMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAsyncResultMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAsyncResultMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAsyncResultMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveAsyncResultMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAsyncResultMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAsyncResultMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAsyncResultMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAsyncResultMethod "getSourceObject" o = AsyncResultGetSourceObjectMethodInfo
    ResolveAsyncResultMethod "getUserData" o = AsyncResultGetUserDataMethodInfo
    ResolveAsyncResultMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAsyncResultMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveAsyncResultMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAsyncResultMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAsyncResultMethod t AsyncResult, O.MethodInfo info AsyncResult p) => OL.IsLabel t (AsyncResult -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- method AsyncResult::get_source_object
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "res"
--           , 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 = "GObject" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "g_async_result_get_source_object" g_async_result_get_source_object :: 
    Ptr AsyncResult ->                      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    IO (Ptr GObject.Object.Object)

-- | Gets the source object from a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
asyncResultGetSourceObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
    a
    -- ^ /@res@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m (Maybe GObject.Object.Object)
    -- ^ __Returns:__ a new reference to the source
    --    object for the /@res@/, or 'P.Nothing' if there is none.
asyncResultGetSourceObject :: a -> m (Maybe Object)
asyncResultGetSourceObject a
res = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncResult
res' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    Ptr Object
result <- Ptr AsyncResult -> IO (Ptr Object)
g_async_result_get_source_object Ptr AsyncResult
res'
    Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
        Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
        Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
res
    Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult

#if defined(ENABLE_OVERLOADING)
data AsyncResultGetSourceObjectMethodInfo
instance (signature ~ (m (Maybe GObject.Object.Object)), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultGetSourceObjectMethodInfo a signature where
    overloadedMethod = asyncResultGetSourceObject

#endif

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

foreign import ccall "g_async_result_get_user_data" g_async_result_get_user_data :: 
    Ptr AsyncResult ->                      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    IO (Ptr ())

-- | Gets the user data from a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
asyncResultGetUserData ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
    a
    -- ^ /@res@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> m (Ptr ())
    -- ^ __Returns:__ the user data for /@res@/.
asyncResultGetUserData :: a -> m (Ptr ())
asyncResultGetUserData a
res = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncResult
res' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    Ptr ()
result <- Ptr AsyncResult -> IO (Ptr ())
g_async_result_get_user_data Ptr AsyncResult
res'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
res
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data AsyncResultGetUserDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultGetUserDataMethodInfo a signature where
    overloadedMethod = asyncResultGetUserData

#endif

-- method AsyncResult::is_tagged
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source_tag"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an application-defined tag"
--                 , 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_async_result_is_tagged" g_async_result_is_tagged :: 
    Ptr AsyncResult ->                      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr () ->                               -- source_tag : TBasicType TPtr
    IO CInt

-- | Checks if /@res@/ has the given /@sourceTag@/ (generally a function
-- pointer indicating the function /@res@/ was created by).
-- 
-- /Since: 2.34/
asyncResultIsTagged ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
    a
    -- ^ /@res@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> Ptr ()
    -- ^ /@sourceTag@/: an application-defined tag
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@res@/ has the indicated /@sourceTag@/, 'P.False' if
    --   not.
asyncResultIsTagged :: a -> Ptr () -> m Bool
asyncResultIsTagged a
res Ptr ()
sourceTag = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncResult
res' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    CInt
result <- Ptr AsyncResult -> Ptr () -> IO CInt
g_async_result_is_tagged Ptr AsyncResult
res' Ptr ()
sourceTag
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
res
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data AsyncResultIsTaggedMethodInfo
instance (signature ~ (Ptr () -> m Bool), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultIsTaggedMethodInfo a signature where
    overloadedMethod = asyncResultIsTagged

#endif

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

foreign import ccall "g_async_result_legacy_propagate_error" g_async_result_legacy_propagate_error :: 
    Ptr AsyncResult ->                      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | If /@res@/ is a t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult', this is equivalent to
-- 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultPropagateError'. Otherwise it returns
-- 'P.False'.
-- 
-- This can be used for legacy error handling in async *@/_finish()/@
-- wrapper functions that traditionally handled t'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'
-- error returns themselves rather than calling into the virtual method.
-- This should not be used in new code; t'GI.Gio.Interfaces.AsyncResult.AsyncResult' errors that are
-- set by virtual methods should also be extracted by virtual methods,
-- to enable subclasses to chain up correctly.
-- 
-- /Since: 2.34/
asyncResultLegacyPropagateError ::
    (B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
    a
    -- ^ /@res@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
asyncResultLegacyPropagateError :: a -> m ()
asyncResultLegacyPropagateError a
res = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncResult
res' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
g_async_result_legacy_propagate_error Ptr AsyncResult
res'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
res
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data AsyncResultLegacyPropagateErrorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultLegacyPropagateErrorMethodInfo a signature where
    overloadedMethod = asyncResultLegacyPropagateError

#endif

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

#endif