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

    As of GLib 2.46, 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' is deprecated in favor of
    'GI.Gio.Objects.Task.Task', which provides a simpler API.

    'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' implements 'GI.Gio.Interfaces.AsyncResult.AsyncResult'.

    GSimpleAsyncResult handles @/GAsyncReadyCallbacks/@, error
    reporting, operation cancellation and the final state of an operation,
    completely transparent to the application. Results can be returned
    as a pointer e.g. for functions that return data that is collected
    asynchronously, a boolean value for checking the success or failure
    of an operation, or a @/gssize/@ for operations which return the number
    of bytes modified by the operation; all of the simple return cases
    are covered.

    Most of the time, an application will not need to know of the details
    of this API; it is handled transparently, and any necessary operations
    are handled by 'GI.Gio.Interfaces.AsyncResult.AsyncResult'\'s interface. However, if implementing a
    new GIO module, for writing language bindings, or for complex
    applications that need better control of how asynchronous operations
    are completed, it is important to understand this functionality.

    GSimpleAsyncResults are tagged with the calling function to ensure
    that asynchronous functions and their finishing functions are used
    together correctly.

    To create a new 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult', call 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultNew'.
    If the result needs to be created for a 'GError', use
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultNewFromError' or
    @/g_simple_async_result_new_take_error()/@. If a 'GError' is not available
    (e.g. the asynchronous operation\'s doesn\'t take a 'GError' argument),
    but the result still needs to be created for an error condition, use
    @/g_simple_async_result_new_error()/@ (or @/g_simple_async_result_set_error_va()/@
    if your application or binding requires passing a variable argument list
    directly), and the error can then be propagated through the use of
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultPropagateError'.

    An asynchronous operation can be made to ignore a cancellation event by
    calling 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetHandleCancellation' with a
    'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' for the operation and 'False'. This is useful for
    operations that are dangerous to cancel, such as close (which would
    cause a leak if cancelled before being run).

    GSimpleAsyncResult can integrate into GLib\'s event loop, 'GI.GLib.Structs.MainLoop.MainLoop',
    or it can use @/GThreads/@.
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultComplete' will finish an I\/O task directly
    from the point where it is called. 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultCompleteInIdle'
    will finish it from an idle handler in the
    [thread-default main context][g-main-context-push-thread-default]
    where the 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' was created.
    @/g_simple_async_result_run_in_thread()/@ will run the job in a
    separate thread and then use
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultCompleteInIdle' to deliver the result.

    To set the results of an asynchronous function,
    @/g_simple_async_result_set_op_res_gpointer()/@,
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetOpResGboolean', and
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetOpResGssize'
    are provided, setting the operation\'s result to a gpointer, gboolean, or
    gssize, respectively.

    Likewise, to get the result of an asynchronous function,
    @/g_simple_async_result_get_op_res_gpointer()/@,
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultGetOpResGboolean', and
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultGetOpResGssize' are
    provided, getting the operation\'s result as a gpointer, gboolean, and
    gssize, respectively.

    For the details of the requirements implementations must respect, see
    'GI.Gio.Interfaces.AsyncResult.AsyncResult'.  A typical implementation of an asynchronous operation
    using GSimpleAsyncResult looks something like this:

    === /C code/
    >
    >static void
    >baked_cb (Cake    *cake,
    >          gpointer user_data)
    >{
    >  // In this example, this callback is not given a reference to the cake,
    >  // so the GSimpleAsyncResult has to take a reference to it.
    >  GSimpleAsyncResult *result = user_data;
    >
    >  if (cake == NULL)
    >    g_simple_async_result_set_error (result,
    >                                     BAKER_ERRORS,
    >                                     BAKER_ERROR_NO_FLOUR,
    >                                     "Go to the supermarket");
    >  else
    >    g_simple_async_result_set_op_res_gpointer (result,
    >                                               g_object_ref (cake),
    >                                               g_object_unref);
    >
    >
    >  // In this example, we assume that baked_cb is called as a callback from
    >  // the mainloop, so it's safe to complete the operation synchronously here.
    >  // If, however, _baker_prepare_cake () might call its callback without
    >  // first returning to the mainloop — inadvisable, but some APIs do so —
    >  // we would need to use g_simple_async_result_complete_in_idle().
    >  g_simple_async_result_complete (result);
    >  g_object_unref (result);
    >}
    >
    >void
    >baker_bake_cake_async (Baker              *self,
    >                       guint               radius,
    >                       GAsyncReadyCallback callback,
    >                       gpointer            user_data)
    >{
    >  GSimpleAsyncResult *simple;
    >  Cake               *cake;
    >
    >  if (radius < 3)
    >    {
    >      g_simple_async_report_error_in_idle (G_OBJECT (self),
    >                                           callback,
    >                                           user_data,
    >                                           BAKER_ERRORS,
    >                                           BAKER_ERROR_TOO_SMALL,
    >                                           "%ucm radius cakes are silly",
    >                                           radius);
    >      return;
    >    }
    >
    >  simple = g_simple_async_result_new (G_OBJECT (self),
    >                                      callback,
    >                                      user_data,
    >                                      baker_bake_cake_async);
    >  cake = _baker_get_cached_cake (self, radius);
    >
    >  if (cake != NULL)
    >    {
    >      g_simple_async_result_set_op_res_gpointer (simple,
    >                                                 g_object_ref (cake),
    >                                                 g_object_unref);
    >      g_simple_async_result_complete_in_idle (simple);
    >      g_object_unref (simple);
    >      // Drop the reference returned by _baker_get_cached_cake();
    >      // the GSimpleAsyncResult has taken its own reference.
    >      g_object_unref (cake);
    >      return;
    >    }
    >
    >  _baker_prepare_cake (self, radius, baked_cb, simple);
    >}
    >
    >Cake *
    >baker_bake_cake_finish (Baker        *self,
    >                        GAsyncResult *result,
    >                        GError      **error)
    >{
    >  GSimpleAsyncResult *simple;
    >  Cake               *cake;
    >
    >  g_return_val_if_fail (g_simple_async_result_is_valid (result,
    >                                                        G_OBJECT (self),
    >                                                        baker_bake_cake_async),
    >                        NULL);
    >
    >  simple = (GSimpleAsyncResult *) result;
    >
    >  if (g_simple_async_result_propagate_error (simple, error))
    >    return NULL;
    >
    >  cake = CAKE (g_simple_async_result_get_op_res_gpointer (simple));
    >  return g_object_ref (cake);
    >}

    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.SimpleAsyncResult
        (

    -- * Exported types
        SimpleAsyncResult(..)                   ,
        IsSimpleAsyncResult                     ,
        toSimpleAsyncResult                     ,
        noSimpleAsyncResult                     ,

     -- * Methods
    -- ** complete #method:complete#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultCompleteMethodInfo     ,
    #endif
        simpleAsyncResultComplete               ,

    -- ** completeInIdle #method:completeInIdle#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultCompleteInIdleMethodInfo,
    #endif
        simpleAsyncResultCompleteInIdle         ,

    -- ** getOpResGboolean #method:getOpResGboolean#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultGetOpResGbooleanMethodInfo,
    #endif
        simpleAsyncResultGetOpResGboolean       ,

    -- ** getOpResGssize #method:getOpResGssize#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultGetOpResGssizeMethodInfo,
    #endif
        simpleAsyncResultGetOpResGssize         ,

    -- ** isValid #method:isValid#

        simpleAsyncResultIsValid                ,

    -- ** new #method:new#

        simpleAsyncResultNew                    ,

    -- ** newFromError #method:newFromError#

        simpleAsyncResultNewFromError           ,

    -- ** propagateError #method:propagateError#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultPropagateErrorMethodInfo,
    #endif
        simpleAsyncResultPropagateError         ,

    -- ** setCheckCancellable #method:setCheckCancellable#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultSetCheckCancellableMethodInfo,
    #endif
        simpleAsyncResultSetCheckCancellable    ,

    -- ** setFromError #method:setFromError#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultSetFromErrorMethodInfo ,
    #endif
        simpleAsyncResultSetFromError           ,

    -- ** setHandleCancellation #method:setHandleCancellation#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultSetHandleCancellationMethodInfo,
    #endif
        simpleAsyncResultSetHandleCancellation  ,

    -- ** setOpResGboolean #method:setOpResGboolean#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultSetOpResGbooleanMethodInfo,
    #endif
        simpleAsyncResultSetOpResGboolean       ,

    -- ** setOpResGssize #method:setOpResGssize#

    #if ENABLE_OVERLOADING
        SimpleAsyncResultSetOpResGssizeMethodInfo,
    #endif
        simpleAsyncResultSetOpResGssize         ,

        ) 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.Objects.Cancellable as Gio.Cancellable

    -- | Memory-managed wrapper type.
    newtype SimpleAsyncResult = SimpleAsyncResult (ManagedPtr SimpleAsyncResult)
    foreign import ccall "g_simple_async_result_get_type"
        c_g_simple_async_result_get_type :: IO GType

    instance GObject SimpleAsyncResult where
        gobjectType _ = c_g_simple_async_result_get_type

    -- | Type class for types which can be safely cast to `SimpleAsyncResult`, for instance with `toSimpleAsyncResult`.
    class GObject o => IsSimpleAsyncResult o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError SimpleAsyncResult a) =>
        IsSimpleAsyncResult a
    #endif
    instance IsSimpleAsyncResult SimpleAsyncResult
    instance GObject.Object.IsObject SimpleAsyncResult
    instance Gio.AsyncResult.IsAsyncResult SimpleAsyncResult

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

    -- | A convenience alias for `Nothing` :: `Maybe` `SimpleAsyncResult`.
    noSimpleAsyncResult :: Maybe SimpleAsyncResult
    noSimpleAsyncResult = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveSimpleAsyncResultMethod (t :: Symbol) (o :: *) :: * where
        ResolveSimpleAsyncResultMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSimpleAsyncResultMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSimpleAsyncResultMethod "complete" o = SimpleAsyncResultCompleteMethodInfo
        ResolveSimpleAsyncResultMethod "completeInIdle" o = SimpleAsyncResultCompleteInIdleMethodInfo
        ResolveSimpleAsyncResultMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSimpleAsyncResultMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSimpleAsyncResultMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSimpleAsyncResultMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSimpleAsyncResultMethod "isTagged" o = Gio.AsyncResult.AsyncResultIsTaggedMethodInfo
        ResolveSimpleAsyncResultMethod "legacyPropagateError" o = Gio.AsyncResult.AsyncResultLegacyPropagateErrorMethodInfo
        ResolveSimpleAsyncResultMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSimpleAsyncResultMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSimpleAsyncResultMethod "propagateError" o = SimpleAsyncResultPropagateErrorMethodInfo
        ResolveSimpleAsyncResultMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSimpleAsyncResultMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSimpleAsyncResultMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSimpleAsyncResultMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSimpleAsyncResultMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSimpleAsyncResultMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSimpleAsyncResultMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSimpleAsyncResultMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSimpleAsyncResultMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSimpleAsyncResultMethod "getOpResGboolean" o = SimpleAsyncResultGetOpResGbooleanMethodInfo
        ResolveSimpleAsyncResultMethod "getOpResGssize" o = SimpleAsyncResultGetOpResGssizeMethodInfo
        ResolveSimpleAsyncResultMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSimpleAsyncResultMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSimpleAsyncResultMethod "getSourceObject" o = Gio.AsyncResult.AsyncResultGetSourceObjectMethodInfo
        ResolveSimpleAsyncResultMethod "getUserData" o = Gio.AsyncResult.AsyncResultGetUserDataMethodInfo
        ResolveSimpleAsyncResultMethod "setCheckCancellable" o = SimpleAsyncResultSetCheckCancellableMethodInfo
        ResolveSimpleAsyncResultMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSimpleAsyncResultMethod "setFromError" o = SimpleAsyncResultSetFromErrorMethodInfo
        ResolveSimpleAsyncResultMethod "setHandleCancellation" o = SimpleAsyncResultSetHandleCancellationMethodInfo
        ResolveSimpleAsyncResultMethod "setOpResGboolean" o = SimpleAsyncResultSetOpResGbooleanMethodInfo
        ResolveSimpleAsyncResultMethod "setOpResGssize" o = SimpleAsyncResultSetOpResGssizeMethodInfo
        ResolveSimpleAsyncResultMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSimpleAsyncResultMethod l o = O.MethodResolutionFailed l o

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

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

    #if ENABLE_OVERLOADING
    #endif

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

    #endif

    -- method SimpleAsyncResult::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GObject, or %NULL.", 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 "a #GAsyncReadyCallback.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @callback.", 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 "the asynchronous function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_new" g_simple_async_result_new ::
        Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        Ptr () ->                               -- source_tag : TBasicType TPtr
        IO (Ptr SimpleAsyncResult)

    {-# DEPRECATED simpleAsyncResultNew ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.taskNew' instead."] #-}
    {- |
    Creates a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.

    The common convention is to create the 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' in the
    function that starts the asynchronous operation and use that same
    function as the /@sourceTag@/.

    If your operation supports cancellation with 'GI.Gio.Objects.Cancellable.Cancellable' (which it
    probably should) then you should provide the user\'s cancellable to
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetCheckCancellable' immediately after
    this function returns.
    -}
    simpleAsyncResultNew ::
        (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
        Maybe (a)
        {- ^ /@sourceObject@/: a 'GI.GObject.Objects.Object.Object', or 'Nothing'. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback'. -}
        -> Ptr ()
        {- ^ /@sourceTag@/: the asynchronous function. -}
        -> m SimpleAsyncResult
        {- ^ __Returns:__ a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
    simpleAsyncResultNew sourceObject callback sourceTag = liftIO $ do
        maybeSourceObject <- case sourceObject of
            Nothing -> return nullPtr
            Just jSourceObject -> do
                jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject
                return jSourceObject'
        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
        result <- g_simple_async_result_new maybeSourceObject maybeCallback userData sourceTag
        checkUnexpectedReturnNULL "simpleAsyncResultNew" result
        result' <- (wrapObject SimpleAsyncResult) result
        whenJust sourceObject touchManagedPtr
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method SimpleAsyncResult::new_from_error
    -- method type : Constructor
    -- Args : [Arg {argCName = "source_object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GObject, or %NULL.", 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 "a #GAsyncReadyCallback.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GError", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_new_from_error" g_simple_async_result_new_from_error ::
        Ptr GObject.Object.Object ->            -- source_object : TInterface (Name {namespace = "GObject", name = "Object"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        Ptr GError ->                           -- error : TError
        IO (Ptr SimpleAsyncResult)

    {-# DEPRECATED simpleAsyncResultNewFromError ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.taskNew' and 'GI.Gio.Objects.Task.taskReturnError' instead."] #-}
    {- |
    Creates a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' from an error condition.
    -}
    simpleAsyncResultNewFromError ::
        (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
        Maybe (a)
        {- ^ /@sourceObject@/: a 'GI.GObject.Objects.Object.Object', or 'Nothing'. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback'. -}
        -> GError
        {- ^ /@error@/: a 'GError' -}
        -> m SimpleAsyncResult
        {- ^ __Returns:__ a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
    simpleAsyncResultNewFromError sourceObject callback error_ = liftIO $ do
        maybeSourceObject <- case sourceObject of
            Nothing -> return nullPtr
            Just jSourceObject -> do
                jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject
                return jSourceObject'
        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'
        error_' <- unsafeManagedPtrGetPtr error_
        let userData = nullPtr
        result <- g_simple_async_result_new_from_error maybeSourceObject maybeCallback userData error_'
        checkUnexpectedReturnNULL "simpleAsyncResultNewFromError" result
        result' <- (wrapObject SimpleAsyncResult) result
        whenJust sourceObject touchManagedPtr
        touchManagedPtr error_
        return result'

    #if ENABLE_OVERLOADING
    #endif

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

    foreign import ccall "g_simple_async_result_complete" g_simple_async_result_complete ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO ()

    {-# DEPRECATED simpleAsyncResultComplete ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' instead."] #-}
    {- |
    Completes an asynchronous I\/O job immediately. Must be called in
    the thread where the asynchronous result was to be delivered, as it
    invokes the callback directly. If you are in a different thread use
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultCompleteInIdle'.

    Calling this function takes a reference to /@simple@/ for as long as
    is needed to complete the call.
    -}
    simpleAsyncResultComplete ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> m ()
    simpleAsyncResultComplete simple = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        g_simple_async_result_complete simple'
        touchManagedPtr simple
        return ()

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultCompleteMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultCompleteMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultComplete

    #endif

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

    foreign import ccall "g_simple_async_result_complete_in_idle" g_simple_async_result_complete_in_idle ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO ()

    {-# DEPRECATED simpleAsyncResultCompleteInIdle ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' instead."] #-}
    {- |
    Completes an asynchronous function in an idle handler in the
    [thread-default main context][g-main-context-push-thread-default]
    of the thread that /@simple@/ was initially created in
    (and re-pushes that context around the invocation of the callback).

    Calling this function takes a reference to /@simple@/ for as long as
    is needed to complete the call.
    -}
    simpleAsyncResultCompleteInIdle ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> m ()
    simpleAsyncResultCompleteInIdle simple = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        g_simple_async_result_complete_in_idle simple'
        touchManagedPtr simple
        return ()

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultCompleteInIdleMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultCompleteInIdleMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultCompleteInIdle

    #endif

    -- method SimpleAsyncResult::get_op_res_gboolean
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAsyncResult.", 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_simple_async_result_get_op_res_gboolean" g_simple_async_result_get_op_res_gboolean ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO CInt

    {-# DEPRECATED simpleAsyncResultGetOpResGboolean ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskPropagateBoolean' instead."] #-}
    {- |
    Gets the operation result boolean from within the asynchronous result.
    -}
    simpleAsyncResultGetOpResGboolean ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the operation\'s result was 'True', 'False'
        if the operation\'s result was 'False'. -}
    simpleAsyncResultGetOpResGboolean simple = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        result <- g_simple_async_result_get_op_res_gboolean simple'
        let result' = (/= 0) result
        touchManagedPtr simple
        return result'

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultGetOpResGbooleanMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultGetOpResGbooleanMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultGetOpResGboolean

    #endif

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

    foreign import ccall "g_simple_async_result_get_op_res_gssize" g_simple_async_result_get_op_res_gssize ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        IO Int64

    {-# DEPRECATED simpleAsyncResultGetOpResGssize ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskPropagateInt' instead."] #-}
    {- |
    Gets a gssize from the asynchronous result.
    -}
    simpleAsyncResultGetOpResGssize ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> m Int64
        {- ^ __Returns:__ a gssize returned from the asynchronous function. -}
    simpleAsyncResultGetOpResGssize simple = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        result <- g_simple_async_result_get_op_res_gssize simple'
        touchManagedPtr simple
        return result

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultGetOpResGssizeMethodInfo
    instance (signature ~ (m Int64), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultGetOpResGssizeMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultGetOpResGssize

    #endif

    -- method SimpleAsyncResult::propagate_error
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAsyncResult.", 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_simple_async_result_propagate_error" g_simple_async_result_propagate_error ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {-# DEPRECATED simpleAsyncResultPropagateError ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' instead."] #-}
    {- |
    Propagates an error from within the simple asynchronous result to
    a given destination.

    If the 'GI.Gio.Objects.Cancellable.Cancellable' given to a prior call to
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetCheckCancellable' is cancelled then this
    function will return 'True' with /@dest@/ set appropriately.
    -}
    simpleAsyncResultPropagateError ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    simpleAsyncResultPropagateError simple = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        onException (do
            _ <- propagateGError $ g_simple_async_result_propagate_error simple'
            touchManagedPtr simple
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultPropagateErrorMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultPropagateErrorMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultPropagateError

    #endif

    -- method SimpleAsyncResult::set_check_cancellable
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "check_cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable to check, or %NULL to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_set_check_cancellable" g_simple_async_result_set_check_cancellable ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Ptr Gio.Cancellable.Cancellable ->      -- check_cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        IO ()

    {-# DEPRECATED simpleAsyncResultSetCheckCancellable ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' instead."] #-}
    {- |
    Sets a 'GI.Gio.Objects.Cancellable.Cancellable' to check before dispatching results.

    This function has one very specific purpose: the provided cancellable
    is checked at the time of 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultPropagateError' If
    it is cancelled, these functions will return an \"Operation was
    cancelled\" error ('GI.Gio.Enums.IOErrorEnumCancelled').

    Implementors of cancellable asynchronous functions should use this in
    order to provide a guarantee to their callers that cancelling an
    async operation will reliably result in an error being returned for
    that operation (even if a positive result for the operation has
    already been sent as an idle to the main context to be dispatched).

    The checking described above is done regardless of any call to the
    unrelated 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetHandleCancellation' function.

    /Since: 2.32/
    -}
    simpleAsyncResultSetCheckCancellable ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult' -}
        -> Maybe (b)
        {- ^ /@checkCancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' to check, or 'Nothing' to unset -}
        -> m ()
    simpleAsyncResultSetCheckCancellable simple checkCancellable = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        maybeCheckCancellable <- case checkCancellable of
            Nothing -> return nullPtr
            Just jCheckCancellable -> do
                jCheckCancellable' <- unsafeManagedPtrCastPtr jCheckCancellable
                return jCheckCancellable'
        g_simple_async_result_set_check_cancellable simple' maybeCheckCancellable
        touchManagedPtr simple
        whenJust checkCancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultSetCheckCancellableMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSimpleAsyncResult a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SimpleAsyncResultSetCheckCancellableMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultSetCheckCancellable

    #endif

    -- method SimpleAsyncResult::set_from_error
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GError.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_async_result_set_from_error" g_simple_async_result_set_from_error ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Ptr GError ->                           -- error : TError
        IO ()

    {-# DEPRECATED simpleAsyncResultSetFromError ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskReturnError' instead."] #-}
    {- |
    Sets the result from a 'GError'.
    -}
    simpleAsyncResultSetFromError ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> GError
        {- ^ /@error@/: 'GError'. -}
        -> m ()
    simpleAsyncResultSetFromError simple error_ = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        error_' <- unsafeManagedPtrGetPtr error_
        g_simple_async_result_set_from_error simple' error_'
        touchManagedPtr simple
        touchManagedPtr error_
        return ()

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultSetFromErrorMethodInfo
    instance (signature ~ (GError -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultSetFromErrorMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultSetFromError

    #endif

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

    foreign import ccall "g_simple_async_result_set_handle_cancellation" g_simple_async_result_set_handle_cancellation ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        CInt ->                                 -- handle_cancellation : TBasicType TBoolean
        IO ()

    {-# DEPRECATED simpleAsyncResultSetHandleCancellation ["(Since version 2.46)"] #-}
    {- |
    Sets whether to handle cancellation within the asynchronous operation.

    This function has nothing to do with
    'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultSetCheckCancellable'.  It only refers to the
    'GI.Gio.Objects.Cancellable.Cancellable' passed to @/g_simple_async_result_run_in_thread()/@.
    -}
    simpleAsyncResultSetHandleCancellation ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> Bool
        {- ^ /@handleCancellation@/: a 'Bool'. -}
        -> m ()
    simpleAsyncResultSetHandleCancellation simple handleCancellation = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        let handleCancellation' = (fromIntegral . fromEnum) handleCancellation
        g_simple_async_result_set_handle_cancellation simple' handleCancellation'
        touchManagedPtr simple
        return ()

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultSetHandleCancellationMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultSetHandleCancellationMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultSetHandleCancellation

    #endif

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

    foreign import ccall "g_simple_async_result_set_op_res_gboolean" g_simple_async_result_set_op_res_gboolean ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        CInt ->                                 -- op_res : TBasicType TBoolean
        IO ()

    {-# DEPRECATED simpleAsyncResultSetOpResGboolean ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskReturnBoolean' instead."] #-}
    {- |
    Sets the operation result to a boolean within the asynchronous result.
    -}
    simpleAsyncResultSetOpResGboolean ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> Bool
        {- ^ /@opRes@/: a 'Bool'. -}
        -> m ()
    simpleAsyncResultSetOpResGboolean simple opRes = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        let opRes' = (fromIntegral . fromEnum) opRes
        g_simple_async_result_set_op_res_gboolean simple' opRes'
        touchManagedPtr simple
        return ()

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultSetOpResGbooleanMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultSetOpResGbooleanMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultSetOpResGboolean

    #endif

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

    foreign import ccall "g_simple_async_result_set_op_res_gssize" g_simple_async_result_set_op_res_gssize ::
        Ptr SimpleAsyncResult ->                -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAsyncResult"})
        Int64 ->                                -- op_res : TBasicType TInt64
        IO ()

    {-# DEPRECATED simpleAsyncResultSetOpResGssize ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskReturnInt' instead."] #-}
    {- |
    Sets the operation result within the asynchronous result to
    the given /@opRes@/.
    -}
    simpleAsyncResultSetOpResGssize ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAsyncResult a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'. -}
        -> Int64
        {- ^ /@opRes@/: a @/gssize/@. -}
        -> m ()
    simpleAsyncResultSetOpResGssize simple opRes = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        g_simple_async_result_set_op_res_gssize simple' opRes
        touchManagedPtr simple
        return ()

    #if ENABLE_OVERLOADING
    data SimpleAsyncResultSetOpResGssizeMethodInfo
    instance (signature ~ (Int64 -> m ()), MonadIO m, IsSimpleAsyncResult a) => O.MethodInfo SimpleAsyncResultSetOpResGssizeMethodInfo a signature where
        overloadedMethod _ = simpleAsyncResultSetOpResGssize

    #endif

    -- method SimpleAsyncResult::is_valid
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult passed to the _finish function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GObject passed to the _finish function.", 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 "the asynchronous function.", 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_simple_async_result_is_valid" g_simple_async_result_is_valid ::
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr GObject.Object.Object ->            -- source : TInterface (Name {namespace = "GObject", name = "Object"})
        Ptr () ->                               -- source_tag : TBasicType TPtr
        IO CInt

    {-# DEPRECATED simpleAsyncResultIsValid ["(Since version 2.46)","Use 'GI.Gio.Objects.Task.Task' and 'GI.Gio.Objects.Task.taskIsValid' instead."] #-}
    {- |
    Ensures that the data passed to the _finish function of an async
    operation is consistent.  Three checks are performed.

    First, /@result@/ is checked to ensure that it is really a
    'GI.Gio.Objects.SimpleAsyncResult.SimpleAsyncResult'.  Second, /@source@/ is checked to ensure that it
    matches the source object of /@result@/.  Third, /@sourceTag@/ is
    checked to ensure that it is equal to the /@sourceTag@/ argument given
    to 'GI.Gio.Objects.SimpleAsyncResult.simpleAsyncResultNew' (which, by convention, is a pointer
    to the _async function corresponding to the _finish function from
    which this function is called).  (Alternatively, if either
    /@sourceTag@/ or /@result@/\'s source tag is 'Nothing', then the source tag
    check is skipped.)

    /Since: 2.20/
    -}
    simpleAsyncResultIsValid ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a, GObject.Object.IsObject b) =>
        a
        {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' passed to the _finish function. -}
        -> Maybe (b)
        {- ^ /@source@/: the 'GI.GObject.Objects.Object.Object' passed to the _finish function. -}
        -> Ptr ()
        {- ^ /@sourceTag@/: the asynchronous function. -}
        -> m Bool
        {- ^ __Returns:__ @/TRUE/@ if all checks passed or @/FALSE/@ if any failed. -}
    simpleAsyncResultIsValid result_ source sourceTag = liftIO $ do
        result_' <- unsafeManagedPtrCastPtr result_
        maybeSource <- case source of
            Nothing -> return nullPtr
            Just jSource -> do
                jSource' <- unsafeManagedPtrCastPtr jSource
                return jSource'
        result <- g_simple_async_result_is_valid result_' maybeSource sourceTag
        let result' = (/= 0) result
        touchManagedPtr result_
        whenJust source touchManagedPtr
        return result'

    #if ENABLE_OVERLOADING
    #endif