{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Objects.AsyncProgress
(
AsyncProgress(..) ,
IsAsyncProgress ,
toAsyncProgress ,
#if defined(ENABLE_OVERLOADING)
ResolveAsyncProgressMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
AsyncProgressCopyStateMethodInfo ,
#endif
asyncProgressCopyState ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressFinishMethodInfo ,
#endif
asyncProgressFinish ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressGetStatusMethodInfo ,
#endif
asyncProgressGetStatus ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressGetUintMethodInfo ,
#endif
asyncProgressGetUint ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressGetUint64MethodInfo ,
#endif
asyncProgressGetUint64 ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressGetVariantMethodInfo ,
#endif
asyncProgressGetVariant ,
asyncProgressNew ,
asyncProgressNewAndConnect ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressSetStatusMethodInfo ,
#endif
asyncProgressSetStatus ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressSetUintMethodInfo ,
#endif
asyncProgressSetUint ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressSetUint64MethodInfo ,
#endif
asyncProgressSetUint64 ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressSetVariantMethodInfo ,
#endif
asyncProgressSetVariant ,
AsyncProgressChangedCallback ,
#if defined(ENABLE_OVERLOADING)
AsyncProgressChangedSignalInfo ,
#endif
afterAsyncProgressChanged ,
onAsyncProgressChanged ,
) 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.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
newtype AsyncProgress = AsyncProgress (SP.ManagedPtr AsyncProgress)
deriving (AsyncProgress -> AsyncProgress -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AsyncProgress -> AsyncProgress -> Bool
$c/= :: AsyncProgress -> AsyncProgress -> Bool
== :: AsyncProgress -> AsyncProgress -> Bool
$c== :: AsyncProgress -> AsyncProgress -> Bool
Eq)
instance SP.ManagedPtrNewtype AsyncProgress where
toManagedPtr :: AsyncProgress -> ManagedPtr AsyncProgress
toManagedPtr (AsyncProgress ManagedPtr AsyncProgress
p) = ManagedPtr AsyncProgress
p
foreign import ccall "ostree_async_progress_get_type"
c_ostree_async_progress_get_type :: IO B.Types.GType
instance B.Types.TypedObject AsyncProgress where
glibType :: IO GType
glibType = IO GType
c_ostree_async_progress_get_type
instance B.Types.GObject AsyncProgress
class (SP.GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o
instance (SP.GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o
instance O.HasParentTypes AsyncProgress
type instance O.ParentTypes AsyncProgress = '[GObject.Object.Object]
toAsyncProgress :: (MIO.MonadIO m, IsAsyncProgress o) => o -> m AsyncProgress
toAsyncProgress :: forall (m :: * -> *) o.
(MonadIO m, IsAsyncProgress o) =>
o -> m AsyncProgress
toAsyncProgress = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr AsyncProgress -> AsyncProgress
AsyncProgress
instance B.GValue.IsGValue (Maybe AsyncProgress) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_async_progress_get_type
gvalueSet_ :: Ptr GValue -> Maybe AsyncProgress -> IO ()
gvalueSet_ Ptr GValue
gv Maybe AsyncProgress
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr AsyncProgress)
gvalueSet_ Ptr GValue
gv (P.Just AsyncProgress
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AsyncProgress
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe AsyncProgress)
gvalueGet_ Ptr GValue
gv = do
Ptr AsyncProgress
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr AsyncProgress)
if Ptr AsyncProgress
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr AsyncProgress -> AsyncProgress
AsyncProgress Ptr AsyncProgress
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveAsyncProgressMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveAsyncProgressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveAsyncProgressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveAsyncProgressMethod "copyState" o = AsyncProgressCopyStateMethodInfo
ResolveAsyncProgressMethod "finish" o = AsyncProgressFinishMethodInfo
ResolveAsyncProgressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveAsyncProgressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveAsyncProgressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveAsyncProgressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveAsyncProgressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveAsyncProgressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveAsyncProgressMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveAsyncProgressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveAsyncProgressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveAsyncProgressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveAsyncProgressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveAsyncProgressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveAsyncProgressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveAsyncProgressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveAsyncProgressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveAsyncProgressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveAsyncProgressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveAsyncProgressMethod "getStatus" o = AsyncProgressGetStatusMethodInfo
ResolveAsyncProgressMethod "getUint" o = AsyncProgressGetUintMethodInfo
ResolveAsyncProgressMethod "getUint64" o = AsyncProgressGetUint64MethodInfo
ResolveAsyncProgressMethod "getVariant" o = AsyncProgressGetVariantMethodInfo
ResolveAsyncProgressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveAsyncProgressMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveAsyncProgressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveAsyncProgressMethod "setStatus" o = AsyncProgressSetStatusMethodInfo
ResolveAsyncProgressMethod "setUint" o = AsyncProgressSetUintMethodInfo
ResolveAsyncProgressMethod "setUint64" o = AsyncProgressSetUint64MethodInfo
ResolveAsyncProgressMethod "setVariant" o = AsyncProgressSetVariantMethodInfo
ResolveAsyncProgressMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAsyncProgressMethod t AsyncProgress, O.OverloadedMethod info AsyncProgress p) => OL.IsLabel t (AsyncProgress -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveAsyncProgressMethod t AsyncProgress, O.OverloadedMethod info AsyncProgress p, R.HasField t AsyncProgress p) => R.HasField t AsyncProgress p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAsyncProgressMethod t AsyncProgress, O.OverloadedMethodInfo info AsyncProgress) => OL.IsLabel t (O.MethodProxy info AsyncProgress) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type AsyncProgressChangedCallback =
IO ()
type C_AsyncProgressChangedCallback =
Ptr AsyncProgress ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_AsyncProgressChangedCallback :: C_AsyncProgressChangedCallback -> IO (FunPtr C_AsyncProgressChangedCallback)
wrap_AsyncProgressChangedCallback ::
GObject a => (a -> AsyncProgressChangedCallback) ->
C_AsyncProgressChangedCallback
wrap_AsyncProgressChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_AsyncProgressChangedCallback
wrap_AsyncProgressChangedCallback a -> IO ()
gi'cb Ptr AsyncProgress
gi'selfPtr Ptr ()
_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr AsyncProgress
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \AsyncProgress
gi'self -> a -> IO ()
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce AsyncProgress
gi'self)
onAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> ((?self :: a) => AsyncProgressChangedCallback) -> m SignalHandlerId
onAsyncProgressChanged :: forall a (m :: * -> *).
(IsAsyncProgress a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onAsyncProgressChanged a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_AsyncProgressChangedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_AsyncProgressChangedCallback
wrap_AsyncProgressChangedCallback a -> IO ()
wrapped
FunPtr C_AsyncProgressChangedCallback
wrapped'' <- C_AsyncProgressChangedCallback
-> IO (FunPtr C_AsyncProgressChangedCallback)
mk_AsyncProgressChangedCallback C_AsyncProgressChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"changed" FunPtr C_AsyncProgressChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> ((?self :: a) => AsyncProgressChangedCallback) -> m SignalHandlerId
afterAsyncProgressChanged :: forall a (m :: * -> *).
(IsAsyncProgress a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterAsyncProgressChanged a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_AsyncProgressChangedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_AsyncProgressChangedCallback
wrap_AsyncProgressChangedCallback a -> IO ()
wrapped
FunPtr C_AsyncProgressChangedCallback
wrapped'' <- C_AsyncProgressChangedCallback
-> IO (FunPtr C_AsyncProgressChangedCallback)
mk_AsyncProgressChangedCallback C_AsyncProgressChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"changed" FunPtr C_AsyncProgressChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data AsyncProgressChangedSignalInfo
instance SignalInfo AsyncProgressChangedSignalInfo where
type HaskellCallbackType AsyncProgressChangedSignalInfo = AsyncProgressChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_AsyncProgressChangedCallback cb
cb'' <- mk_AsyncProgressChangedCallback cb'
connectSignalFunPtr obj "changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress::changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#g:signal:changed"})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AsyncProgress
type instance O.AttributeList AsyncProgress = AsyncProgressAttributeList
type AsyncProgressAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList AsyncProgress = AsyncProgressSignalList
type AsyncProgressSignalList = ('[ '("changed", AsyncProgressChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "ostree_async_progress_new" ostree_async_progress_new ::
IO (Ptr AsyncProgress)
asyncProgressNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m AsyncProgress
asyncProgressNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m AsyncProgress
asyncProgressNew = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
result <- IO (Ptr AsyncProgress)
ostree_async_progress_new
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"asyncProgressNew" Ptr AsyncProgress
result
AsyncProgress
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr AsyncProgress -> AsyncProgress
AsyncProgress) Ptr AsyncProgress
result
forall (m :: * -> *) a. Monad m => a -> m a
return AsyncProgress
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ostree_async_progress_new_and_connect" ostree_async_progress_new_and_connect ::
Ptr () ->
Ptr () ->
IO (Ptr AsyncProgress)
asyncProgressNewAndConnect ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> Ptr ()
-> m AsyncProgress
asyncProgressNewAndConnect :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> Ptr () -> m AsyncProgress
asyncProgressNewAndConnect Ptr ()
changed Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
result <- Ptr () -> Ptr () -> IO (Ptr AsyncProgress)
ostree_async_progress_new_and_connect Ptr ()
changed Ptr ()
userData
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"asyncProgressNewAndConnect" Ptr AsyncProgress
result
AsyncProgress
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr AsyncProgress -> AsyncProgress
AsyncProgress) Ptr AsyncProgress
result
forall (m :: * -> *) a. Monad m => a -> m a
return AsyncProgress
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ostree_async_progress_copy_state" ostree_async_progress_copy_state ::
Ptr AsyncProgress ->
Ptr AsyncProgress ->
IO ()
asyncProgressCopyState ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a, IsAsyncProgress b) =>
a
-> b
-> m ()
asyncProgressCopyState :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAsyncProgress a, IsAsyncProgress b) =>
a -> b -> m ()
asyncProgressCopyState a
self b
dest = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr AsyncProgress
dest' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr AsyncProgress -> Ptr AsyncProgress -> IO ()
ostree_async_progress_copy_state Ptr AsyncProgress
self' Ptr AsyncProgress
dest'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressCopyStateMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsAsyncProgress a, IsAsyncProgress b) => O.OverloadedMethod AsyncProgressCopyStateMethodInfo a signature where
overloadedMethod = asyncProgressCopyState
instance O.OverloadedMethodInfo AsyncProgressCopyStateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressCopyState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressCopyState"
})
#endif
foreign import ccall "ostree_async_progress_finish" ostree_async_progress_finish ::
Ptr AsyncProgress ->
IO ()
asyncProgressFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> m ()
asyncProgressFinish :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> m ()
asyncProgressFinish a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr AsyncProgress -> IO ()
ostree_async_progress_finish Ptr AsyncProgress
self'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressFinishMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressFinishMethodInfo a signature where
overloadedMethod = asyncProgressFinish
instance O.OverloadedMethodInfo AsyncProgressFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressFinish"
})
#endif
foreign import ccall "ostree_async_progress_get_status" ostree_async_progress_get_status ::
Ptr AsyncProgress ->
IO CString
asyncProgressGetStatus ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> m (Maybe T.Text)
asyncProgressGetStatus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> m (Maybe Text)
asyncProgressGetStatus a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
result <- Ptr AsyncProgress -> IO CString
ostree_async_progress_get_status Ptr AsyncProgress
self'
Maybe Text
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall a. Ptr a -> IO ()
freeMem CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetStatusMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressGetStatusMethodInfo a signature where
overloadedMethod = asyncProgressGetStatus
instance O.OverloadedMethodInfo AsyncProgressGetStatusMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressGetStatus",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressGetStatus"
})
#endif
foreign import ccall "ostree_async_progress_get_uint" ostree_async_progress_get_uint ::
Ptr AsyncProgress ->
CString ->
IO Word32
asyncProgressGetUint ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> T.Text
-> m Word32
asyncProgressGetUint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Text -> m Word32
asyncProgressGetUint a
self Text
key = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
key' <- Text -> IO CString
textToCString Text
key
Word32
result <- Ptr AsyncProgress -> CString -> IO Word32
ostree_async_progress_get_uint Ptr AsyncProgress
self' CString
key'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetUintMethodInfo
instance (signature ~ (T.Text -> m Word32), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressGetUintMethodInfo a signature where
overloadedMethod = asyncProgressGetUint
instance O.OverloadedMethodInfo AsyncProgressGetUintMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressGetUint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressGetUint"
})
#endif
foreign import ccall "ostree_async_progress_get_uint64" ostree_async_progress_get_uint64 ::
Ptr AsyncProgress ->
CString ->
IO Word64
asyncProgressGetUint64 ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> T.Text
-> m Word64
asyncProgressGetUint64 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Text -> m Word64
asyncProgressGetUint64 a
self Text
key = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
key' <- Text -> IO CString
textToCString Text
key
Word64
result <- Ptr AsyncProgress -> CString -> IO Word64
ostree_async_progress_get_uint64 Ptr AsyncProgress
self' CString
key'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetUint64MethodInfo
instance (signature ~ (T.Text -> m Word64), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressGetUint64MethodInfo a signature where
overloadedMethod = asyncProgressGetUint64
instance O.OverloadedMethodInfo AsyncProgressGetUint64MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressGetUint64",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressGetUint64"
})
#endif
foreign import ccall "ostree_async_progress_get_variant" ostree_async_progress_get_variant ::
Ptr AsyncProgress ->
CString ->
IO (Ptr GVariant)
asyncProgressGetVariant ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> T.Text
-> m (Maybe GVariant)
asyncProgressGetVariant :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Text -> m (Maybe GVariant)
asyncProgressGetVariant a
self Text
key = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr GVariant
result <- Ptr AsyncProgress -> CString -> IO (Ptr GVariant)
ostree_async_progress_get_variant Ptr AsyncProgress
self' CString
key'
Maybe GVariant
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result'
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetVariantMethodInfo
instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressGetVariantMethodInfo a signature where
overloadedMethod = asyncProgressGetVariant
instance O.OverloadedMethodInfo AsyncProgressGetVariantMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressGetVariant",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressGetVariant"
})
#endif
foreign import ccall "ostree_async_progress_set_status" ostree_async_progress_set_status ::
Ptr AsyncProgress ->
CString ->
IO ()
asyncProgressSetStatus ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> Maybe (T.Text)
-> m ()
asyncProgressSetStatus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Maybe Text -> m ()
asyncProgressSetStatus a
self Maybe Text
status = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
maybeStatus <- case Maybe Text
status of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jStatus -> do
CString
jStatus' <- Text -> IO CString
textToCString Text
jStatus
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jStatus'
Ptr AsyncProgress -> CString -> IO ()
ostree_async_progress_set_status Ptr AsyncProgress
self' CString
maybeStatus
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
maybeStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetStatusMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressSetStatusMethodInfo a signature where
overloadedMethod = asyncProgressSetStatus
instance O.OverloadedMethodInfo AsyncProgressSetStatusMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressSetStatus",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressSetStatus"
})
#endif
foreign import ccall "ostree_async_progress_set_uint" ostree_async_progress_set_uint ::
Ptr AsyncProgress ->
CString ->
Word32 ->
IO ()
asyncProgressSetUint ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> T.Text
-> Word32
-> m ()
asyncProgressSetUint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Text -> Word32 -> m ()
asyncProgressSetUint a
self Text
key Word32
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr AsyncProgress -> CString -> Word32 -> IO ()
ostree_async_progress_set_uint Ptr AsyncProgress
self' CString
key' Word32
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetUintMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressSetUintMethodInfo a signature where
overloadedMethod = asyncProgressSetUint
instance O.OverloadedMethodInfo AsyncProgressSetUintMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressSetUint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressSetUint"
})
#endif
foreign import ccall "ostree_async_progress_set_uint64" ostree_async_progress_set_uint64 ::
Ptr AsyncProgress ->
CString ->
Word64 ->
IO ()
asyncProgressSetUint64 ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> T.Text
-> Word64
-> m ()
asyncProgressSetUint64 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Text -> Word64 -> m ()
asyncProgressSetUint64 a
self Text
key Word64
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr AsyncProgress -> CString -> Word64 -> IO ()
ostree_async_progress_set_uint64 Ptr AsyncProgress
self' CString
key' Word64
value
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetUint64MethodInfo
instance (signature ~ (T.Text -> Word64 -> m ()), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressSetUint64MethodInfo a signature where
overloadedMethod = asyncProgressSetUint64
instance O.OverloadedMethodInfo AsyncProgressSetUint64MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressSetUint64",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressSetUint64"
})
#endif
foreign import ccall "ostree_async_progress_set_variant" ostree_async_progress_set_variant ::
Ptr AsyncProgress ->
CString ->
Ptr GVariant ->
IO ()
asyncProgressSetVariant ::
(B.CallStack.HasCallStack, MonadIO m, IsAsyncProgress a) =>
a
-> T.Text
-> GVariant
-> m ()
asyncProgressSetVariant :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Text -> GVariant -> m ()
asyncProgressSetVariant a
self Text
key GVariant
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncProgress
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr GVariant
value' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr AsyncProgress -> CString -> Ptr GVariant -> IO ()
ostree_async_progress_set_variant Ptr AsyncProgress
self' CString
key' Ptr GVariant
value'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetVariantMethodInfo
instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m, IsAsyncProgress a) => O.OverloadedMethod AsyncProgressSetVariantMethodInfo a signature where
overloadedMethod = asyncProgressSetVariant
instance O.OverloadedMethodInfo AsyncProgressSetVariantMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Objects.AsyncProgress.asyncProgressSetVariant",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-AsyncProgress.html#v:asyncProgressSetVariant"
})
#endif