#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.GstPbutils.Objects.Discoverer
(
Discoverer(..) ,
IsDiscoverer ,
toDiscoverer ,
noDiscoverer ,
#if ENABLE_OVERLOADING
DiscovererDiscoverUriMethodInfo ,
#endif
discovererDiscoverUri ,
#if ENABLE_OVERLOADING
DiscovererDiscoverUriAsyncMethodInfo ,
#endif
discovererDiscoverUriAsync ,
discovererNew ,
#if ENABLE_OVERLOADING
DiscovererStartMethodInfo ,
#endif
discovererStart ,
#if ENABLE_OVERLOADING
DiscovererStopMethodInfo ,
#endif
discovererStop ,
#if ENABLE_OVERLOADING
DiscovererTimeoutPropertyInfo ,
#endif
constructDiscovererTimeout ,
#if ENABLE_OVERLOADING
discovererTimeout ,
#endif
getDiscovererTimeout ,
setDiscovererTimeout ,
#if ENABLE_OVERLOADING
DiscovererUseCachePropertyInfo ,
#endif
constructDiscovererUseCache ,
#if ENABLE_OVERLOADING
discovererUseCache ,
#endif
getDiscovererUseCache ,
setDiscovererUseCache ,
C_DiscovererDiscoveredCallback ,
DiscovererDiscoveredCallback ,
#if ENABLE_OVERLOADING
DiscovererDiscoveredSignalInfo ,
#endif
afterDiscovererDiscovered ,
genClosure_DiscovererDiscovered ,
mk_DiscovererDiscoveredCallback ,
noDiscovererDiscoveredCallback ,
onDiscovererDiscovered ,
wrap_DiscovererDiscoveredCallback ,
C_DiscovererFinishedCallback ,
DiscovererFinishedCallback ,
#if ENABLE_OVERLOADING
DiscovererFinishedSignalInfo ,
#endif
afterDiscovererFinished ,
genClosure_DiscovererFinished ,
mk_DiscovererFinishedCallback ,
noDiscovererFinishedCallback ,
onDiscovererFinished ,
wrap_DiscovererFinishedCallback ,
C_DiscovererSourceSetupCallback ,
DiscovererSourceSetupCallback ,
#if ENABLE_OVERLOADING
DiscovererSourceSetupSignalInfo ,
#endif
afterDiscovererSourceSetup ,
genClosure_DiscovererSourceSetup ,
mk_DiscovererSourceSetupCallback ,
noDiscovererSourceSetupCallback ,
onDiscovererSourceSetup ,
wrap_DiscovererSourceSetupCallback ,
C_DiscovererStartingCallback ,
DiscovererStartingCallback ,
#if ENABLE_OVERLOADING
DiscovererStartingSignalInfo ,
#endif
afterDiscovererStarting ,
genClosure_DiscovererStarting ,
mk_DiscovererStartingCallback ,
noDiscovererStartingCallback ,
onDiscovererStarting ,
wrap_DiscovererStartingCallback ,
) 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.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
import qualified GI.Gst.Objects.Element as Gst.Element
import {-# SOURCE #-} qualified GI.GstPbutils.Objects.DiscovererInfo as GstPbutils.DiscovererInfo
newtype Discoverer = Discoverer (ManagedPtr Discoverer)
foreign import ccall "gst_discoverer_get_type"
c_gst_discoverer_get_type :: IO GType
instance GObject Discoverer where
gobjectType = c_gst_discoverer_get_type
class (GObject o, O.IsDescendantOf Discoverer o) => IsDiscoverer o
instance (GObject o, O.IsDescendantOf Discoverer o) => IsDiscoverer o
instance O.HasParentTypes Discoverer
type instance O.ParentTypes Discoverer = '[GObject.Object.Object]
toDiscoverer :: (MonadIO m, IsDiscoverer o) => o -> m Discoverer
toDiscoverer = liftIO . unsafeCastTo Discoverer
noDiscoverer :: Maybe Discoverer
noDiscoverer = Nothing
#if ENABLE_OVERLOADING
type family ResolveDiscovererMethod (t :: Symbol) (o :: *) :: * where
ResolveDiscovererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDiscovererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDiscovererMethod "discoverUri" o = DiscovererDiscoverUriMethodInfo
ResolveDiscovererMethod "discoverUriAsync" o = DiscovererDiscoverUriAsyncMethodInfo
ResolveDiscovererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDiscovererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDiscovererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDiscovererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDiscovererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDiscovererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDiscovererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDiscovererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDiscovererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDiscovererMethod "start" o = DiscovererStartMethodInfo
ResolveDiscovererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDiscovererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDiscovererMethod "stop" o = DiscovererStopMethodInfo
ResolveDiscovererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDiscovererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDiscovererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDiscovererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDiscovererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDiscovererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDiscovererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDiscovererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDiscovererMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDiscovererMethod t Discoverer, O.MethodInfo info Discoverer p) => OL.IsLabel t (Discoverer -> 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
type DiscovererDiscoveredCallback =
GstPbutils.DiscovererInfo.DiscovererInfo
-> Maybe GError
-> IO ()
noDiscovererDiscoveredCallback :: Maybe DiscovererDiscoveredCallback
noDiscovererDiscoveredCallback = Nothing
type C_DiscovererDiscoveredCallback =
Ptr () ->
Ptr GstPbutils.DiscovererInfo.DiscovererInfo ->
Ptr GError ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererDiscoveredCallback :: C_DiscovererDiscoveredCallback -> IO (FunPtr C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered :: MonadIO m => DiscovererDiscoveredCallback -> m (GClosure C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered cb = liftIO $ do
let cb' = wrap_DiscovererDiscoveredCallback cb
mk_DiscovererDiscoveredCallback cb' >>= B.GClosure.newGClosure
wrap_DiscovererDiscoveredCallback ::
DiscovererDiscoveredCallback ->
C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback _cb _ info error_ _ = do
info' <- (newObject GstPbutils.DiscovererInfo.DiscovererInfo) info
maybeError_ <-
if error_ == nullPtr
then return Nothing
else do
error_' <- (newBoxed GError) error_
return $ Just error_'
_cb info' maybeError_
onDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId
onDiscovererDiscovered obj cb = liftIO $ do
let cb' = wrap_DiscovererDiscoveredCallback cb
cb'' <- mk_DiscovererDiscoveredCallback cb'
connectSignalFunPtr obj "discovered" cb'' SignalConnectBefore
afterDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId
afterDiscovererDiscovered obj cb = liftIO $ do
let cb' = wrap_DiscovererDiscoveredCallback cb
cb'' <- mk_DiscovererDiscoveredCallback cb'
connectSignalFunPtr obj "discovered" cb'' SignalConnectAfter
type DiscovererFinishedCallback =
IO ()
noDiscovererFinishedCallback :: Maybe DiscovererFinishedCallback
noDiscovererFinishedCallback = Nothing
type C_DiscovererFinishedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererFinishedCallback :: C_DiscovererFinishedCallback -> IO (FunPtr C_DiscovererFinishedCallback)
genClosure_DiscovererFinished :: MonadIO m => DiscovererFinishedCallback -> m (GClosure C_DiscovererFinishedCallback)
genClosure_DiscovererFinished cb = liftIO $ do
let cb' = wrap_DiscovererFinishedCallback cb
mk_DiscovererFinishedCallback cb' >>= B.GClosure.newGClosure
wrap_DiscovererFinishedCallback ::
DiscovererFinishedCallback ->
C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback _cb _ _ = do
_cb
onDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId
onDiscovererFinished obj cb = liftIO $ do
let cb' = wrap_DiscovererFinishedCallback cb
cb'' <- mk_DiscovererFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' SignalConnectBefore
afterDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId
afterDiscovererFinished obj cb = liftIO $ do
let cb' = wrap_DiscovererFinishedCallback cb
cb'' <- mk_DiscovererFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' SignalConnectAfter
type DiscovererSourceSetupCallback =
Gst.Element.Element
-> IO ()
noDiscovererSourceSetupCallback :: Maybe DiscovererSourceSetupCallback
noDiscovererSourceSetupCallback = Nothing
type C_DiscovererSourceSetupCallback =
Ptr () ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererSourceSetupCallback :: C_DiscovererSourceSetupCallback -> IO (FunPtr C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup :: MonadIO m => DiscovererSourceSetupCallback -> m (GClosure C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup cb = liftIO $ do
let cb' = wrap_DiscovererSourceSetupCallback cb
mk_DiscovererSourceSetupCallback cb' >>= B.GClosure.newGClosure
wrap_DiscovererSourceSetupCallback ::
DiscovererSourceSetupCallback ->
C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback _cb _ source _ = do
source' <- (newObject Gst.Element.Element) source
_cb source'
onDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId
onDiscovererSourceSetup obj cb = liftIO $ do
let cb' = wrap_DiscovererSourceSetupCallback cb
cb'' <- mk_DiscovererSourceSetupCallback cb'
connectSignalFunPtr obj "source-setup" cb'' SignalConnectBefore
afterDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId
afterDiscovererSourceSetup obj cb = liftIO $ do
let cb' = wrap_DiscovererSourceSetupCallback cb
cb'' <- mk_DiscovererSourceSetupCallback cb'
connectSignalFunPtr obj "source-setup" cb'' SignalConnectAfter
type DiscovererStartingCallback =
IO ()
noDiscovererStartingCallback :: Maybe DiscovererStartingCallback
noDiscovererStartingCallback = Nothing
type C_DiscovererStartingCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererStartingCallback :: C_DiscovererStartingCallback -> IO (FunPtr C_DiscovererStartingCallback)
genClosure_DiscovererStarting :: MonadIO m => DiscovererStartingCallback -> m (GClosure C_DiscovererStartingCallback)
genClosure_DiscovererStarting cb = liftIO $ do
let cb' = wrap_DiscovererStartingCallback cb
mk_DiscovererStartingCallback cb' >>= B.GClosure.newGClosure
wrap_DiscovererStartingCallback ::
DiscovererStartingCallback ->
C_DiscovererStartingCallback
wrap_DiscovererStartingCallback _cb _ _ = do
_cb
onDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId
onDiscovererStarting obj cb = liftIO $ do
let cb' = wrap_DiscovererStartingCallback cb
cb'' <- mk_DiscovererStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' SignalConnectBefore
afterDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId
afterDiscovererStarting obj cb = liftIO $ do
let cb' = wrap_DiscovererStartingCallback cb
cb'' <- mk_DiscovererStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' SignalConnectAfter
getDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> m Word64
getDiscovererTimeout obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "timeout"
setDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> Word64 -> m ()
setDiscovererTimeout obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "timeout" val
constructDiscovererTimeout :: (IsDiscoverer o) => Word64 -> IO (GValueConstruct o)
constructDiscovererTimeout val = B.Properties.constructObjectPropertyUInt64 "timeout" val
#if ENABLE_OVERLOADING
data DiscovererTimeoutPropertyInfo
instance AttrInfo DiscovererTimeoutPropertyInfo where
type AttrAllowedOps DiscovererTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint DiscovererTimeoutPropertyInfo = (~) Word64
type AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo = IsDiscoverer
type AttrGetType DiscovererTimeoutPropertyInfo = Word64
type AttrLabel DiscovererTimeoutPropertyInfo = "timeout"
type AttrOrigin DiscovererTimeoutPropertyInfo = Discoverer
attrGet _ = getDiscovererTimeout
attrSet _ = setDiscovererTimeout
attrConstruct _ = constructDiscovererTimeout
attrClear _ = undefined
#endif
getDiscovererUseCache :: (MonadIO m, IsDiscoverer o) => o -> m Bool
getDiscovererUseCache obj = liftIO $ B.Properties.getObjectPropertyBool obj "use-cache"
setDiscovererUseCache :: (MonadIO m, IsDiscoverer o) => o -> Bool -> m ()
setDiscovererUseCache obj val = liftIO $ B.Properties.setObjectPropertyBool obj "use-cache" val
constructDiscovererUseCache :: (IsDiscoverer o) => Bool -> IO (GValueConstruct o)
constructDiscovererUseCache val = B.Properties.constructObjectPropertyBool "use-cache" val
#if ENABLE_OVERLOADING
data DiscovererUseCachePropertyInfo
instance AttrInfo DiscovererUseCachePropertyInfo where
type AttrAllowedOps DiscovererUseCachePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint DiscovererUseCachePropertyInfo = (~) Bool
type AttrBaseTypeConstraint DiscovererUseCachePropertyInfo = IsDiscoverer
type AttrGetType DiscovererUseCachePropertyInfo = Bool
type AttrLabel DiscovererUseCachePropertyInfo = "use-cache"
type AttrOrigin DiscovererUseCachePropertyInfo = Discoverer
attrGet _ = getDiscovererUseCache
attrSet _ = setDiscovererUseCache
attrConstruct _ = constructDiscovererUseCache
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Discoverer
type instance O.AttributeList Discoverer = DiscovererAttributeList
type DiscovererAttributeList = ('[ '("timeout", DiscovererTimeoutPropertyInfo), '("useCache", DiscovererUseCachePropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
discovererTimeout :: AttrLabelProxy "timeout"
discovererTimeout = AttrLabelProxy
discovererUseCache :: AttrLabelProxy "useCache"
discovererUseCache = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
data DiscovererDiscoveredSignalInfo
instance SignalInfo DiscovererDiscoveredSignalInfo where
type HaskellCallbackType DiscovererDiscoveredSignalInfo = DiscovererDiscoveredCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_DiscovererDiscoveredCallback cb
cb'' <- mk_DiscovererDiscoveredCallback cb'
connectSignalFunPtr obj "discovered" cb'' connectMode
data DiscovererFinishedSignalInfo
instance SignalInfo DiscovererFinishedSignalInfo where
type HaskellCallbackType DiscovererFinishedSignalInfo = DiscovererFinishedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_DiscovererFinishedCallback cb
cb'' <- mk_DiscovererFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' connectMode
data DiscovererSourceSetupSignalInfo
instance SignalInfo DiscovererSourceSetupSignalInfo where
type HaskellCallbackType DiscovererSourceSetupSignalInfo = DiscovererSourceSetupCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_DiscovererSourceSetupCallback cb
cb'' <- mk_DiscovererSourceSetupCallback cb'
connectSignalFunPtr obj "source-setup" cb'' connectMode
data DiscovererStartingSignalInfo
instance SignalInfo DiscovererStartingSignalInfo where
type HaskellCallbackType DiscovererStartingSignalInfo = DiscovererStartingCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_DiscovererStartingCallback cb
cb'' <- mk_DiscovererStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' connectMode
type instance O.SignalList Discoverer = DiscovererSignalList
type DiscovererSignalList = ('[ '("discovered", DiscovererDiscoveredSignalInfo), '("finished", DiscovererFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sourceSetup", DiscovererSourceSetupSignalInfo), '("starting", DiscovererStartingSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_discoverer_new" gst_discoverer_new ::
Word64 ->
Ptr (Ptr GError) ->
IO (Ptr Discoverer)
discovererNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word64
-> m Discoverer
discovererNew timeout = liftIO $ do
onException (do
result <- propagateGError $ gst_discoverer_new timeout
checkUnexpectedReturnNULL "discovererNew" result
result' <- (wrapObject Discoverer) result
return result'
) (do
return ()
)
#if ENABLE_OVERLOADING
#endif
foreign import ccall "gst_discoverer_discover_uri" gst_discoverer_discover_uri ::
Ptr Discoverer ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GstPbutils.DiscovererInfo.DiscovererInfo)
discovererDiscoverUri ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> T.Text
-> m GstPbutils.DiscovererInfo.DiscovererInfo
discovererDiscoverUri discoverer uri = liftIO $ do
discoverer' <- unsafeManagedPtrCastPtr discoverer
uri' <- textToCString uri
onException (do
result <- propagateGError $ gst_discoverer_discover_uri discoverer' uri'
checkUnexpectedReturnNULL "discovererDiscoverUri" result
result' <- (wrapObject GstPbutils.DiscovererInfo.DiscovererInfo) result
touchManagedPtr discoverer
freeMem uri'
return result'
) (do
freeMem uri'
)
#if ENABLE_OVERLOADING
data DiscovererDiscoverUriMethodInfo
instance (signature ~ (T.Text -> m GstPbutils.DiscovererInfo.DiscovererInfo), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererDiscoverUriMethodInfo a signature where
overloadedMethod _ = discovererDiscoverUri
#endif
foreign import ccall "gst_discoverer_discover_uri_async" gst_discoverer_discover_uri_async ::
Ptr Discoverer ->
CString ->
IO CInt
discovererDiscoverUriAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> T.Text
-> m Bool
discovererDiscoverUriAsync discoverer uri = liftIO $ do
discoverer' <- unsafeManagedPtrCastPtr discoverer
uri' <- textToCString uri
result <- gst_discoverer_discover_uri_async discoverer' uri'
let result' = (/= 0) result
touchManagedPtr discoverer
freeMem uri'
return result'
#if ENABLE_OVERLOADING
data DiscovererDiscoverUriAsyncMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererDiscoverUriAsyncMethodInfo a signature where
overloadedMethod _ = discovererDiscoverUriAsync
#endif
foreign import ccall "gst_discoverer_start" gst_discoverer_start ::
Ptr Discoverer ->
IO ()
discovererStart ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> m ()
discovererStart discoverer = liftIO $ do
discoverer' <- unsafeManagedPtrCastPtr discoverer
gst_discoverer_start discoverer'
touchManagedPtr discoverer
return ()
#if ENABLE_OVERLOADING
data DiscovererStartMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererStartMethodInfo a signature where
overloadedMethod _ = discovererStart
#endif
foreign import ccall "gst_discoverer_stop" gst_discoverer_stop ::
Ptr Discoverer ->
IO ()
discovererStop ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> m ()
discovererStop discoverer = liftIO $ do
discoverer' <- unsafeManagedPtrCastPtr discoverer
gst_discoverer_stop discoverer'
touchManagedPtr discoverer
return ()
#if ENABLE_OVERLOADING
data DiscovererStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererStopMethodInfo a signature where
overloadedMethod _ = discovererStop
#endif