#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.Gio.Interfaces.AsyncResult
(
AsyncResult(..) ,
noAsyncResult ,
IsAsyncResult ,
toAsyncResult ,
#if ENABLE_OVERLOADING
AsyncResultGetSourceObjectMethodInfo ,
#endif
asyncResultGetSourceObject ,
#if ENABLE_OVERLOADING
AsyncResultGetUserDataMethodInfo ,
#endif
asyncResultGetUserData ,
#if ENABLE_OVERLOADING
AsyncResultIsTaggedMethodInfo ,
#endif
asyncResultIsTagged ,
#if 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.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
newtype AsyncResult = AsyncResult (ManagedPtr AsyncResult)
noAsyncResult :: Maybe AsyncResult
noAsyncResult :: Maybe AsyncResult
noAsyncResult = Maybe AsyncResult
forall a. Maybe a
Nothing
#if ENABLE_OVERLOADING
type instance O.SignalList AsyncResult = AsyncResultSignalList
type AsyncResultSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_async_result_get_type"
c_g_async_result_get_type :: IO GType
instance GObject AsyncResult where
gobjectType :: AsyncResult -> IO GType
gobjectType _ = IO GType
c_g_async_result_get_type
class GObject o => IsAsyncResult o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError AsyncResult a) =>
IsAsyncResult a
#endif
instance IsAsyncResult AsyncResult
instance GObject.Object.IsObject AsyncResult
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, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr AsyncResult -> AsyncResult
AsyncResult
#if ENABLE_OVERLOADING
instance O.HasAttributeList AsyncResult
type instance O.AttributeList AsyncResult = AsyncResultAttributeList
type AsyncResultAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
#endif
#if 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 "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveAsyncResultMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAsyncResultMethod t AsyncResult, O.MethodInfo info AsyncResult p) => O.IsLabelProxy t (AsyncResult -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAsyncResultMethod t AsyncResult, O.MethodInfo info AsyncResult p) => O.IsLabel t (AsyncResult -> 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
foreign import ccall "g_async_result_get_source_object" g_async_result_get_source_object ::
Ptr AsyncResult ->
IO (Ptr GObject.Object.Object)
asyncResultGetSourceObject ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
a
-> m (Maybe GObject.Object.Object)
asyncResultGetSourceObject :: a -> m (Maybe Object)
asyncResultGetSourceObject res :: 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
$ \result' :: 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 ENABLE_OVERLOADING
data AsyncResultGetSourceObjectMethodInfo
instance (signature ~ (m (Maybe GObject.Object.Object)), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultGetSourceObjectMethodInfo a signature where
overloadedMethod _ = asyncResultGetSourceObject
#endif
foreign import ccall "g_async_result_get_user_data" g_async_result_get_user_data ::
Ptr AsyncResult ->
IO (Ptr ())
asyncResultGetUserData ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
a
-> m (Ptr ())
asyncResultGetUserData :: a -> m (Ptr ())
asyncResultGetUserData res :: 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 ENABLE_OVERLOADING
data AsyncResultGetUserDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultGetUserDataMethodInfo a signature where
overloadedMethod _ = asyncResultGetUserData
#endif
foreign import ccall "g_async_result_is_tagged" g_async_result_is_tagged ::
Ptr AsyncResult ->
Ptr () ->
IO CInt
asyncResultIsTagged ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
a
-> Ptr ()
-> m Bool
asyncResultIsTagged :: a -> Ptr () -> m Bool
asyncResultIsTagged res :: a
res sourceTag :: 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
/= 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 ENABLE_OVERLOADING
data AsyncResultIsTaggedMethodInfo
instance (signature ~ (Ptr () -> m Bool), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultIsTaggedMethodInfo a signature where
overloadedMethod _ = asyncResultIsTagged
#endif
foreign import ccall "g_async_result_legacy_propagate_error" g_async_result_legacy_propagate_error ::
Ptr AsyncResult ->
Ptr (Ptr GError) ->
IO CInt
asyncResultLegacyPropagateError ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncResult a) =>
a
-> m ()
asyncResultLegacyPropagateError :: a -> m ()
asyncResultLegacyPropagateError res :: 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 ENABLE_OVERLOADING
data AsyncResultLegacyPropagateErrorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAsyncResult a) => O.MethodInfo AsyncResultLegacyPropagateErrorMethodInfo a signature where
overloadedMethod _ = asyncResultLegacyPropagateError
#endif