GI.GstPbutils.Objects.Discoverer

The Discoverer is a utility object which allows to get as much information as possible from one or many URIs.

It provides two APIs, allowing usage in blocking or non-blocking mode.

The blocking mode just requires calling discovererDiscoverUri with the URI one wishes to discover.

The non-blocking mode requires a running MainLoop iterating a MainContext, where one connects to the various signals, appends the URIs to be processed (through discovererDiscoverUriAsync) and then asks for the discovery to begin (through discovererStart). By default this will use the GLib default main context unless you have set a custom context using mainContextPushThreadDefault.

All the information is returned in a DiscovererInfo structure.

Exported types

newtype Discoverer

Constructors

Discoverer (ManagedPtr Discoverer)

Instances

GObject Discoverer

Methods

gobjectType :: Discoverer -> IO GType

IsObject Discoverer

IsDiscoverer Discoverer

((~) * info (ResolveDiscovererMethod t Discoverer), MethodInfo * info Discoverer p) => IsLabel t (Discoverer -> p)

Methods

fromLabel :: Proxy# Symbol t -> Discoverer -> p

((~) * info (ResolveDiscovererMethod t Discoverer), MethodInfo * info Discoverer p) => IsLabelProxy t (Discoverer -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Discoverer -> p

HasAttributeList * Discoverer

type AttributeList Discoverer

type AttributeList Discoverer

type SignalList Discoverer

type SignalList Discoverer

class GObject o => IsDiscoverer o

Instances

(GObject a, UnknownAncestorError Constraint Discoverer a) => IsDiscoverer a

IsDiscoverer Discoverer

toDiscoverer :: IsDiscoverer o => o -> IO Discoverer

noDiscoverer :: Maybe Discoverer

Methods

discoverUri

data DiscovererDiscoverUriMethodInfo

Instances

((~) * signature (Text -> m DiscovererInfo), MonadIO m, IsDiscoverer a) => MethodInfo * DiscovererDiscoverUriMethodInfo a signature

Methods

overloadedMethod :: MethodProxy DiscovererDiscoverUriMethodInfo a -> signature -> s

discovererDiscoverUri

Arguments

:: (HasCallStack, MonadIO m, IsDiscoverer a)

=> a

discoverer: A Discoverer

-> Text

uri: The URI to run on.

-> m DiscovererInfo

Returns: the result of the scanning. Can be Nothing if an error occurred. (Can throw GError)

Synchronously discovers the given uri.

A copy of uri will be made internally, so the caller can safely free afterwards.

discoverUriAsync

data DiscovererDiscoverUriAsyncMethodInfo

Instances

((~) * signature (Text -> m Bool), MonadIO m, IsDiscoverer a) => MethodInfo * DiscovererDiscoverUriAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy DiscovererDiscoverUriAsyncMethodInfo a -> signature -> s

discovererDiscoverUriAsync

Arguments

:: (HasCallStack, MonadIO m, IsDiscoverer a)

=> a

discoverer: A Discoverer

-> Text

uri: the URI to add.

-> m Bool

Returns: True if the uri was successfully appended to the list of pending uris, else False

Appends the given uri to the list of URIs to discoverer. The actual discovery of the uri will only take place if discovererStart has been called.

A copy of uri will be made internally, so the caller can safely free afterwards.

new

discovererNew

Arguments

:: (HasCallStack, MonadIO m)

=> Word64

timeout: timeout per file, in nanoseconds. Allowed are values between one second (SECOND) and one hour (3600 * SECOND)

-> m Discoverer

Returns: The new Discoverer. If an error occurred when creating the discoverer, err will be set accordingly and Nothing will be returned. If err is set, the caller must free it when no longer needed using errorFree. (Can throw GError)

Creates a new Discoverer with the provided timeout.

start

data DiscovererStartMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsDiscoverer a) => MethodInfo * DiscovererStartMethodInfo a signature

Methods

overloadedMethod :: MethodProxy DiscovererStartMethodInfo a -> signature -> s

discovererStart

Arguments

:: (HasCallStack, MonadIO m, IsDiscoverer a)

=> a

discoverer: A Discoverer

-> m ()

Allow asynchronous discovering of URIs to take place. A MainLoop must be available for Discoverer to properly work in asynchronous mode.

stop

data DiscovererStopMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsDiscoverer a) => MethodInfo * DiscovererStopMethodInfo a signature

Methods

overloadedMethod :: MethodProxy DiscovererStopMethodInfo a -> signature -> s

discovererStop

Arguments

:: (HasCallStack, MonadIO m, IsDiscoverer a)

=> a

discoverer: A Discoverer

-> m ()

Stop the discovery of any pending URIs and clears the list of pending URIS (if any).

Properties

timeout

data DiscovererTimeoutPropertyInfo

Instances

AttrInfo DiscovererTimeoutPropertyInfo

Associated Types

type AttrAllowedOps DiscovererTimeoutPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint DiscovererTimeoutPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo :: * -> Constraint

type AttrGetType DiscovererTimeoutPropertyInfo :: *

type AttrLabel DiscovererTimeoutPropertyInfo :: Symbol

type AttrOrigin DiscovererTimeoutPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo o => Proxy * DiscovererTimeoutPropertyInfo -> o -> IO (AttrGetType DiscovererTimeoutPropertyInfo)

attrSet :: (AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo o, AttrSetTypeConstraint DiscovererTimeoutPropertyInfo b) => Proxy * DiscovererTimeoutPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo o => Proxy * DiscovererTimeoutPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo o, AttrSetTypeConstraint DiscovererTimeoutPropertyInfo b) => Proxy * DiscovererTimeoutPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin DiscovererTimeoutPropertyInfo

type AttrOrigin DiscovererTimeoutPropertyInfo = Discoverer

type AttrLabel DiscovererTimeoutPropertyInfo

type AttrLabel DiscovererTimeoutPropertyInfo = "timeout"

type AttrGetType DiscovererTimeoutPropertyInfo

type AttrGetType DiscovererTimeoutPropertyInfo = Word64

type AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo

type AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo = IsDiscoverer

type AttrSetTypeConstraint DiscovererTimeoutPropertyInfo

type AttrSetTypeConstraint DiscovererTimeoutPropertyInfo = * ~ Word64

type AttrAllowedOps DiscovererTimeoutPropertyInfo

type AttrAllowedOps DiscovererTimeoutPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructDiscovererTimeout :: IsDiscoverer o => Word64 -> IO (GValueConstruct o)

discovererTimeout :: AttrLabelProxy "timeout"

getDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> m Word64

setDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> Word64 -> m ()

Signals

discovered

type C_DiscovererDiscoveredCallback = Ptr () -> Ptr DiscovererInfo -> Ptr GError -> Ptr () -> IO ()

type DiscovererDiscoveredCallback = DiscovererInfo -> GError -> IO ()

data DiscovererDiscoveredSignalInfo

Instances

SignalInfo DiscovererDiscoveredSignalInfo

Associated Types

type HaskellCallbackType DiscovererDiscoveredSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o DiscovererDiscoveredSignalInfo -> o -> HaskellCallbackType DiscovererDiscoveredSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType DiscovererDiscoveredSignalInfo

type HaskellCallbackType DiscovererDiscoveredSignalInfo = DiscovererDiscoveredCallback

afterDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId

genClosure_DiscovererDiscovered :: DiscovererDiscoveredCallback -> IO Closure

mk_DiscovererDiscoveredCallback :: C_DiscovererDiscoveredCallback -> IO (FunPtr C_DiscovererDiscoveredCallback)

noDiscovererDiscoveredCallback :: Maybe DiscovererDiscoveredCallback

onDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId

wrap_DiscovererDiscoveredCallback :: DiscovererDiscoveredCallback -> Ptr () -> Ptr DiscovererInfo -> Ptr GError -> Ptr () -> IO ()

finished

type C_DiscovererFinishedCallback = Ptr () -> Ptr () -> IO ()

type DiscovererFinishedCallback = IO ()

data DiscovererFinishedSignalInfo

Instances

SignalInfo DiscovererFinishedSignalInfo

Associated Types

type HaskellCallbackType DiscovererFinishedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o DiscovererFinishedSignalInfo -> o -> HaskellCallbackType DiscovererFinishedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType DiscovererFinishedSignalInfo

type HaskellCallbackType DiscovererFinishedSignalInfo = DiscovererFinishedCallback

afterDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId

genClosure_DiscovererFinished :: DiscovererFinishedCallback -> IO Closure

mk_DiscovererFinishedCallback :: C_DiscovererFinishedCallback -> IO (FunPtr C_DiscovererFinishedCallback)

noDiscovererFinishedCallback :: Maybe DiscovererFinishedCallback

onDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId

wrap_DiscovererFinishedCallback :: DiscovererFinishedCallback -> Ptr () -> Ptr () -> IO ()

sourceSetup

type C_DiscovererSourceSetupCallback = Ptr () -> Ptr Element -> Ptr () -> IO ()

type DiscovererSourceSetupCallback = Element -> IO ()

data DiscovererSourceSetupSignalInfo

Instances

SignalInfo DiscovererSourceSetupSignalInfo

Associated Types

type HaskellCallbackType DiscovererSourceSetupSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o DiscovererSourceSetupSignalInfo -> o -> HaskellCallbackType DiscovererSourceSetupSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType DiscovererSourceSetupSignalInfo

type HaskellCallbackType DiscovererSourceSetupSignalInfo = DiscovererSourceSetupCallback

afterDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId

genClosure_DiscovererSourceSetup :: DiscovererSourceSetupCallback -> IO Closure

mk_DiscovererSourceSetupCallback :: C_DiscovererSourceSetupCallback -> IO (FunPtr C_DiscovererSourceSetupCallback)

noDiscovererSourceSetupCallback :: Maybe DiscovererSourceSetupCallback

onDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId

wrap_DiscovererSourceSetupCallback :: DiscovererSourceSetupCallback -> Ptr () -> Ptr Element -> Ptr () -> IO ()

starting

type C_DiscovererStartingCallback = Ptr () -> Ptr () -> IO ()

type DiscovererStartingCallback = IO ()

data DiscovererStartingSignalInfo

Instances

SignalInfo DiscovererStartingSignalInfo

Associated Types

type HaskellCallbackType DiscovererStartingSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o DiscovererStartingSignalInfo -> o -> HaskellCallbackType DiscovererStartingSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType DiscovererStartingSignalInfo

type HaskellCallbackType DiscovererStartingSignalInfo = DiscovererStartingCallback

afterDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId

genClosure_DiscovererStarting :: DiscovererStartingCallback -> IO Closure

mk_DiscovererStartingCallback :: C_DiscovererStartingCallback -> IO (FunPtr C_DiscovererStartingCallback)

noDiscovererStartingCallback :: Maybe DiscovererStartingCallback

onDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId

wrap_DiscovererStartingCallback :: DiscovererStartingCallback -> Ptr () -> Ptr () -> IO ()