{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.TypeFindFactory
(
TypeFindFactory(..) ,
IsTypeFindFactory ,
toTypeFindFactory ,
#if defined(ENABLE_OVERLOADING)
ResolveTypeFindFactoryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TypeFindFactoryCallFunctionMethodInfo ,
#endif
typeFindFactoryCallFunction ,
#if defined(ENABLE_OVERLOADING)
TypeFindFactoryGetCapsMethodInfo ,
#endif
typeFindFactoryGetCaps ,
#if defined(ENABLE_OVERLOADING)
TypeFindFactoryGetExtensionsMethodInfo ,
#endif
typeFindFactoryGetExtensions ,
typeFindFactoryGetList ,
#if defined(ENABLE_OVERLOADING)
TypeFindFactoryHasFunctionMethodInfo ,
#endif
typeFindFactoryHasFunction ,
) 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.GHashTable as B.GHT
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.Kind as DK
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.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.PluginFeature as Gst.PluginFeature
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.TypeFind as Gst.TypeFind
newtype TypeFindFactory = TypeFindFactory (SP.ManagedPtr TypeFindFactory)
deriving (TypeFindFactory -> TypeFindFactory -> Bool
(TypeFindFactory -> TypeFindFactory -> Bool)
-> (TypeFindFactory -> TypeFindFactory -> Bool)
-> Eq TypeFindFactory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeFindFactory -> TypeFindFactory -> Bool
== :: TypeFindFactory -> TypeFindFactory -> Bool
$c/= :: TypeFindFactory -> TypeFindFactory -> Bool
/= :: TypeFindFactory -> TypeFindFactory -> Bool
Eq)
instance SP.ManagedPtrNewtype TypeFindFactory where
toManagedPtr :: TypeFindFactory -> ManagedPtr TypeFindFactory
toManagedPtr (TypeFindFactory ManagedPtr TypeFindFactory
p) = ManagedPtr TypeFindFactory
p
foreign import ccall "gst_type_find_factory_get_type"
c_gst_type_find_factory_get_type :: IO B.Types.GType
instance B.Types.TypedObject TypeFindFactory where
glibType :: IO GType
glibType = IO GType
c_gst_type_find_factory_get_type
instance B.Types.GObject TypeFindFactory
class (SP.GObject o, O.IsDescendantOf TypeFindFactory o) => IsTypeFindFactory o
instance (SP.GObject o, O.IsDescendantOf TypeFindFactory o) => IsTypeFindFactory o
instance O.HasParentTypes TypeFindFactory
type instance O.ParentTypes TypeFindFactory = '[Gst.PluginFeature.PluginFeature, Gst.Object.Object, GObject.Object.Object]
toTypeFindFactory :: (MIO.MonadIO m, IsTypeFindFactory o) => o -> m TypeFindFactory
toTypeFindFactory :: forall (m :: * -> *) o.
(MonadIO m, IsTypeFindFactory o) =>
o -> m TypeFindFactory
toTypeFindFactory = IO TypeFindFactory -> m TypeFindFactory
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TypeFindFactory -> m TypeFindFactory)
-> (o -> IO TypeFindFactory) -> o -> m TypeFindFactory
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TypeFindFactory -> TypeFindFactory)
-> o -> IO TypeFindFactory
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr TypeFindFactory -> TypeFindFactory
TypeFindFactory
instance B.GValue.IsGValue (Maybe TypeFindFactory) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_type_find_factory_get_type
gvalueSet_ :: Ptr GValue -> Maybe TypeFindFactory -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TypeFindFactory
P.Nothing = Ptr GValue -> Ptr TypeFindFactory -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TypeFindFactory
forall a. Ptr a
FP.nullPtr :: FP.Ptr TypeFindFactory)
gvalueSet_ Ptr GValue
gv (P.Just TypeFindFactory
obj) = TypeFindFactory -> (Ptr TypeFindFactory -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TypeFindFactory
obj (Ptr GValue -> Ptr TypeFindFactory -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TypeFindFactory)
gvalueGet_ Ptr GValue
gv = do
Ptr TypeFindFactory
ptr <- Ptr GValue -> IO (Ptr TypeFindFactory)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TypeFindFactory)
if Ptr TypeFindFactory
ptr Ptr TypeFindFactory -> Ptr TypeFindFactory -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TypeFindFactory
forall a. Ptr a
FP.nullPtr
then TypeFindFactory -> Maybe TypeFindFactory
forall a. a -> Maybe a
P.Just (TypeFindFactory -> Maybe TypeFindFactory)
-> IO TypeFindFactory -> IO (Maybe TypeFindFactory)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TypeFindFactory -> TypeFindFactory)
-> Ptr TypeFindFactory -> IO TypeFindFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TypeFindFactory -> TypeFindFactory
TypeFindFactory Ptr TypeFindFactory
ptr
else Maybe TypeFindFactory -> IO (Maybe TypeFindFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeFindFactory
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveTypeFindFactoryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTypeFindFactoryMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveTypeFindFactoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTypeFindFactoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTypeFindFactoryMethod "callFunction" o = TypeFindFactoryCallFunctionMethodInfo
ResolveTypeFindFactoryMethod "checkVersion" o = Gst.PluginFeature.PluginFeatureCheckVersionMethodInfo
ResolveTypeFindFactoryMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveTypeFindFactoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTypeFindFactoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTypeFindFactoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTypeFindFactoryMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveTypeFindFactoryMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveTypeFindFactoryMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveTypeFindFactoryMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveTypeFindFactoryMethod "hasFunction" o = TypeFindFactoryHasFunctionMethodInfo
ResolveTypeFindFactoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTypeFindFactoryMethod "load" o = Gst.PluginFeature.PluginFeatureLoadMethodInfo
ResolveTypeFindFactoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTypeFindFactoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTypeFindFactoryMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveTypeFindFactoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTypeFindFactoryMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveTypeFindFactoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTypeFindFactoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTypeFindFactoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTypeFindFactoryMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveTypeFindFactoryMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveTypeFindFactoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTypeFindFactoryMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveTypeFindFactoryMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveTypeFindFactoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTypeFindFactoryMethod "getCaps" o = TypeFindFactoryGetCapsMethodInfo
ResolveTypeFindFactoryMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveTypeFindFactoryMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveTypeFindFactoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTypeFindFactoryMethod "getExtensions" o = TypeFindFactoryGetExtensionsMethodInfo
ResolveTypeFindFactoryMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveTypeFindFactoryMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveTypeFindFactoryMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveTypeFindFactoryMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveTypeFindFactoryMethod "getPlugin" o = Gst.PluginFeature.PluginFeatureGetPluginMethodInfo
ResolveTypeFindFactoryMethod "getPluginName" o = Gst.PluginFeature.PluginFeatureGetPluginNameMethodInfo
ResolveTypeFindFactoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTypeFindFactoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTypeFindFactoryMethod "getRank" o = Gst.PluginFeature.PluginFeatureGetRankMethodInfo
ResolveTypeFindFactoryMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveTypeFindFactoryMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveTypeFindFactoryMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveTypeFindFactoryMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveTypeFindFactoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTypeFindFactoryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTypeFindFactoryMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveTypeFindFactoryMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveTypeFindFactoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTypeFindFactoryMethod "setRank" o = Gst.PluginFeature.PluginFeatureSetRankMethodInfo
ResolveTypeFindFactoryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTypeFindFactoryMethod t TypeFindFactory, O.OverloadedMethod info TypeFindFactory p) => OL.IsLabel t (TypeFindFactory -> 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 ~ ResolveTypeFindFactoryMethod t TypeFindFactory, O.OverloadedMethod info TypeFindFactory p, R.HasField t TypeFindFactory p) => R.HasField t TypeFindFactory p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTypeFindFactoryMethod t TypeFindFactory, O.OverloadedMethodInfo info TypeFindFactory) => OL.IsLabel t (O.MethodProxy info TypeFindFactory) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TypeFindFactory
type instance O.AttributeList TypeFindFactory = TypeFindFactoryAttributeList
type TypeFindFactoryAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TypeFindFactory = TypeFindFactorySignalList
type TypeFindFactorySignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gst_type_find_factory_call_function" gst_type_find_factory_call_function ::
Ptr TypeFindFactory ->
Ptr Gst.TypeFind.TypeFind ->
IO ()
typeFindFactoryCallFunction ::
(B.CallStack.HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a
-> Gst.TypeFind.TypeFind
-> m ()
typeFindFactoryCallFunction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a -> TypeFind -> m ()
typeFindFactoryCallFunction a
factory TypeFind
find = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeFindFactory
factory' <- a -> IO (Ptr TypeFindFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
Ptr TypeFind
find' <- TypeFind -> IO (Ptr TypeFind)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeFind
find
Ptr TypeFindFactory -> Ptr TypeFind -> IO ()
gst_type_find_factory_call_function Ptr TypeFindFactory
factory' Ptr TypeFind
find'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
factory
TypeFind -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeFind
find
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TypeFindFactoryCallFunctionMethodInfo
instance (signature ~ (Gst.TypeFind.TypeFind -> m ()), MonadIO m, IsTypeFindFactory a) => O.OverloadedMethod TypeFindFactoryCallFunctionMethodInfo a signature where
overloadedMethod = typeFindFactoryCallFunction
instance O.OverloadedMethodInfo TypeFindFactoryCallFunctionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.TypeFindFactory.typeFindFactoryCallFunction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Objects-TypeFindFactory.html#v:typeFindFactoryCallFunction"
})
#endif
foreign import ccall "gst_type_find_factory_get_caps" gst_type_find_factory_get_caps ::
Ptr TypeFindFactory ->
IO (Ptr Gst.Caps.Caps)
typeFindFactoryGetCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a
-> m (Maybe Gst.Caps.Caps)
typeFindFactoryGetCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a -> m (Maybe Caps)
typeFindFactoryGetCaps a
factory = IO (Maybe Caps) -> m (Maybe Caps)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeFindFactory
factory' <- a -> IO (Ptr TypeFindFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
Ptr Caps
result <- Ptr TypeFindFactory -> IO (Ptr Caps)
gst_type_find_factory_get_caps Ptr TypeFindFactory
factory'
Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
Caps -> IO Caps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
factory
Maybe Caps -> IO (Maybe Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult
#if defined(ENABLE_OVERLOADING)
data TypeFindFactoryGetCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsTypeFindFactory a) => O.OverloadedMethod TypeFindFactoryGetCapsMethodInfo a signature where
overloadedMethod = typeFindFactoryGetCaps
instance O.OverloadedMethodInfo TypeFindFactoryGetCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.TypeFindFactory.typeFindFactoryGetCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Objects-TypeFindFactory.html#v:typeFindFactoryGetCaps"
})
#endif
foreign import ccall "gst_type_find_factory_get_extensions" gst_type_find_factory_get_extensions ::
Ptr TypeFindFactory ->
IO (Ptr CString)
typeFindFactoryGetExtensions ::
(B.CallStack.HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a
-> m (Maybe [T.Text])
typeFindFactoryGetExtensions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a -> m (Maybe [Text])
typeFindFactoryGetExtensions a
factory = IO (Maybe [Text]) -> m (Maybe [Text])
forall a. IO a -> m a
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 TypeFindFactory
factory' <- a -> IO (Ptr TypeFindFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
Ptr CString
result <- Ptr TypeFindFactory -> IO (Ptr CString)
gst_type_find_factory_get_extensions Ptr TypeFindFactory
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'
[Text] -> IO [Text]
forall a. a -> IO a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult
#if defined(ENABLE_OVERLOADING)
data TypeFindFactoryGetExtensionsMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsTypeFindFactory a) => O.OverloadedMethod TypeFindFactoryGetExtensionsMethodInfo a signature where
overloadedMethod = typeFindFactoryGetExtensions
instance O.OverloadedMethodInfo TypeFindFactoryGetExtensionsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.TypeFindFactory.typeFindFactoryGetExtensions",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Objects-TypeFindFactory.html#v:typeFindFactoryGetExtensions"
})
#endif
foreign import ccall "gst_type_find_factory_has_function" gst_type_find_factory_has_function ::
Ptr TypeFindFactory ->
IO CInt
typeFindFactoryHasFunction ::
(B.CallStack.HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a
-> m Bool
typeFindFactoryHasFunction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTypeFindFactory a) =>
a -> m Bool
typeFindFactoryHasFunction a
factory = IO Bool -> m Bool
forall a. IO a -> m a
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 TypeFindFactory
factory' <- a -> IO (Ptr TypeFindFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
factory
CInt
result <- Ptr TypeFindFactory -> IO CInt
gst_type_find_factory_has_function Ptr TypeFindFactory
factory'
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
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TypeFindFactoryHasFunctionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTypeFindFactory a) => O.OverloadedMethod TypeFindFactoryHasFunctionMethodInfo a signature where
overloadedMethod = typeFindFactoryHasFunction
instance O.OverloadedMethodInfo TypeFindFactoryHasFunctionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.TypeFindFactory.typeFindFactoryHasFunction",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Objects-TypeFindFactory.html#v:typeFindFactoryHasFunction"
})
#endif
foreign import ccall "gst_type_find_factory_get_list" gst_type_find_factory_get_list ::
IO (Ptr (GList (Ptr TypeFindFactory)))
typeFindFactoryGetList ::
(B.CallStack.HasCallStack, MonadIO m) =>
m [TypeFindFactory]
typeFindFactoryGetList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m [TypeFindFactory]
typeFindFactoryGetList = IO [TypeFindFactory] -> m [TypeFindFactory]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TypeFindFactory] -> m [TypeFindFactory])
-> IO [TypeFindFactory] -> m [TypeFindFactory]
forall a b. (a -> b) -> a -> b
$ do
Ptr (GList (Ptr TypeFindFactory))
result <- IO (Ptr (GList (Ptr TypeFindFactory)))
gst_type_find_factory_get_list
[Ptr TypeFindFactory]
result' <- Ptr (GList (Ptr TypeFindFactory)) -> IO [Ptr TypeFindFactory]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr TypeFindFactory))
result
[TypeFindFactory]
result'' <- (Ptr TypeFindFactory -> IO TypeFindFactory)
-> [Ptr TypeFindFactory] -> IO [TypeFindFactory]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr TypeFindFactory -> TypeFindFactory)
-> Ptr TypeFindFactory -> IO TypeFindFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TypeFindFactory -> TypeFindFactory
TypeFindFactory) [Ptr TypeFindFactory]
result'
Ptr (GList (Ptr TypeFindFactory)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr TypeFindFactory))
result
[TypeFindFactory] -> IO [TypeFindFactory]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TypeFindFactory]
result''
#if defined(ENABLE_OVERLOADING)
#endif