{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.DeviceProviderFactory
(
DeviceProviderFactory(..) ,
IsDeviceProviderFactory ,
toDeviceProviderFactory ,
noDeviceProviderFactory ,
#if defined(ENABLE_OVERLOADING)
ResolveDeviceProviderFactoryMethod ,
#endif
deviceProviderFactoryFind ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderFactoryGetMethodInfo ,
#endif
deviceProviderFactoryGet ,
deviceProviderFactoryGetByName ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderFactoryGetDeviceProviderTypeMethodInfo,
#endif
deviceProviderFactoryGetDeviceProviderType,
#if defined(ENABLE_OVERLOADING)
DeviceProviderFactoryGetMetadataMethodInfo,
#endif
deviceProviderFactoryGetMetadata ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderFactoryGetMetadataKeysMethodInfo,
#endif
deviceProviderFactoryGetMetadataKeys ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderFactoryHasClassesMethodInfo,
#endif
deviceProviderFactoryHasClasses ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderFactoryHasClassesvMethodInfo,
#endif
deviceProviderFactoryHasClassesv ,
deviceProviderFactoryListGetDeviceProviders,
) 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
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Objects.DeviceProvider as Gst.DeviceProvider
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.PluginFeature as Gst.PluginFeature
newtype DeviceProviderFactory = DeviceProviderFactory (ManagedPtr DeviceProviderFactory)
deriving (DeviceProviderFactory -> DeviceProviderFactory -> Bool
(DeviceProviderFactory -> DeviceProviderFactory -> Bool)
-> (DeviceProviderFactory -> DeviceProviderFactory -> Bool)
-> Eq DeviceProviderFactory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceProviderFactory -> DeviceProviderFactory -> Bool
$c/= :: DeviceProviderFactory -> DeviceProviderFactory -> Bool
== :: DeviceProviderFactory -> DeviceProviderFactory -> Bool
$c== :: DeviceProviderFactory -> DeviceProviderFactory -> Bool
Eq)
foreign import ccall "gst_device_provider_factory_get_type"
c_gst_device_provider_factory_get_type :: IO GType
instance GObject DeviceProviderFactory where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_device_provider_factory_get_type
instance B.GValue.IsGValue DeviceProviderFactory where
toGValue :: DeviceProviderFactory -> IO GValue
toGValue o :: DeviceProviderFactory
o = do
GType
gtype <- IO GType
c_gst_device_provider_factory_get_type
DeviceProviderFactory
-> (Ptr DeviceProviderFactory -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DeviceProviderFactory
o (GType
-> (GValue -> Ptr DeviceProviderFactory -> IO ())
-> Ptr DeviceProviderFactory
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr DeviceProviderFactory -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO DeviceProviderFactory
fromGValue gv :: GValue
gv = do
Ptr DeviceProviderFactory
ptr <- GValue -> IO (Ptr DeviceProviderFactory)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr DeviceProviderFactory)
(ManagedPtr DeviceProviderFactory -> DeviceProviderFactory)
-> Ptr DeviceProviderFactory -> IO DeviceProviderFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DeviceProviderFactory -> DeviceProviderFactory
DeviceProviderFactory Ptr DeviceProviderFactory
ptr
class (GObject o, O.IsDescendantOf DeviceProviderFactory o) => IsDeviceProviderFactory o
instance (GObject o, O.IsDescendantOf DeviceProviderFactory o) => IsDeviceProviderFactory o
instance O.HasParentTypes DeviceProviderFactory
type instance O.ParentTypes DeviceProviderFactory = '[Gst.PluginFeature.PluginFeature, Gst.Object.Object, GObject.Object.Object]
toDeviceProviderFactory :: (MonadIO m, IsDeviceProviderFactory o) => o -> m DeviceProviderFactory
toDeviceProviderFactory :: o -> m DeviceProviderFactory
toDeviceProviderFactory = IO DeviceProviderFactory -> m DeviceProviderFactory
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DeviceProviderFactory -> m DeviceProviderFactory)
-> (o -> IO DeviceProviderFactory) -> o -> m DeviceProviderFactory
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DeviceProviderFactory -> DeviceProviderFactory)
-> o -> IO DeviceProviderFactory
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr DeviceProviderFactory -> DeviceProviderFactory
DeviceProviderFactory
noDeviceProviderFactory :: Maybe DeviceProviderFactory
noDeviceProviderFactory :: Maybe DeviceProviderFactory
noDeviceProviderFactory = Maybe DeviceProviderFactory
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDeviceProviderFactoryMethod (t :: Symbol) (o :: *) :: * where
ResolveDeviceProviderFactoryMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveDeviceProviderFactoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDeviceProviderFactoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDeviceProviderFactoryMethod "checkVersion" o = Gst.PluginFeature.PluginFeatureCheckVersionMethodInfo
ResolveDeviceProviderFactoryMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveDeviceProviderFactoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDeviceProviderFactoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDeviceProviderFactoryMethod "get" o = DeviceProviderFactoryGetMethodInfo
ResolveDeviceProviderFactoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDeviceProviderFactoryMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveDeviceProviderFactoryMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveDeviceProviderFactoryMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveDeviceProviderFactoryMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveDeviceProviderFactoryMethod "hasClasses" o = DeviceProviderFactoryHasClassesMethodInfo
ResolveDeviceProviderFactoryMethod "hasClassesv" o = DeviceProviderFactoryHasClassesvMethodInfo
ResolveDeviceProviderFactoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDeviceProviderFactoryMethod "load" o = Gst.PluginFeature.PluginFeatureLoadMethodInfo
ResolveDeviceProviderFactoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDeviceProviderFactoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDeviceProviderFactoryMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveDeviceProviderFactoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDeviceProviderFactoryMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveDeviceProviderFactoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDeviceProviderFactoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDeviceProviderFactoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDeviceProviderFactoryMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveDeviceProviderFactoryMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveDeviceProviderFactoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDeviceProviderFactoryMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveDeviceProviderFactoryMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveDeviceProviderFactoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDeviceProviderFactoryMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveDeviceProviderFactoryMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveDeviceProviderFactoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDeviceProviderFactoryMethod "getDeviceProviderType" o = DeviceProviderFactoryGetDeviceProviderTypeMethodInfo
ResolveDeviceProviderFactoryMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveDeviceProviderFactoryMethod "getMetadata" o = DeviceProviderFactoryGetMetadataMethodInfo
ResolveDeviceProviderFactoryMethod "getMetadataKeys" o = DeviceProviderFactoryGetMetadataKeysMethodInfo
ResolveDeviceProviderFactoryMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveDeviceProviderFactoryMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveDeviceProviderFactoryMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveDeviceProviderFactoryMethod "getPlugin" o = Gst.PluginFeature.PluginFeatureGetPluginMethodInfo
ResolveDeviceProviderFactoryMethod "getPluginName" o = Gst.PluginFeature.PluginFeatureGetPluginNameMethodInfo
ResolveDeviceProviderFactoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDeviceProviderFactoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDeviceProviderFactoryMethod "getRank" o = Gst.PluginFeature.PluginFeatureGetRankMethodInfo
ResolveDeviceProviderFactoryMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveDeviceProviderFactoryMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveDeviceProviderFactoryMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveDeviceProviderFactoryMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveDeviceProviderFactoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDeviceProviderFactoryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDeviceProviderFactoryMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveDeviceProviderFactoryMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveDeviceProviderFactoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDeviceProviderFactoryMethod "setRank" o = Gst.PluginFeature.PluginFeatureSetRankMethodInfo
ResolveDeviceProviderFactoryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDeviceProviderFactoryMethod t DeviceProviderFactory, O.MethodInfo info DeviceProviderFactory p) => OL.IsLabel t (DeviceProviderFactory -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DeviceProviderFactory
type instance O.AttributeList DeviceProviderFactory = DeviceProviderFactoryAttributeList
type DeviceProviderFactoryAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DeviceProviderFactory = DeviceProviderFactorySignalList
type DeviceProviderFactorySignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_device_provider_factory_get" gst_device_provider_factory_get ::
Ptr DeviceProviderFactory ->
IO (Ptr Gst.DeviceProvider.DeviceProvider)
deviceProviderFactoryGet ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a
-> m (Maybe Gst.DeviceProvider.DeviceProvider)
deviceProviderFactoryGet :: a -> m (Maybe DeviceProvider)
deviceProviderFactoryGet factory :: a
factory = IO (Maybe DeviceProvider) -> m (Maybe DeviceProvider)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DeviceProvider) -> m (Maybe DeviceProvider))
-> IO (Maybe DeviceProvider) -> m (Maybe DeviceProvider)
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProviderFactory
factory' <- a -> IO (Ptr DeviceProviderFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
Ptr DeviceProvider
result <- Ptr DeviceProviderFactory -> IO (Ptr DeviceProvider)
gst_device_provider_factory_get Ptr DeviceProviderFactory
factory'
Maybe DeviceProvider
maybeResult <- Ptr DeviceProvider
-> (Ptr DeviceProvider -> IO DeviceProvider)
-> IO (Maybe DeviceProvider)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DeviceProvider
result ((Ptr DeviceProvider -> IO DeviceProvider)
-> IO (Maybe DeviceProvider))
-> (Ptr DeviceProvider -> IO DeviceProvider)
-> IO (Maybe DeviceProvider)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr DeviceProvider
result' -> do
DeviceProvider
result'' <- ((ManagedPtr DeviceProvider -> DeviceProvider)
-> Ptr DeviceProvider -> IO DeviceProvider
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DeviceProvider -> DeviceProvider
Gst.DeviceProvider.DeviceProvider) Ptr DeviceProvider
result'
DeviceProvider -> IO DeviceProvider
forall (m :: * -> *) a. Monad m => a -> m a
return DeviceProvider
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
factory
Maybe DeviceProvider -> IO (Maybe DeviceProvider)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProvider
maybeResult
#if defined(ENABLE_OVERLOADING)
data DeviceProviderFactoryGetMethodInfo
instance (signature ~ (m (Maybe Gst.DeviceProvider.DeviceProvider)), MonadIO m, IsDeviceProviderFactory a) => O.MethodInfo DeviceProviderFactoryGetMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGet
#endif
foreign import ccall "gst_device_provider_factory_get_device_provider_type" gst_device_provider_factory_get_device_provider_type ::
Ptr DeviceProviderFactory ->
IO CGType
deviceProviderFactoryGetDeviceProviderType ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a
-> m GType
deviceProviderFactoryGetDeviceProviderType :: a -> m GType
deviceProviderFactoryGetDeviceProviderType factory :: a
factory = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProviderFactory
factory' <- a -> IO (Ptr DeviceProviderFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
CGType
result <- Ptr DeviceProviderFactory -> IO CGType
gst_device_provider_factory_get_device_provider_type Ptr DeviceProviderFactory
factory'
let result' :: GType
result' = CGType -> GType
GType CGType
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
factory
GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderFactoryGetDeviceProviderTypeMethodInfo
instance (signature ~ (m GType), MonadIO m, IsDeviceProviderFactory a) => O.MethodInfo DeviceProviderFactoryGetDeviceProviderTypeMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGetDeviceProviderType
#endif
foreign import ccall "gst_device_provider_factory_get_metadata" gst_device_provider_factory_get_metadata ::
Ptr DeviceProviderFactory ->
CString ->
IO CString
deviceProviderFactoryGetMetadata ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a
-> T.Text
-> m (Maybe T.Text)
deviceProviderFactoryGetMetadata :: a -> Text -> m (Maybe Text)
deviceProviderFactoryGetMetadata factory :: a
factory key :: Text
key = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProviderFactory
factory' <- a -> IO (Ptr DeviceProviderFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
CString
key' <- Text -> IO CString
textToCString Text
key
CString
result <- Ptr DeviceProviderFactory -> CString -> IO CString
gst_device_provider_factory_get_metadata Ptr DeviceProviderFactory
factory' CString
key'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
factory
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data DeviceProviderFactoryGetMetadataMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsDeviceProviderFactory a) => O.MethodInfo DeviceProviderFactoryGetMetadataMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGetMetadata
#endif
foreign import ccall "gst_device_provider_factory_get_metadata_keys" gst_device_provider_factory_get_metadata_keys ::
Ptr DeviceProviderFactory ->
IO (Ptr CString)
deviceProviderFactoryGetMetadataKeys ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a
-> m (Maybe [T.Text])
deviceProviderFactoryGetMetadataKeys :: a -> m (Maybe [Text])
deviceProviderFactoryGetMetadataKeys factory :: a
factory = IO (Maybe [Text]) -> m (Maybe [Text])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [Text]) -> m (Maybe [Text]))
-> IO (Maybe [Text]) -> m (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProviderFactory
factory' <- a -> IO (Ptr DeviceProviderFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
Ptr CString
result <- Ptr DeviceProviderFactory -> IO (Ptr CString)
gst_device_provider_factory_get_metadata_keys Ptr DeviceProviderFactory
factory'
Maybe [Text]
maybeResult <- Ptr CString -> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CString
result ((Ptr CString -> IO [Text]) -> IO (Maybe [Text]))
-> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr CString
result' -> do
[Text]
result'' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result'
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result'
[Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
factory
Maybe [Text] -> IO (Maybe [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult
#if defined(ENABLE_OVERLOADING)
data DeviceProviderFactoryGetMetadataKeysMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsDeviceProviderFactory a) => O.MethodInfo DeviceProviderFactoryGetMetadataKeysMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGetMetadataKeys
#endif
foreign import ccall "gst_device_provider_factory_has_classes" gst_device_provider_factory_has_classes ::
Ptr DeviceProviderFactory ->
CString ->
IO CInt
deviceProviderFactoryHasClasses ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a
-> Maybe (T.Text)
-> m Bool
deviceProviderFactoryHasClasses :: a -> Maybe Text -> m Bool
deviceProviderFactoryHasClasses factory :: a
factory classes :: Maybe Text
classes = 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 DeviceProviderFactory
factory' <- a -> IO (Ptr DeviceProviderFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
CString
maybeClasses <- case Maybe Text
classes of
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just jClasses :: Text
jClasses -> do
CString
jClasses' <- Text -> IO CString
textToCString Text
jClasses
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jClasses'
CInt
result <- Ptr DeviceProviderFactory -> CString -> IO CInt
gst_device_provider_factory_has_classes Ptr DeviceProviderFactory
factory' CString
maybeClasses
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
factory
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeClasses
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderFactoryHasClassesMethodInfo
instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m, IsDeviceProviderFactory a) => O.MethodInfo DeviceProviderFactoryHasClassesMethodInfo a signature where
overloadedMethod = deviceProviderFactoryHasClasses
#endif
foreign import ccall "gst_device_provider_factory_has_classesv" gst_device_provider_factory_has_classesv ::
Ptr DeviceProviderFactory ->
Ptr CString ->
IO CInt
deviceProviderFactoryHasClassesv ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a
-> Maybe ([T.Text])
-> m Bool
deviceProviderFactoryHasClassesv :: a -> Maybe [Text] -> m Bool
deviceProviderFactoryHasClassesv factory :: a
factory classes :: Maybe [Text]
classes = 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 DeviceProviderFactory
factory' <- a -> IO (Ptr DeviceProviderFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
Ptr CString
maybeClasses <- case Maybe [Text]
classes of
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just jClasses :: [Text]
jClasses -> do
Ptr CString
jClasses' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jClasses
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jClasses'
CInt
result <- Ptr DeviceProviderFactory -> Ptr CString -> IO CInt
gst_device_provider_factory_has_classesv Ptr DeviceProviderFactory
factory' Ptr CString
maybeClasses
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
factory
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeClasses
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeClasses
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderFactoryHasClassesvMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> m Bool), MonadIO m, IsDeviceProviderFactory a) => O.MethodInfo DeviceProviderFactoryHasClassesvMethodInfo a signature where
overloadedMethod = deviceProviderFactoryHasClassesv
#endif
foreign import ccall "gst_device_provider_factory_find" gst_device_provider_factory_find ::
CString ->
IO (Ptr DeviceProviderFactory)
deviceProviderFactoryFind ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe DeviceProviderFactory)
deviceProviderFactoryFind :: Text -> m (Maybe DeviceProviderFactory)
deviceProviderFactoryFind name :: Text
name = IO (Maybe DeviceProviderFactory) -> m (Maybe DeviceProviderFactory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DeviceProviderFactory)
-> m (Maybe DeviceProviderFactory))
-> IO (Maybe DeviceProviderFactory)
-> m (Maybe DeviceProviderFactory)
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr DeviceProviderFactory
result <- CString -> IO (Ptr DeviceProviderFactory)
gst_device_provider_factory_find CString
name'
Maybe DeviceProviderFactory
maybeResult <- Ptr DeviceProviderFactory
-> (Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DeviceProviderFactory
result ((Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory))
-> (Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr DeviceProviderFactory
result' -> do
DeviceProviderFactory
result'' <- ((ManagedPtr DeviceProviderFactory -> DeviceProviderFactory)
-> Ptr DeviceProviderFactory -> IO DeviceProviderFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DeviceProviderFactory -> DeviceProviderFactory
DeviceProviderFactory) Ptr DeviceProviderFactory
result'
DeviceProviderFactory -> IO DeviceProviderFactory
forall (m :: * -> *) a. Monad m => a -> m a
return DeviceProviderFactory
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe DeviceProviderFactory -> IO (Maybe DeviceProviderFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProviderFactory
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_device_provider_factory_get_by_name" gst_device_provider_factory_get_by_name ::
CString ->
IO (Ptr Gst.DeviceProvider.DeviceProvider)
deviceProviderFactoryGetByName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe Gst.DeviceProvider.DeviceProvider)
deviceProviderFactoryGetByName :: Text -> m (Maybe DeviceProvider)
deviceProviderFactoryGetByName factoryname :: Text
factoryname = IO (Maybe DeviceProvider) -> m (Maybe DeviceProvider)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DeviceProvider) -> m (Maybe DeviceProvider))
-> IO (Maybe DeviceProvider) -> m (Maybe DeviceProvider)
forall a b. (a -> b) -> a -> b
$ do
CString
factoryname' <- Text -> IO CString
textToCString Text
factoryname
Ptr DeviceProvider
result <- CString -> IO (Ptr DeviceProvider)
gst_device_provider_factory_get_by_name CString
factoryname'
Maybe DeviceProvider
maybeResult <- Ptr DeviceProvider
-> (Ptr DeviceProvider -> IO DeviceProvider)
-> IO (Maybe DeviceProvider)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DeviceProvider
result ((Ptr DeviceProvider -> IO DeviceProvider)
-> IO (Maybe DeviceProvider))
-> (Ptr DeviceProvider -> IO DeviceProvider)
-> IO (Maybe DeviceProvider)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr DeviceProvider
result' -> do
DeviceProvider
result'' <- ((ManagedPtr DeviceProvider -> DeviceProvider)
-> Ptr DeviceProvider -> IO DeviceProvider
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DeviceProvider -> DeviceProvider
Gst.DeviceProvider.DeviceProvider) Ptr DeviceProvider
result'
DeviceProvider -> IO DeviceProvider
forall (m :: * -> *) a. Monad m => a -> m a
return DeviceProvider
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
factoryname'
Maybe DeviceProvider -> IO (Maybe DeviceProvider)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProvider
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_device_provider_factory_list_get_device_providers" gst_device_provider_factory_list_get_device_providers ::
CUInt ->
IO (Ptr (GList (Ptr DeviceProviderFactory)))
deviceProviderFactoryListGetDeviceProviders ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Rank
-> m [DeviceProviderFactory]
deviceProviderFactoryListGetDeviceProviders :: Rank -> m [DeviceProviderFactory]
deviceProviderFactoryListGetDeviceProviders minrank :: Rank
minrank = IO [DeviceProviderFactory] -> m [DeviceProviderFactory]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [DeviceProviderFactory] -> m [DeviceProviderFactory])
-> IO [DeviceProviderFactory] -> m [DeviceProviderFactory]
forall a b. (a -> b) -> a -> b
$ do
let minrank' :: CUInt
minrank' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Rank -> Int) -> Rank -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rank -> Int
forall a. Enum a => a -> Int
fromEnum) Rank
minrank
Ptr (GList (Ptr DeviceProviderFactory))
result <- CUInt -> IO (Ptr (GList (Ptr DeviceProviderFactory)))
gst_device_provider_factory_list_get_device_providers CUInt
minrank'
[Ptr DeviceProviderFactory]
result' <- Ptr (GList (Ptr DeviceProviderFactory))
-> IO [Ptr DeviceProviderFactory]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr DeviceProviderFactory))
result
[DeviceProviderFactory]
result'' <- (Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> [Ptr DeviceProviderFactory] -> IO [DeviceProviderFactory]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr DeviceProviderFactory -> DeviceProviderFactory)
-> Ptr DeviceProviderFactory -> IO DeviceProviderFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DeviceProviderFactory -> DeviceProviderFactory
DeviceProviderFactory) [Ptr DeviceProviderFactory]
result'
Ptr (GList (Ptr DeviceProviderFactory)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr DeviceProviderFactory))
result
[DeviceProviderFactory] -> IO [DeviceProviderFactory]
forall (m :: * -> *) a. Monad m => a -> m a
return [DeviceProviderFactory]
result''
#if defined(ENABLE_OVERLOADING)
#endif