{-# 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                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addControlBinding]("GI.Gst.Objects.Object#g:method:addControlBinding"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkVersion]("GI.Gst.Objects.PluginFeature#g:method:checkVersion"), [defaultError]("GI.Gst.Objects.Object#g:method:defaultError"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [get]("GI.Gst.Objects.DeviceProviderFactory#g:method:get"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasActiveControlBindings]("GI.Gst.Objects.Object#g:method:hasActiveControlBindings"), [hasAncestor]("GI.Gst.Objects.Object#g:method:hasAncestor"), [hasAsAncestor]("GI.Gst.Objects.Object#g:method:hasAsAncestor"), [hasAsParent]("GI.Gst.Objects.Object#g:method:hasAsParent"), [hasClasses]("GI.Gst.Objects.DeviceProviderFactory#g:method:hasClasses"), [hasClassesv]("GI.Gst.Objects.DeviceProviderFactory#g:method:hasClassesv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [load]("GI.Gst.Objects.PluginFeature#g:method:load"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.Gst.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeControlBinding]("GI.Gst.Objects.Object#g:method:removeControlBinding"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [suggestNextSync]("GI.Gst.Objects.Object#g:method:suggestNextSync"), [syncValues]("GI.Gst.Objects.Object#g:method:syncValues"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unparent]("GI.Gst.Objects.Object#g:method:unparent"), [unref]("GI.Gst.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getControlBinding]("GI.Gst.Objects.Object#g:method:getControlBinding"), [getControlRate]("GI.Gst.Objects.Object#g:method:getControlRate"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDeviceProviderType]("GI.Gst.Objects.DeviceProviderFactory#g:method:getDeviceProviderType"), [getGValueArray]("GI.Gst.Objects.Object#g:method:getGValueArray"), [getMetadata]("GI.Gst.Objects.DeviceProviderFactory#g:method:getMetadata"), [getMetadataKeys]("GI.Gst.Objects.DeviceProviderFactory#g:method:getMetadataKeys"), [getName]("GI.Gst.Objects.Object#g:method:getName"), [getParent]("GI.Gst.Objects.Object#g:method:getParent"), [getPathString]("GI.Gst.Objects.Object#g:method:getPathString"), [getPlugin]("GI.Gst.Objects.PluginFeature#g:method:getPlugin"), [getPluginName]("GI.Gst.Objects.PluginFeature#g:method:getPluginName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRank]("GI.Gst.Objects.PluginFeature#g:method:getRank"), [getValue]("GI.Gst.Objects.Object#g:method:getValue").
-- 
-- ==== Setters
-- [setControlBindingDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingDisabled"), [setControlBindingsDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingsDisabled"), [setControlRate]("GI.Gst.Objects.Object#g:method:setControlRate"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setName]("GI.Gst.Objects.Object#g:method:setName"), [setParent]("GI.Gst.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRank]("GI.Gst.Objects.PluginFeature#g:method:setRank").

#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.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

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

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

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

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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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

-- 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 :: 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