DeviceProviderFactory.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' is used to create instances of device providers. A
GstDeviceProviderfactory can be added to a 'GI.Gst.Objects.Plugin.Plugin' as it is also a
'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/
-}

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

module GI.Gst.Objects.DeviceProviderFactory
    ( 

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


 -- * Methods
-- ** find #method:find#

    deviceProviderFactoryFind               ,


-- ** get #method:get#

#if ENABLE_OVERLOADING
    DeviceProviderFactoryGetMethodInfo      ,
#endif
    deviceProviderFactoryGet                ,


-- ** getByName #method:getByName#

    deviceProviderFactoryGetByName          ,


-- ** getDeviceProviderType #method:getDeviceProviderType#

#if ENABLE_OVERLOADING
    DeviceProviderFactoryGetDeviceProviderTypeMethodInfo,
#endif
    deviceProviderFactoryGetDeviceProviderType,


-- ** getMetadata #method:getMetadata#

#if ENABLE_OVERLOADING
    DeviceProviderFactoryGetMetadataMethodInfo,
#endif
    deviceProviderFactoryGetMetadata        ,


-- ** getMetadataKeys #method:getMetadataKeys#

#if ENABLE_OVERLOADING
    DeviceProviderFactoryGetMetadataKeysMethodInfo,
#endif
    deviceProviderFactoryGetMetadataKeys    ,


-- ** hasClasses #method:hasClasses#

#if ENABLE_OVERLOADING
    DeviceProviderFactoryHasClassesMethodInfo,
#endif
    deviceProviderFactoryHasClasses         ,


-- ** hasClassesv #method:hasClassesv#

#if 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.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)
foreign import ccall "gst_device_provider_factory_get_type"
    c_gst_device_provider_factory_get_type :: IO GType

instance GObject DeviceProviderFactory where
    gobjectType = c_gst_device_provider_factory_get_type
    

-- | 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 = liftIO . unsafeCastTo DeviceProviderFactory

-- | A convenience alias for `Nothing` :: `Maybe` `DeviceProviderFactory`.
noDeviceProviderFactory :: Maybe DeviceProviderFactory
noDeviceProviderFactory = Nothing

#if 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 "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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

#if 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 ENABLE_OVERLOADING
#endif

#if 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 'GI.Gst.Objects.DeviceProvider.DeviceProvider' or 'Nothing'
if the device provider couldn\'t be created -}
deviceProviderFactoryGet factory = liftIO $ do
    factory' <- unsafeManagedPtrCastPtr factory
    result <- gst_device_provider_factory_get factory'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Gst.DeviceProvider.DeviceProvider) result'
        return result''
    touchManagedPtr factory
    return maybeResult

#if 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 '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 'GType' from -}
    -> m GType
    {- ^ __Returns:__ the 'GType' for device providers managed by this factory. -}
deviceProviderFactoryGetDeviceProviderType factory = liftIO $ do
    factory' <- unsafeManagedPtrCastPtr factory
    result <- gst_device_provider_factory_get_device_provider_type factory'
    let result' = GType result
    touchManagedPtr factory
    return result'

#if 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 'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' -}
    -> T.Text
    {- ^ /@key@/: a key -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the metadata with /@key@/ on /@factory@/ or 'Nothing'
when there was no metadata with the given /@key@/. -}
deviceProviderFactoryGetMetadata factory key = liftIO $ do
    factory' <- unsafeManagedPtrCastPtr factory
    key' <- textToCString key
    result <- gst_device_provider_factory_get_metadata factory' key'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr factory
    freeMem key'
    return maybeResult

#if 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 'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' -}
    -> m (Maybe [T.Text])
    {- ^ __Returns:__ 
a 'Nothing'-terminated array of key strings, or 'Nothing' when there is no
metadata. Free with 'GI.GLib.Functions.strfreev' when no longer needed. -}
deviceProviderFactoryGetMetadataKeys factory = liftIO $ do
    factory' <- unsafeManagedPtrCastPtr factory
    result <- gst_device_provider_factory_get_metadata_keys factory'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- unpackZeroTerminatedUTF8CArray result'
        mapZeroTerminatedCArray freeMem result'
        freeMem result'
        return result''
    touchManagedPtr factory
    return maybeResult

#if 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 '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:__ 'True' if /@factory@/ matches or if /@classes@/ is 'Nothing'. -}
deviceProviderFactoryHasClasses factory classes = liftIO $ do
    factory' <- unsafeManagedPtrCastPtr factory
    maybeClasses <- case classes of
        Nothing -> return nullPtr
        Just jClasses -> do
            jClasses' <- textToCString jClasses
            return jClasses'
    result <- gst_device_provider_factory_has_classes factory' maybeClasses
    let result' = (/= 0) result
    touchManagedPtr factory
    freeMem maybeClasses
    return result'

#if 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 'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' -}
    -> Maybe ([T.Text])
    {- ^ /@classes@/: a 'Nothing' terminated array
  of classes to match, only match if all classes are matched -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@factory@/ matches. -}
deviceProviderFactoryHasClassesv factory classes = liftIO $ do
    factory' <- unsafeManagedPtrCastPtr factory
    maybeClasses <- case classes of
        Nothing -> return nullPtr
        Just jClasses -> do
            jClasses' <- packZeroTerminatedUTF8CArray jClasses
            return jClasses'
    result <- gst_device_provider_factory_has_classesv factory' maybeClasses
    let result' = (/= 0) result
    touchManagedPtr factory
    mapZeroTerminatedCArray freeMem maybeClasses
    freeMem maybeClasses
    return result'

#if 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:__ 'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' if
found, 'Nothing' otherwise -}
deviceProviderFactoryFind name = liftIO $ do
    name' <- textToCString name
    result <- gst_device_provider_factory_find name'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject DeviceProviderFactory) result'
        return result''
    freeMem name'
    return maybeResult

#if 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 'GI.Gst.Objects.DeviceProvider.DeviceProvider' or 'Nothing'
if unable to create device provider -}
deviceProviderFactoryGetByName factoryname = liftIO $ do
    factoryname' <- textToCString factoryname
    result <- gst_device_provider_factory_get_by_name factoryname'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject Gst.DeviceProvider.DeviceProvider) result'
        return result''
    freeMem factoryname'
    return maybeResult

#if 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 'GI.GLib.Structs.List.List' of 'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' device providers. Use
'GI.Gst.Objects.PluginFeature.pluginFeatureListFree' after usage. -}
deviceProviderFactoryListGetDeviceProviders minrank = liftIO $ do
    let minrank' = (fromIntegral . fromEnum) minrank
    result <- gst_device_provider_factory_list_get_device_providers minrank'
    result' <- unpackGList result
    result'' <- mapM (wrapObject DeviceProviderFactory) result'
    g_list_free result
    return result''

#if ENABLE_OVERLOADING
#endif