{-# 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 ,
#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.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.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.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 GHC.Records as R
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 (SP.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)
instance SP.ManagedPtrNewtype DeviceProviderFactory where
toManagedPtr :: DeviceProviderFactory -> ManagedPtr DeviceProviderFactory
toManagedPtr (DeviceProviderFactory ManagedPtr DeviceProviderFactory
p) = ManagedPtr DeviceProviderFactory
p
foreign import ccall "gst_device_provider_factory_get_type"
c_gst_device_provider_factory_get_type :: IO B.Types.GType
instance B.Types.TypedObject DeviceProviderFactory where
glibType :: IO GType
glibType = IO GType
c_gst_device_provider_factory_get_type
instance B.Types.GObject DeviceProviderFactory
class (SP.GObject o, O.IsDescendantOf DeviceProviderFactory o) => IsDeviceProviderFactory o
instance (SP.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 :: (MIO.MonadIO m, IsDeviceProviderFactory o) => o -> m DeviceProviderFactory
toDeviceProviderFactory :: forall (m :: * -> *) o.
(MonadIO m, IsDeviceProviderFactory o) =>
o -> m DeviceProviderFactory
toDeviceProviderFactory = IO DeviceProviderFactory -> m DeviceProviderFactory
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DeviceProviderFactory -> DeviceProviderFactory
DeviceProviderFactory
instance B.GValue.IsGValue (Maybe DeviceProviderFactory) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_device_provider_factory_get_type
gvalueSet_ :: Ptr GValue -> Maybe DeviceProviderFactory -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DeviceProviderFactory
P.Nothing = Ptr GValue -> Ptr DeviceProviderFactory -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DeviceProviderFactory
forall a. Ptr a
FP.nullPtr :: FP.Ptr DeviceProviderFactory)
gvalueSet_ Ptr GValue
gv (P.Just DeviceProviderFactory
obj) = DeviceProviderFactory
-> (Ptr DeviceProviderFactory -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DeviceProviderFactory
obj (Ptr GValue -> Ptr DeviceProviderFactory -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DeviceProviderFactory)
gvalueGet_ Ptr GValue
gv = do
Ptr DeviceProviderFactory
ptr <- Ptr GValue -> IO (Ptr DeviceProviderFactory)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DeviceProviderFactory)
if Ptr DeviceProviderFactory
ptr Ptr DeviceProviderFactory -> Ptr DeviceProviderFactory -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DeviceProviderFactory
forall a. Ptr a
FP.nullPtr
then DeviceProviderFactory -> Maybe DeviceProviderFactory
forall a. a -> Maybe a
P.Just (DeviceProviderFactory -> Maybe DeviceProviderFactory)
-> IO DeviceProviderFactory -> IO (Maybe DeviceProviderFactory)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
else Maybe DeviceProviderFactory -> IO (Maybe DeviceProviderFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProviderFactory
forall a. Maybe a
P.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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDeviceProviderFactoryMethod t DeviceProviderFactory, O.OverloadedMethod info DeviceProviderFactory p, R.HasField t DeviceProviderFactory p) => R.HasField t DeviceProviderFactory p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDeviceProviderFactoryMethod t DeviceProviderFactory, O.OverloadedMethodInfo info DeviceProviderFactory) => OL.IsLabel t (O.MethodProxy info DeviceProviderFactory) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a -> m (Maybe DeviceProvider)
deviceProviderFactoryGet 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
$ \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.OverloadedMethod DeviceProviderFactoryGetMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGet
instance O.OverloadedMethodInfo DeviceProviderFactoryGetMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryGet",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-DeviceProviderFactory.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a -> m GType
deviceProviderFactoryGetDeviceProviderType 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.OverloadedMethod DeviceProviderFactoryGetDeviceProviderTypeMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGetDeviceProviderType
instance O.OverloadedMethodInfo DeviceProviderFactoryGetDeviceProviderTypeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryGetDeviceProviderType",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-DeviceProviderFactory.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a -> Text -> m (Maybe Text)
deviceProviderFactoryGetMetadata a
factory 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
$ \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.OverloadedMethod DeviceProviderFactoryGetMetadataMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGetMetadata
instance O.OverloadedMethodInfo DeviceProviderFactoryGetMetadataMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryGetMetadata",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-DeviceProviderFactory.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a -> m (Maybe [Text])
deviceProviderFactoryGetMetadataKeys 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
$ \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.OverloadedMethod DeviceProviderFactoryGetMetadataKeysMethodInfo a signature where
overloadedMethod = deviceProviderFactoryGetMetadataKeys
instance O.OverloadedMethodInfo DeviceProviderFactoryGetMetadataKeysMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryGetMetadataKeys",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-DeviceProviderFactory.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a -> Maybe Text -> m Bool
deviceProviderFactoryHasClasses a
factory 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
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just 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
/= CInt
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.OverloadedMethod DeviceProviderFactoryHasClassesMethodInfo a signature where
overloadedMethod = deviceProviderFactoryHasClasses
instance O.OverloadedMethodInfo DeviceProviderFactoryHasClassesMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryHasClasses",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-DeviceProviderFactory.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
a -> Maybe [Text] -> m Bool
deviceProviderFactoryHasClassesv a
factory 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
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [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
/= CInt
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.OverloadedMethod DeviceProviderFactoryHasClassesvMethodInfo a signature where
overloadedMethod = deviceProviderFactoryHasClassesv
instance O.OverloadedMethodInfo DeviceProviderFactoryHasClassesvMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryHasClassesv",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-DeviceProviderFactory.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe DeviceProviderFactory)
deviceProviderFactoryFind 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
$ \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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe DeviceProvider)
deviceProviderFactoryGetByName 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
$ \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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Rank -> m [DeviceProviderFactory]
deviceProviderFactoryListGetDeviceProviders 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