{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Plugin
(
Plugin(..) ,
IsPlugin ,
toPlugin ,
#if defined(ENABLE_OVERLOADING)
ResolvePluginMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PluginAddDependencyMethodInfo ,
#endif
pluginAddDependency ,
#if defined(ENABLE_OVERLOADING)
PluginAddDependencySimpleMethodInfo ,
#endif
pluginAddDependencySimple ,
#if defined(ENABLE_OVERLOADING)
PluginGetCacheDataMethodInfo ,
#endif
pluginGetCacheData ,
#if defined(ENABLE_OVERLOADING)
PluginGetDescriptionMethodInfo ,
#endif
pluginGetDescription ,
#if defined(ENABLE_OVERLOADING)
PluginGetFilenameMethodInfo ,
#endif
pluginGetFilename ,
#if defined(ENABLE_OVERLOADING)
PluginGetLicenseMethodInfo ,
#endif
pluginGetLicense ,
#if defined(ENABLE_OVERLOADING)
PluginGetNameMethodInfo ,
#endif
pluginGetName ,
#if defined(ENABLE_OVERLOADING)
PluginGetOriginMethodInfo ,
#endif
pluginGetOrigin ,
#if defined(ENABLE_OVERLOADING)
PluginGetPackageMethodInfo ,
#endif
pluginGetPackage ,
#if defined(ENABLE_OVERLOADING)
PluginGetReleaseDateStringMethodInfo ,
#endif
pluginGetReleaseDateString ,
#if defined(ENABLE_OVERLOADING)
PluginGetSourceMethodInfo ,
#endif
pluginGetSource ,
#if defined(ENABLE_OVERLOADING)
PluginGetVersionMethodInfo ,
#endif
pluginGetVersion ,
#if defined(ENABLE_OVERLOADING)
PluginIsLoadedMethodInfo ,
#endif
pluginIsLoaded ,
pluginListFree ,
#if defined(ENABLE_OVERLOADING)
PluginLoadMethodInfo ,
#endif
pluginLoad ,
pluginLoadByName ,
pluginLoadFile ,
pluginRegisterStatic ,
pluginRegisterStaticFull ,
#if defined(ENABLE_OVERLOADING)
PluginSetCacheDataMethodInfo ,
#endif
pluginSetCacheData ,
) 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.Coerce as Coerce
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 qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure
newtype Plugin = Plugin (SP.ManagedPtr Plugin)
deriving (Plugin -> Plugin -> Bool
(Plugin -> Plugin -> Bool)
-> (Plugin -> Plugin -> Bool) -> Eq Plugin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Plugin -> Plugin -> Bool
$c/= :: Plugin -> Plugin -> Bool
== :: Plugin -> Plugin -> Bool
$c== :: Plugin -> Plugin -> Bool
Eq)
instance SP.ManagedPtrNewtype Plugin where
toManagedPtr :: Plugin -> ManagedPtr Plugin
toManagedPtr (Plugin ManagedPtr Plugin
p) = ManagedPtr Plugin
p
foreign import ccall "gst_plugin_get_type"
c_gst_plugin_get_type :: IO B.Types.GType
instance B.Types.TypedObject Plugin where
glibType :: IO GType
glibType = IO GType
c_gst_plugin_get_type
instance B.Types.GObject Plugin
class (SP.GObject o, O.IsDescendantOf Plugin o) => IsPlugin o
instance (SP.GObject o, O.IsDescendantOf Plugin o) => IsPlugin o
instance O.HasParentTypes Plugin
type instance O.ParentTypes Plugin = '[Gst.Object.Object, GObject.Object.Object]
toPlugin :: (MIO.MonadIO m, IsPlugin o) => o -> m Plugin
toPlugin :: forall (m :: * -> *) o. (MonadIO m, IsPlugin o) => o -> m Plugin
toPlugin = IO Plugin -> m Plugin
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Plugin -> m Plugin) -> (o -> IO Plugin) -> o -> m Plugin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Plugin -> Plugin) -> o -> IO Plugin
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Plugin -> Plugin
Plugin
instance B.GValue.IsGValue (Maybe Plugin) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_plugin_get_type
gvalueSet_ :: Ptr GValue -> Maybe Plugin -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Plugin
P.Nothing = Ptr GValue -> Ptr Plugin -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Plugin
forall a. Ptr a
FP.nullPtr :: FP.Ptr Plugin)
gvalueSet_ Ptr GValue
gv (P.Just Plugin
obj) = Plugin -> (Ptr Plugin -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Plugin
obj (Ptr GValue -> Ptr Plugin -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Plugin)
gvalueGet_ Ptr GValue
gv = do
Ptr Plugin
ptr <- Ptr GValue -> IO (Ptr Plugin)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Plugin)
if Ptr Plugin
ptr Ptr Plugin -> Ptr Plugin -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Plugin
forall a. Ptr a
FP.nullPtr
then Plugin -> Maybe Plugin
forall a. a -> Maybe a
P.Just (Plugin -> Maybe Plugin) -> IO Plugin -> IO (Maybe Plugin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Plugin -> Plugin
Plugin Ptr Plugin
ptr
else Maybe Plugin -> IO (Maybe Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Plugin
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolvePluginMethod (t :: Symbol) (o :: *) :: * where
ResolvePluginMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolvePluginMethod "addDependency" o = PluginAddDependencyMethodInfo
ResolvePluginMethod "addDependencySimple" o = PluginAddDependencySimpleMethodInfo
ResolvePluginMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolvePluginMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolvePluginMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolvePluginMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolvePluginMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolvePluginMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolvePluginMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolvePluginMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolvePluginMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolvePluginMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolvePluginMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolvePluginMethod "isLoaded" o = PluginIsLoadedMethodInfo
ResolvePluginMethod "load" o = PluginLoadMethodInfo
ResolvePluginMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolvePluginMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolvePluginMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolvePluginMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolvePluginMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolvePluginMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolvePluginMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolvePluginMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolvePluginMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolvePluginMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolvePluginMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolvePluginMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolvePluginMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolvePluginMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolvePluginMethod "getCacheData" o = PluginGetCacheDataMethodInfo
ResolvePluginMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolvePluginMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolvePluginMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolvePluginMethod "getDescription" o = PluginGetDescriptionMethodInfo
ResolvePluginMethod "getFilename" o = PluginGetFilenameMethodInfo
ResolvePluginMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolvePluginMethod "getLicense" o = PluginGetLicenseMethodInfo
ResolvePluginMethod "getName" o = PluginGetNameMethodInfo
ResolvePluginMethod "getOrigin" o = PluginGetOriginMethodInfo
ResolvePluginMethod "getPackage" o = PluginGetPackageMethodInfo
ResolvePluginMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolvePluginMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolvePluginMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolvePluginMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolvePluginMethod "getReleaseDateString" o = PluginGetReleaseDateStringMethodInfo
ResolvePluginMethod "getSource" o = PluginGetSourceMethodInfo
ResolvePluginMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolvePluginMethod "getVersion" o = PluginGetVersionMethodInfo
ResolvePluginMethod "setCacheData" o = PluginSetCacheDataMethodInfo
ResolvePluginMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolvePluginMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolvePluginMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolvePluginMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolvePluginMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolvePluginMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolvePluginMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolvePluginMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolvePluginMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePluginMethod t Plugin, O.OverloadedMethod info Plugin p) => OL.IsLabel t (Plugin -> 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 ~ ResolvePluginMethod t Plugin, O.OverloadedMethod info Plugin p, R.HasField t Plugin p) => R.HasField t Plugin p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolvePluginMethod t Plugin, O.OverloadedMethodInfo info Plugin) => OL.IsLabel t (O.MethodProxy info Plugin) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Plugin
type instance O.AttributeList Plugin = PluginAttributeList
type PluginAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Plugin = PluginSignalList
type PluginSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_plugin_add_dependency" gst_plugin_add_dependency ::
Ptr Plugin ->
Ptr CString ->
Ptr CString ->
Ptr CString ->
CUInt ->
IO ()
pluginAddDependency ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> Maybe ([T.Text])
-> Maybe ([T.Text])
-> Maybe ([T.Text])
-> [Gst.Flags.PluginDependencyFlags]
-> m ()
pluginAddDependency :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a
-> Maybe [Text]
-> Maybe [Text]
-> Maybe [Text]
-> [PluginDependencyFlags]
-> m ()
pluginAddDependency a
plugin Maybe [Text]
envVars Maybe [Text]
paths Maybe [Text]
names [PluginDependencyFlags]
flags = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
Ptr CString
maybeEnvVars <- case Maybe [Text]
envVars 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]
jEnvVars -> do
Ptr CString
jEnvVars' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jEnvVars
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jEnvVars'
Ptr CString
maybePaths <- case Maybe [Text]
paths 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]
jPaths -> do
Ptr CString
jPaths' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jPaths
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jPaths'
Ptr CString
maybeNames <- case Maybe [Text]
names 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]
jNames -> do
Ptr CString
jNames' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jNames
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jNames'
let flags' :: CUInt
flags' = [PluginDependencyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PluginDependencyFlags]
flags
Ptr Plugin
-> Ptr CString -> Ptr CString -> Ptr CString -> CUInt -> IO ()
gst_plugin_add_dependency Ptr Plugin
plugin' Ptr CString
maybeEnvVars Ptr CString
maybePaths Ptr CString
maybeNames CUInt
flags'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
(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
maybeEnvVars
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeEnvVars
(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
maybePaths
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybePaths
(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
maybeNames
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeNames
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PluginAddDependencyMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> Maybe ([T.Text]) -> Maybe ([T.Text]) -> [Gst.Flags.PluginDependencyFlags] -> m ()), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginAddDependencyMethodInfo a signature where
overloadedMethod = pluginAddDependency
instance O.OverloadedMethodInfo PluginAddDependencyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginAddDependency",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginAddDependency"
})
#endif
foreign import ccall "gst_plugin_add_dependency_simple" gst_plugin_add_dependency_simple ::
Ptr Plugin ->
CString ->
CString ->
CString ->
CUInt ->
IO ()
pluginAddDependencySimple ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> Maybe (T.Text)
-> Maybe (T.Text)
-> Maybe (T.Text)
-> [Gst.Flags.PluginDependencyFlags]
-> m ()
pluginAddDependencySimple :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> [PluginDependencyFlags]
-> m ()
pluginAddDependencySimple a
plugin Maybe Text
envVars Maybe Text
paths Maybe Text
names [PluginDependencyFlags]
flags = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
maybeEnvVars <- case Maybe Text
envVars of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jEnvVars -> do
CString
jEnvVars' <- Text -> IO CString
textToCString Text
jEnvVars
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jEnvVars'
CString
maybePaths <- case Maybe Text
paths of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jPaths -> do
CString
jPaths' <- Text -> IO CString
textToCString Text
jPaths
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jPaths'
CString
maybeNames <- case Maybe Text
names of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jNames -> do
CString
jNames' <- Text -> IO CString
textToCString Text
jNames
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jNames'
let flags' :: CUInt
flags' = [PluginDependencyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PluginDependencyFlags]
flags
Ptr Plugin -> CString -> CString -> CString -> CUInt -> IO ()
gst_plugin_add_dependency_simple Ptr Plugin
plugin' CString
maybeEnvVars CString
maybePaths CString
maybeNames CUInt
flags'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeEnvVars
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybePaths
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeNames
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PluginAddDependencySimpleMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> [Gst.Flags.PluginDependencyFlags] -> m ()), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginAddDependencySimpleMethodInfo a signature where
overloadedMethod = pluginAddDependencySimple
instance O.OverloadedMethodInfo PluginAddDependencySimpleMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginAddDependencySimple",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginAddDependencySimple"
})
#endif
foreign import ccall "gst_plugin_get_cache_data" gst_plugin_get_cache_data ::
Ptr Plugin ->
IO (Ptr Gst.Structure.Structure)
pluginGetCacheData ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m (Maybe Gst.Structure.Structure)
pluginGetCacheData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m (Maybe Structure)
pluginGetCacheData a
plugin = IO (Maybe Structure) -> m (Maybe Structure)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Structure) -> m (Maybe Structure))
-> IO (Maybe Structure) -> m (Maybe Structure)
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
Ptr Structure
result <- Ptr Plugin -> IO (Ptr Structure)
gst_plugin_get_cache_data Ptr Plugin
plugin'
Maybe Structure
maybeResult <- Ptr Structure
-> (Ptr Structure -> IO Structure) -> IO (Maybe Structure)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Structure
result ((Ptr Structure -> IO Structure) -> IO (Maybe Structure))
-> (Ptr Structure -> IO Structure) -> IO (Maybe Structure)
forall a b. (a -> b) -> a -> b
$ \Ptr Structure
result' -> do
Structure
result'' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
result'
Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Maybe Structure -> IO (Maybe Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Structure
maybeResult
#if defined(ENABLE_OVERLOADING)
data PluginGetCacheDataMethodInfo
instance (signature ~ (m (Maybe Gst.Structure.Structure)), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetCacheDataMethodInfo a signature where
overloadedMethod = pluginGetCacheData
instance O.OverloadedMethodInfo PluginGetCacheDataMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetCacheData",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetCacheData"
})
#endif
foreign import ccall "gst_plugin_get_description" gst_plugin_get_description ::
Ptr Plugin ->
IO CString
pluginGetDescription ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m T.Text
pluginGetDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Text
pluginGetDescription a
plugin = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_description Ptr Plugin
plugin'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginGetDescription" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PluginGetDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetDescriptionMethodInfo a signature where
overloadedMethod = pluginGetDescription
instance O.OverloadedMethodInfo PluginGetDescriptionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetDescription"
})
#endif
foreign import ccall "gst_plugin_get_filename" gst_plugin_get_filename ::
Ptr Plugin ->
IO CString
pluginGetFilename ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m (Maybe [Char])
pluginGetFilename :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m (Maybe [Char])
pluginGetFilename a
plugin = IO (Maybe [Char]) -> m (Maybe [Char])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [Char]) -> m (Maybe [Char]))
-> IO (Maybe [Char]) -> m (Maybe [Char])
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_filename Ptr Plugin
plugin'
Maybe [Char]
maybeResult <- CString -> (CString -> IO [Char]) -> IO (Maybe [Char])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO [Char]) -> IO (Maybe [Char]))
-> (CString -> IO [Char]) -> IO (Maybe [Char])
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
[Char]
result'' <- HasCallStack => CString -> IO [Char]
CString -> IO [Char]
cstringToString CString
result'
[Char] -> IO [Char]
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Maybe [Char] -> IO (Maybe [Char])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Char]
maybeResult
#if defined(ENABLE_OVERLOADING)
data PluginGetFilenameMethodInfo
instance (signature ~ (m (Maybe [Char])), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetFilenameMethodInfo a signature where
overloadedMethod = pluginGetFilename
instance O.OverloadedMethodInfo PluginGetFilenameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetFilename",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetFilename"
})
#endif
foreign import ccall "gst_plugin_get_license" gst_plugin_get_license ::
Ptr Plugin ->
IO CString
pluginGetLicense ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m T.Text
pluginGetLicense :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Text
pluginGetLicense a
plugin = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_license Ptr Plugin
plugin'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginGetLicense" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PluginGetLicenseMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetLicenseMethodInfo a signature where
overloadedMethod = pluginGetLicense
instance O.OverloadedMethodInfo PluginGetLicenseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetLicense",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetLicense"
})
#endif
foreign import ccall "gst_plugin_get_name" gst_plugin_get_name ::
Ptr Plugin ->
IO CString
pluginGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m T.Text
pluginGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Text
pluginGetName a
plugin = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_name Ptr Plugin
plugin'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginGetName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PluginGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetNameMethodInfo a signature where
overloadedMethod = pluginGetName
instance O.OverloadedMethodInfo PluginGetNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetName"
})
#endif
foreign import ccall "gst_plugin_get_origin" gst_plugin_get_origin ::
Ptr Plugin ->
IO CString
pluginGetOrigin ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m T.Text
pluginGetOrigin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Text
pluginGetOrigin a
plugin = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_origin Ptr Plugin
plugin'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginGetOrigin" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PluginGetOriginMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetOriginMethodInfo a signature where
overloadedMethod = pluginGetOrigin
instance O.OverloadedMethodInfo PluginGetOriginMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetOrigin",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetOrigin"
})
#endif
foreign import ccall "gst_plugin_get_package" gst_plugin_get_package ::
Ptr Plugin ->
IO CString
pluginGetPackage ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m T.Text
pluginGetPackage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Text
pluginGetPackage a
plugin = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_package Ptr Plugin
plugin'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginGetPackage" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PluginGetPackageMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetPackageMethodInfo a signature where
overloadedMethod = pluginGetPackage
instance O.OverloadedMethodInfo PluginGetPackageMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetPackage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetPackage"
})
#endif
foreign import ccall "gst_plugin_get_release_date_string" gst_plugin_get_release_date_string ::
Ptr Plugin ->
IO CString
pluginGetReleaseDateString ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m (Maybe T.Text)
pluginGetReleaseDateString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m (Maybe Text)
pluginGetReleaseDateString a
plugin = 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 Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_release_date_string Ptr Plugin
plugin'
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
plugin
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data PluginGetReleaseDateStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetReleaseDateStringMethodInfo a signature where
overloadedMethod = pluginGetReleaseDateString
instance O.OverloadedMethodInfo PluginGetReleaseDateStringMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetReleaseDateString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetReleaseDateString"
})
#endif
foreign import ccall "gst_plugin_get_source" gst_plugin_get_source ::
Ptr Plugin ->
IO CString
pluginGetSource ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m T.Text
pluginGetSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Text
pluginGetSource a
plugin = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_source Ptr Plugin
plugin'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginGetSource" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PluginGetSourceMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetSourceMethodInfo a signature where
overloadedMethod = pluginGetSource
instance O.OverloadedMethodInfo PluginGetSourceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetSource"
})
#endif
foreign import ccall "gst_plugin_get_version" gst_plugin_get_version ::
Ptr Plugin ->
IO CString
pluginGetVersion ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m T.Text
pluginGetVersion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Text
pluginGetVersion a
plugin = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CString
result <- Ptr Plugin -> IO CString
gst_plugin_get_version Ptr Plugin
plugin'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginGetVersion" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PluginGetVersionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetVersionMethodInfo a signature where
overloadedMethod = pluginGetVersion
instance O.OverloadedMethodInfo PluginGetVersionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginGetVersion",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginGetVersion"
})
#endif
foreign import ccall "gst_plugin_is_loaded" gst_plugin_is_loaded ::
Ptr Plugin ->
IO CInt
pluginIsLoaded ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m Bool
pluginIsLoaded :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m Bool
pluginIsLoaded a
plugin = 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 Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
CInt
result <- Ptr Plugin -> IO CInt
gst_plugin_is_loaded Ptr Plugin
plugin'
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
plugin
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PluginIsLoadedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginIsLoadedMethodInfo a signature where
overloadedMethod = pluginIsLoaded
instance O.OverloadedMethodInfo PluginIsLoadedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginIsLoaded",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginIsLoaded"
})
#endif
foreign import ccall "gst_plugin_load" gst_plugin_load ::
Ptr Plugin ->
IO (Ptr Plugin)
pluginLoad ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> m (Maybe Plugin)
pluginLoad :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> m (Maybe Plugin)
pluginLoad a
plugin = IO (Maybe Plugin) -> m (Maybe Plugin)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Plugin) -> m (Maybe Plugin))
-> IO (Maybe Plugin) -> m (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
Ptr Plugin
result <- Ptr Plugin -> IO (Ptr Plugin)
gst_plugin_load Ptr Plugin
plugin'
Maybe Plugin
maybeResult <- Ptr Plugin -> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Plugin
result ((Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin))
-> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ \Ptr Plugin
result' -> do
Plugin
result'' <- ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Plugin -> Plugin
Plugin) Ptr Plugin
result'
Plugin -> IO Plugin
forall (m :: * -> *) a. Monad m => a -> m a
return Plugin
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Maybe Plugin -> IO (Maybe Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Plugin
maybeResult
#if defined(ENABLE_OVERLOADING)
data PluginLoadMethodInfo
instance (signature ~ (m (Maybe Plugin)), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginLoadMethodInfo a signature where
overloadedMethod = pluginLoad
instance O.OverloadedMethodInfo PluginLoadMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginLoad",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginLoad"
})
#endif
foreign import ccall "gst_plugin_set_cache_data" gst_plugin_set_cache_data ::
Ptr Plugin ->
Ptr Gst.Structure.Structure ->
IO ()
pluginSetCacheData ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
a
-> Gst.Structure.Structure
-> m ()
pluginSetCacheData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
a -> Structure -> m ()
pluginSetCacheData a
plugin Structure
cacheData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Plugin
plugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
Ptr Structure
cacheData' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
cacheData
Ptr Plugin -> Ptr Structure -> IO ()
gst_plugin_set_cache_data Ptr Plugin
plugin' Ptr Structure
cacheData'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
cacheData
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PluginSetCacheDataMethodInfo
instance (signature ~ (Gst.Structure.Structure -> m ()), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginSetCacheDataMethodInfo a signature where
overloadedMethod = pluginSetCacheData
instance O.OverloadedMethodInfo PluginSetCacheDataMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Plugin.pluginSetCacheData",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Plugin.html#v:pluginSetCacheData"
})
#endif
foreign import ccall "gst_plugin_list_free" gst_plugin_list_free ::
Ptr (GList (Ptr Plugin)) ->
IO ()
pluginListFree ::
(B.CallStack.HasCallStack, MonadIO m, IsPlugin a) =>
[a]
-> m ()
pluginListFree :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
[a] -> m ()
pluginListFree [a]
list = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
[Ptr Plugin]
list' <- (a -> IO (Ptr Plugin)) -> [a] -> IO [Ptr Plugin]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM a -> IO (Ptr Plugin)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject [a]
list
Ptr (GList (Ptr Plugin))
list'' <- [Ptr Plugin] -> IO (Ptr (GList (Ptr Plugin)))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr Plugin]
list'
Ptr (GList (Ptr Plugin)) -> IO ()
gst_plugin_list_free Ptr (GList (Ptr Plugin))
list''
(a -> IO ()) -> [a] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [a]
list
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_plugin_load_by_name" gst_plugin_load_by_name ::
CString ->
IO (Ptr Plugin)
pluginLoadByName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe Plugin)
pluginLoadByName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe Plugin)
pluginLoadByName Text
name = IO (Maybe Plugin) -> m (Maybe Plugin)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Plugin) -> m (Maybe Plugin))
-> IO (Maybe Plugin) -> m (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Plugin
result <- CString -> IO (Ptr Plugin)
gst_plugin_load_by_name CString
name'
Maybe Plugin
maybeResult <- Ptr Plugin -> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Plugin
result ((Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin))
-> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ \Ptr Plugin
result' -> do
Plugin
result'' <- ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Plugin -> Plugin
Plugin) Ptr Plugin
result'
Plugin -> IO Plugin
forall (m :: * -> *) a. Monad m => a -> m a
return Plugin
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe Plugin -> IO (Maybe Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Plugin
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_plugin_load_file" gst_plugin_load_file ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr Plugin)
pluginLoadFile ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Char]
-> m Plugin
pluginLoadFile :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[Char] -> m Plugin
pluginLoadFile [Char]
filename = IO Plugin -> m Plugin
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Plugin -> m Plugin) -> IO Plugin -> m Plugin
forall a b. (a -> b) -> a -> b
$ do
CString
filename' <- [Char] -> IO CString
stringToCString [Char]
filename
IO Plugin -> IO () -> IO Plugin
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Plugin
result <- (Ptr (Ptr GError) -> IO (Ptr Plugin)) -> IO (Ptr Plugin)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Plugin)) -> IO (Ptr Plugin))
-> (Ptr (Ptr GError) -> IO (Ptr Plugin)) -> IO (Ptr Plugin)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr Plugin)
gst_plugin_load_file CString
filename'
Text -> Ptr Plugin -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pluginLoadFile" Ptr Plugin
result
Plugin
result' <- ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Plugin -> Plugin
Plugin) Ptr Plugin
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Plugin -> IO Plugin
forall (m :: * -> *) a. Monad m => a -> m a
return Plugin
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_plugin_register_static" gst_plugin_register_static ::
Int32 ->
Int32 ->
CString ->
CString ->
FunPtr Gst.Callbacks.C_PluginInitFunc ->
CString ->
CString ->
CString ->
CString ->
CString ->
IO CInt
pluginRegisterStatic ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> Int32
-> T.Text
-> T.Text
-> Gst.Callbacks.PluginInitFunc
-> T.Text
-> T.Text
-> T.Text
-> T.Text
-> T.Text
-> m Bool
pluginRegisterStatic :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32
-> Int32
-> Text
-> Text
-> PluginInitFunc
-> Text
-> Text
-> Text
-> Text
-> Text
-> m Bool
pluginRegisterStatic Int32
majorVersion Int32
minorVersion Text
name Text
description PluginInitFunc
initFunc Text
version Text
license Text
source Text
package Text
origin = 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
CString
name' <- Text -> IO CString
textToCString Text
name
CString
description' <- Text -> IO CString
textToCString Text
description
FunPtr (Ptr Plugin -> IO CInt)
initFunc' <- (Ptr Plugin -> IO CInt) -> IO (FunPtr (Ptr Plugin -> IO CInt))
Gst.Callbacks.mk_PluginInitFunc (Maybe (Ptr (FunPtr (Ptr Plugin -> IO CInt)))
-> PluginInitFunc -> Ptr Plugin -> IO CInt
Gst.Callbacks.wrap_PluginInitFunc Maybe (Ptr (FunPtr (Ptr Plugin -> IO CInt)))
forall a. Maybe a
Nothing PluginInitFunc
initFunc)
CString
version' <- Text -> IO CString
textToCString Text
version
CString
license' <- Text -> IO CString
textToCString Text
license
CString
source' <- Text -> IO CString
textToCString Text
source
CString
package' <- Text -> IO CString
textToCString Text
package
CString
origin' <- Text -> IO CString
textToCString Text
origin
CInt
result <- Int32
-> Int32
-> CString
-> CString
-> FunPtr (Ptr Plugin -> IO CInt)
-> CString
-> CString
-> CString
-> CString
-> CString
-> IO CInt
gst_plugin_register_static Int32
majorVersion Int32
minorVersion CString
name' CString
description' FunPtr (Ptr Plugin -> IO CInt)
initFunc' CString
version' CString
license' CString
source' CString
package' CString
origin'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr Plugin -> IO CInt) -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Plugin -> IO CInt)
initFunc'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
description'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
version'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
license'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
source'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
package'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
origin'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_plugin_register_static_full" gst_plugin_register_static_full ::
Int32 ->
Int32 ->
CString ->
CString ->
FunPtr Gst.Callbacks.C_PluginInitFullFunc ->
CString ->
CString ->
CString ->
CString ->
CString ->
Ptr () ->
IO CInt
pluginRegisterStaticFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> Int32
-> T.Text
-> T.Text
-> Gst.Callbacks.PluginInitFullFunc
-> T.Text
-> T.Text
-> T.Text
-> T.Text
-> T.Text
-> m Bool
pluginRegisterStaticFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32
-> Int32
-> Text
-> Text
-> PluginInitFunc
-> Text
-> Text
-> Text
-> Text
-> Text
-> m Bool
pluginRegisterStaticFull Int32
majorVersion Int32
minorVersion Text
name Text
description PluginInitFunc
initFullFunc Text
version Text
license Text
source Text
package Text
origin = 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
CString
name' <- Text -> IO CString
textToCString Text
name
CString
description' <- Text -> IO CString
textToCString Text
description
FunPtr C_PluginInitFullFunc
initFullFunc' <- C_PluginInitFullFunc -> IO (FunPtr C_PluginInitFullFunc)
Gst.Callbacks.mk_PluginInitFullFunc (Maybe (Ptr (FunPtr C_PluginInitFullFunc))
-> PluginInitFullFunc_WithClosures -> C_PluginInitFullFunc
Gst.Callbacks.wrap_PluginInitFullFunc Maybe (Ptr (FunPtr C_PluginInitFullFunc))
forall a. Maybe a
Nothing (PluginInitFunc -> PluginInitFullFunc_WithClosures
Gst.Callbacks.drop_closures_PluginInitFullFunc PluginInitFunc
initFullFunc))
CString
version' <- Text -> IO CString
textToCString Text
version
CString
license' <- Text -> IO CString
textToCString Text
license
CString
source' <- Text -> IO CString
textToCString Text
source
CString
package' <- Text -> IO CString
textToCString Text
package
CString
origin' <- Text -> IO CString
textToCString Text
origin
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Int32
-> Int32
-> CString
-> CString
-> FunPtr C_PluginInitFullFunc
-> CString
-> CString
-> CString
-> CString
-> CString
-> Ptr ()
-> IO CInt
gst_plugin_register_static_full Int32
majorVersion Int32
minorVersion CString
name' CString
description' FunPtr C_PluginInitFullFunc
initFullFunc' CString
version' CString
license' CString
source' CString
package' CString
origin' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_PluginInitFullFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PluginInitFullFunc
initFullFunc'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
description'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
version'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
license'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
source'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
package'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
origin'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif