{-# LANGUAGE 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 ,
noAsyncProgress ,
#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
C_AsyncProgressChangedCallback ,
afterAsyncProgressChanged ,
genClosure_AsyncProgressChanged ,
mk_AsyncProgressChangedCallback ,
noAsyncProgressChangedCallback ,
onAsyncProgressChanged ,
wrap_AsyncProgressChangedCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
newtype AsyncProgress = AsyncProgress (ManagedPtr AsyncProgress)
deriving (Eq)
foreign import ccall "ostree_async_progress_get_type"
c_ostree_async_progress_get_type :: IO GType
instance GObject AsyncProgress where
gobjectType = c_ostree_async_progress_get_type
instance B.GValue.IsGValue AsyncProgress where
toGValue o = do
gtype <- c_ostree_async_progress_get_type
B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)
fromGValue gv = do
ptr <- B.GValue.get_object gv :: IO (Ptr AsyncProgress)
B.ManagedPtr.newObject AsyncProgress ptr
class (GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o
instance (GObject o, O.IsDescendantOf AsyncProgress o) => IsAsyncProgress o
instance O.HasParentTypes AsyncProgress
type instance O.ParentTypes AsyncProgress = '[GObject.Object.Object]
toAsyncProgress :: (MonadIO m, IsAsyncProgress o) => o -> m AsyncProgress
toAsyncProgress = liftIO . unsafeCastTo AsyncProgress
noAsyncProgress :: Maybe AsyncProgress
noAsyncProgress = Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveAsyncProgressMethod (t :: Symbol) (o :: *) :: * 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.MethodInfo 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
#endif
type AsyncProgressChangedCallback =
IO ()
noAsyncProgressChangedCallback :: Maybe AsyncProgressChangedCallback
noAsyncProgressChangedCallback = Nothing
type C_AsyncProgressChangedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_AsyncProgressChangedCallback :: C_AsyncProgressChangedCallback -> IO (FunPtr C_AsyncProgressChangedCallback)
genClosure_AsyncProgressChanged :: MonadIO m => AsyncProgressChangedCallback -> m (GClosure C_AsyncProgressChangedCallback)
genClosure_AsyncProgressChanged cb = liftIO $ do
let cb' = wrap_AsyncProgressChangedCallback cb
mk_AsyncProgressChangedCallback cb' >>= B.GClosure.newGClosure
wrap_AsyncProgressChangedCallback ::
AsyncProgressChangedCallback ->
C_AsyncProgressChangedCallback
wrap_AsyncProgressChangedCallback _cb _ _ = do
_cb
onAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> AsyncProgressChangedCallback -> m SignalHandlerId
onAsyncProgressChanged obj cb = liftIO $ do
let cb' = wrap_AsyncProgressChangedCallback cb
cb'' <- mk_AsyncProgressChangedCallback cb'
connectSignalFunPtr obj "changed" cb'' SignalConnectBefore Nothing
afterAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> AsyncProgressChangedCallback -> m SignalHandlerId
afterAsyncProgressChanged obj cb = liftIO $ do
let cb' = wrap_AsyncProgressChangedCallback cb
cb'' <- mk_AsyncProgressChangedCallback cb'
connectSignalFunPtr obj "changed" cb'' SignalConnectAfter 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
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AsyncProgress
type instance O.AttributeList AsyncProgress = AsyncProgressAttributeList
type AsyncProgressAttributeList = ('[ ] :: [(Symbol, *)])
#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, *)])
#endif
foreign import ccall "ostree_async_progress_new" ostree_async_progress_new ::
IO (Ptr AsyncProgress)
asyncProgressNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m AsyncProgress
asyncProgressNew = liftIO $ do
result <- ostree_async_progress_new
checkUnexpectedReturnNULL "asyncProgressNew" result
result' <- (wrapObject AsyncProgress) result
return 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 changed userData = liftIO $ do
result <- ostree_async_progress_new_and_connect changed userData
checkUnexpectedReturnNULL "asyncProgressNewAndConnect" result
result' <- (wrapObject AsyncProgress) result
return 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 self dest = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
dest' <- unsafeManagedPtrCastPtr dest
ostree_async_progress_copy_state self' dest'
touchManagedPtr self
touchManagedPtr dest
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressCopyStateMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsAsyncProgress a, IsAsyncProgress b) => O.MethodInfo AsyncProgressCopyStateMethodInfo a signature where
overloadedMethod = 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 self = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
ostree_async_progress_finish self'
touchManagedPtr self
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressFinishMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressFinishMethodInfo a signature where
overloadedMethod = 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 self = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
result <- ostree_async_progress_get_status self'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- cstringToText result'
freeMem result'
return result''
touchManagedPtr self
return maybeResult
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetStatusMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetStatusMethodInfo a signature where
overloadedMethod = 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 self key = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
key' <- textToCString key
result <- ostree_async_progress_get_uint self' key'
touchManagedPtr self
freeMem key'
return result
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetUintMethodInfo
instance (signature ~ (T.Text -> m Word32), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetUintMethodInfo a signature where
overloadedMethod = 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 self key = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
key' <- textToCString key
result <- ostree_async_progress_get_uint64 self' key'
touchManagedPtr self
freeMem key'
return result
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetUint64MethodInfo
instance (signature ~ (T.Text -> m Word64), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetUint64MethodInfo a signature where
overloadedMethod = 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 self key = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
key' <- textToCString key
result <- ostree_async_progress_get_variant self' key'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- B.GVariant.wrapGVariantPtr result'
return result''
touchManagedPtr self
freeMem key'
return maybeResult
#if defined(ENABLE_OVERLOADING)
data AsyncProgressGetVariantMethodInfo
instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressGetVariantMethodInfo a signature where
overloadedMethod = 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 self status = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
maybeStatus <- case status of
Nothing -> return nullPtr
Just jStatus -> do
jStatus' <- textToCString jStatus
return jStatus'
ostree_async_progress_set_status self' maybeStatus
touchManagedPtr self
freeMem maybeStatus
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetStatusMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetStatusMethodInfo a signature where
overloadedMethod = 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 self key value = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
key' <- textToCString key
ostree_async_progress_set_uint self' key' value
touchManagedPtr self
freeMem key'
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetUintMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetUintMethodInfo a signature where
overloadedMethod = 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 self key value = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
key' <- textToCString key
ostree_async_progress_set_uint64 self' key' value
touchManagedPtr self
freeMem key'
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetUint64MethodInfo
instance (signature ~ (T.Text -> Word64 -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetUint64MethodInfo a signature where
overloadedMethod = 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 self key value = liftIO $ do
self' <- unsafeManagedPtrCastPtr self
key' <- textToCString key
value' <- unsafeManagedPtrGetPtr value
ostree_async_progress_set_variant self' key' value'
touchManagedPtr self
touchManagedPtr value
freeMem key'
return ()
#if defined(ENABLE_OVERLOADING)
data AsyncProgressSetVariantMethodInfo
instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m, IsAsyncProgress a) => O.MethodInfo AsyncProgressSetVariantMethodInfo a signature where
overloadedMethod = asyncProgressSetVariant
#endif