{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' is used to create instances of device providers. A
-- GstDeviceProviderfactory can be added to a t'GI.Gst.Objects.Plugin.Plugin' as it is also a
-- t'GI.Gst.Objects.PluginFeature.PluginFeature'.
-- 
-- Use the 'GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryFind' and
-- 'GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryGet' functions to create device
-- provider instances or use 'GI.Gst.Objects.DeviceProviderFactory.deviceProviderFactoryGetByName' as a
-- convenient shortcut.
-- 
-- /Since: 1.4/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gst.Objects.DeviceProviderFactory
    ( 

-- * Exported types
    DeviceProviderFactory(..)               ,
    IsDeviceProviderFactory                 ,
    toDeviceProviderFactory                 ,
    noDeviceProviderFactory                 ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveDeviceProviderFactoryMethod      ,
#endif


-- ** find #method:find#

    deviceProviderFactoryFind               ,


-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderFactoryGetMethodInfo      ,
#endif
    deviceProviderFactoryGet                ,


-- ** getByName #method:getByName#

    deviceProviderFactoryGetByName          ,


-- ** getDeviceProviderType #method:getDeviceProviderType#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderFactoryGetDeviceProviderTypeMethodInfo,
#endif
    deviceProviderFactoryGetDeviceProviderType,


-- ** getMetadata #method:getMetadata#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderFactoryGetMetadataMethodInfo,
#endif
    deviceProviderFactoryGetMetadata        ,


-- ** getMetadataKeys #method:getMetadataKeys#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderFactoryGetMetadataKeysMethodInfo,
#endif
    deviceProviderFactoryGetMetadataKeys    ,


-- ** hasClasses #method:hasClasses#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderFactoryHasClassesMethodInfo,
#endif
    deviceProviderFactoryHasClasses         ,


-- ** hasClassesv #method:hasClassesv#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderFactoryHasClassesvMethodInfo,
#endif
    deviceProviderFactoryHasClassesv        ,


-- ** listGetDeviceProviders #method:listGetDeviceProviders#

    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

-- | Memory-managed wrapper type.
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
    

-- | Convert 'DeviceProviderFactory' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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
        
    

-- | Type class for types which can be safely cast to `DeviceProviderFactory`, for instance with `toDeviceProviderFactory`.
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]

-- | Cast to `DeviceProviderFactory`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- | A convenience alias for `Nothing` :: `Maybe` `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

-- method DeviceProviderFactory::get
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "factory"
--           , argType =
--               TInterface
--                 Name { namespace = "Gst" , name = "DeviceProviderFactory" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "factory to instantiate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gst" , name = "DeviceProvider" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_get" gst_device_provider_factory_get :: 
    Ptr DeviceProviderFactory ->            -- factory : TInterface (Name {namespace = "Gst", name = "DeviceProviderFactory"})
    IO (Ptr Gst.DeviceProvider.DeviceProvider)

-- | Returns the device provider of the type defined by the given device
-- providerfactory.
-- 
-- /Since: 1.4/
deviceProviderFactoryGet ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
    a
    -- ^ /@factory@/: factory to instantiate
    -> m (Maybe Gst.DeviceProvider.DeviceProvider)
    -- ^ __Returns:__ the t'GI.Gst.Objects.DeviceProvider.DeviceProvider' or 'P.Nothing'
    -- if the device provider couldn\'t be created
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

-- method DeviceProviderFactory::get_device_provider_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "factory"
--           , argType =
--               TInterface
--                 Name { namespace = "Gst" , name = "DeviceProviderFactory" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "factory to get managed #GType from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_get_device_provider_type" gst_device_provider_factory_get_device_provider_type :: 
    Ptr DeviceProviderFactory ->            -- factory : TInterface (Name {namespace = "Gst", name = "DeviceProviderFactory"})
    IO CGType

-- | Get the t'GType' for device providers managed by this factory. The type can
-- only be retrieved if the device provider factory is loaded, which can be
-- assured with 'GI.Gst.Objects.PluginFeature.pluginFeatureLoad'.
-- 
-- /Since: 1.4/
deviceProviderFactoryGetDeviceProviderType ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
    a
    -- ^ /@factory@/: factory to get managed t'GType' from
    -> m GType
    -- ^ __Returns:__ the t'GType' for device providers managed by this factory.
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

-- method DeviceProviderFactory::get_metadata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "factory"
--           , argType =
--               TInterface
--                 Name { namespace = "Gst" , name = "DeviceProviderFactory" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProviderFactory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_get_metadata" gst_device_provider_factory_get_metadata :: 
    Ptr DeviceProviderFactory ->            -- factory : TInterface (Name {namespace = "Gst", name = "DeviceProviderFactory"})
    CString ->                              -- key : TBasicType TUTF8
    IO CString

-- | Get the metadata on /@factory@/ with /@key@/.
-- 
-- /Since: 1.4/
deviceProviderFactoryGetMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
    a
    -- ^ /@factory@/: a t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory'
    -> T.Text
    -- ^ /@key@/: a key
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the metadata with /@key@/ on /@factory@/ or 'P.Nothing'
    -- when there was no metadata with the given /@key@/.
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

-- method DeviceProviderFactory::get_metadata_keys
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "factory"
--           , argType =
--               TInterface
--                 Name { namespace = "Gst" , name = "DeviceProviderFactory" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProviderFactory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_get_metadata_keys" gst_device_provider_factory_get_metadata_keys :: 
    Ptr DeviceProviderFactory ->            -- factory : TInterface (Name {namespace = "Gst", name = "DeviceProviderFactory"})
    IO (Ptr CString)

-- | Get the available keys for the metadata on /@factory@/.
-- 
-- /Since: 1.4/
deviceProviderFactoryGetMetadataKeys ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
    a
    -- ^ /@factory@/: a t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory'
    -> m (Maybe [T.Text])
    -- ^ __Returns:__ 
    -- a 'P.Nothing'-terminated array of key strings, or 'P.Nothing' when there is no
    -- metadata. Free with 'GI.GLib.Functions.strfreev' when no longer needed.
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

-- method DeviceProviderFactory::has_classes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "factory"
--           , argType =
--               TInterface
--                 Name { namespace = "Gst" , name = "DeviceProviderFactory" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProviderFactory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "classes"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a \"/\" separate list of classes to match, only match\n    if all classes are matched"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_has_classes" gst_device_provider_factory_has_classes :: 
    Ptr DeviceProviderFactory ->            -- factory : TInterface (Name {namespace = "Gst", name = "DeviceProviderFactory"})
    CString ->                              -- classes : TBasicType TUTF8
    IO CInt

-- | Check if /@factory@/ matches all of the given /@classes@/
-- 
-- /Since: 1.4/
deviceProviderFactoryHasClasses ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
    a
    -- ^ /@factory@/: a t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory'
    -> Maybe (T.Text)
    -- ^ /@classes@/: a \"\/\" separate list of classes to match, only match
    --     if all classes are matched
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@factory@/ matches or if /@classes@/ is 'P.Nothing'.
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

-- method DeviceProviderFactory::has_classesv
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "factory"
--           , argType =
--               TInterface
--                 Name { namespace = "Gst" , name = "DeviceProviderFactory" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProviderFactory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "classes"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a %NULL terminated array\n  of classes to match, only match if all classes are matched"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_has_classesv" gst_device_provider_factory_has_classesv :: 
    Ptr DeviceProviderFactory ->            -- factory : TInterface (Name {namespace = "Gst", name = "DeviceProviderFactory"})
    Ptr CString ->                          -- classes : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO CInt

-- | Check if /@factory@/ matches all of the given classes
-- 
-- /Since: 1.4/
deviceProviderFactoryHasClassesv ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProviderFactory a) =>
    a
    -- ^ /@factory@/: a t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory'
    -> Maybe ([T.Text])
    -- ^ /@classes@/: a 'P.Nothing' terminated array
    --   of classes to match, only match if all classes are matched
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@factory@/ matches.
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

-- method DeviceProviderFactory::find
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of factory to find"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gst" , name = "DeviceProviderFactory" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_find" gst_device_provider_factory_find :: 
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr DeviceProviderFactory)

-- | Search for an device provider factory of the given name. Refs the returned
-- device provider factory; caller is responsible for unreffing.
-- 
-- /Since: 1.4/
deviceProviderFactoryFind ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@name@/: name of factory to find
    -> m (Maybe DeviceProviderFactory)
    -- ^ __Returns:__ t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' if
    -- found, 'P.Nothing' otherwise
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

-- method DeviceProviderFactory::get_by_name
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "factoryname"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a named factory to instantiate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gst" , name = "DeviceProvider" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_get_by_name" gst_device_provider_factory_get_by_name :: 
    CString ->                              -- factoryname : TBasicType TUTF8
    IO (Ptr Gst.DeviceProvider.DeviceProvider)

-- | Returns the device provider of the type defined by the given device
-- provider factory.
-- 
-- /Since: 1.4/
deviceProviderFactoryGetByName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@factoryname@/: a named factory to instantiate
    -> m (Maybe Gst.DeviceProvider.DeviceProvider)
    -- ^ __Returns:__ a t'GI.Gst.Objects.DeviceProvider.DeviceProvider' or 'P.Nothing'
    -- if unable to create device provider
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

-- method DeviceProviderFactory::list_get_device_providers
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "minrank"
--           , argType = TInterface Name { namespace = "Gst" , name = "Rank" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Minimum rank" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface
--                     Name { namespace = "Gst" , name = "DeviceProviderFactory" }))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_factory_list_get_device_providers" gst_device_provider_factory_list_get_device_providers :: 
    CUInt ->                                -- minrank : TInterface (Name {namespace = "Gst", name = "Rank"})
    IO (Ptr (GList (Ptr DeviceProviderFactory)))

-- | Get a list of factories with a rank greater or equal to /@minrank@/.
-- The list of factories is returned by decreasing rank.
-- 
-- /Since: 1.4/
deviceProviderFactoryListGetDeviceProviders ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gst.Enums.Rank
    -- ^ /@minrank@/: Minimum rank
    -> m [DeviceProviderFactory]
    -- ^ __Returns:__ 
    -- a t'GI.GLib.Structs.List.List' of t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' device providers. Use
    -- 'GI.Gst.Objects.PluginFeature.pluginFeatureListFree' after usage.
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