{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstPbutils.Objects.DiscovererStreamInfo
(
DiscovererStreamInfo(..) ,
IsDiscovererStreamInfo ,
toDiscovererStreamInfo ,
#if defined(ENABLE_OVERLOADING)
ResolveDiscovererStreamInfoMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetCapsMethodInfo ,
#endif
discovererStreamInfoGetCaps ,
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetMiscMethodInfo ,
#endif
discovererStreamInfoGetMisc ,
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetNextMethodInfo ,
#endif
discovererStreamInfoGetNext ,
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetPreviousMethodInfo,
#endif
discovererStreamInfoGetPrevious ,
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetStreamIdMethodInfo,
#endif
discovererStreamInfoGetStreamId ,
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetStreamTypeNickMethodInfo,
#endif
discovererStreamInfoGetStreamTypeNick ,
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetTagsMethodInfo ,
#endif
discovererStreamInfoGetTags ,
#if defined(ENABLE_OVERLOADING)
DiscovererStreamInfoGetTocMethodInfo ,
#endif
discovererStreamInfoGetToc ,
discovererStreamInfoListFree ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Structs.Caps as Gst.Caps
import qualified GI.Gst.Structs.Structure as Gst.Structure
import qualified GI.Gst.Structs.TagList as Gst.TagList
import qualified GI.Gst.Structs.Toc as Gst.Toc
newtype DiscovererStreamInfo = DiscovererStreamInfo (SP.ManagedPtr DiscovererStreamInfo)
deriving (DiscovererStreamInfo -> DiscovererStreamInfo -> Bool
(DiscovererStreamInfo -> DiscovererStreamInfo -> Bool)
-> (DiscovererStreamInfo -> DiscovererStreamInfo -> Bool)
-> Eq DiscovererStreamInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiscovererStreamInfo -> DiscovererStreamInfo -> Bool
$c/= :: DiscovererStreamInfo -> DiscovererStreamInfo -> Bool
== :: DiscovererStreamInfo -> DiscovererStreamInfo -> Bool
$c== :: DiscovererStreamInfo -> DiscovererStreamInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype DiscovererStreamInfo where
toManagedPtr :: DiscovererStreamInfo -> ManagedPtr DiscovererStreamInfo
toManagedPtr (DiscovererStreamInfo ManagedPtr DiscovererStreamInfo
p) = ManagedPtr DiscovererStreamInfo
p
foreign import ccall "gst_discoverer_stream_info_get_type"
c_gst_discoverer_stream_info_get_type :: IO B.Types.GType
instance B.Types.TypedObject DiscovererStreamInfo where
glibType :: IO GType
glibType = IO GType
c_gst_discoverer_stream_info_get_type
instance B.Types.GObject DiscovererStreamInfo
class (SP.GObject o, O.IsDescendantOf DiscovererStreamInfo o) => IsDiscovererStreamInfo o
instance (SP.GObject o, O.IsDescendantOf DiscovererStreamInfo o) => IsDiscovererStreamInfo o
instance O.HasParentTypes DiscovererStreamInfo
type instance O.ParentTypes DiscovererStreamInfo = '[GObject.Object.Object]
toDiscovererStreamInfo :: (MIO.MonadIO m, IsDiscovererStreamInfo o) => o -> m DiscovererStreamInfo
toDiscovererStreamInfo :: forall (m :: * -> *) o.
(MonadIO m, IsDiscovererStreamInfo o) =>
o -> m DiscovererStreamInfo
toDiscovererStreamInfo = IO DiscovererStreamInfo -> m DiscovererStreamInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DiscovererStreamInfo -> m DiscovererStreamInfo)
-> (o -> IO DiscovererStreamInfo) -> o -> m DiscovererStreamInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo)
-> o -> IO DiscovererStreamInfo
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo
DiscovererStreamInfo
instance B.GValue.IsGValue (Maybe DiscovererStreamInfo) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_discoverer_stream_info_get_type
gvalueSet_ :: Ptr GValue -> Maybe DiscovererStreamInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DiscovererStreamInfo
P.Nothing = Ptr GValue -> Ptr DiscovererStreamInfo -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DiscovererStreamInfo
forall a. Ptr a
FP.nullPtr :: FP.Ptr DiscovererStreamInfo)
gvalueSet_ Ptr GValue
gv (P.Just DiscovererStreamInfo
obj) = DiscovererStreamInfo
-> (Ptr DiscovererStreamInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DiscovererStreamInfo
obj (Ptr GValue -> Ptr DiscovererStreamInfo -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DiscovererStreamInfo)
gvalueGet_ Ptr GValue
gv = do
Ptr DiscovererStreamInfo
ptr <- Ptr GValue -> IO (Ptr DiscovererStreamInfo)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DiscovererStreamInfo)
if Ptr DiscovererStreamInfo
ptr Ptr DiscovererStreamInfo -> Ptr DiscovererStreamInfo -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DiscovererStreamInfo
forall a. Ptr a
FP.nullPtr
then DiscovererStreamInfo -> Maybe DiscovererStreamInfo
forall a. a -> Maybe a
P.Just (DiscovererStreamInfo -> Maybe DiscovererStreamInfo)
-> IO DiscovererStreamInfo -> IO (Maybe DiscovererStreamInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo)
-> Ptr DiscovererStreamInfo -> IO DiscovererStreamInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo
DiscovererStreamInfo Ptr DiscovererStreamInfo
ptr
else Maybe DiscovererStreamInfo -> IO (Maybe DiscovererStreamInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiscovererStreamInfo
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDiscovererStreamInfoMethod (t :: Symbol) (o :: *) :: * where
ResolveDiscovererStreamInfoMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDiscovererStreamInfoMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDiscovererStreamInfoMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDiscovererStreamInfoMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDiscovererStreamInfoMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDiscovererStreamInfoMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDiscovererStreamInfoMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDiscovererStreamInfoMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDiscovererStreamInfoMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDiscovererStreamInfoMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDiscovererStreamInfoMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDiscovererStreamInfoMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDiscovererStreamInfoMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDiscovererStreamInfoMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDiscovererStreamInfoMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDiscovererStreamInfoMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDiscovererStreamInfoMethod "getCaps" o = DiscovererStreamInfoGetCapsMethodInfo
ResolveDiscovererStreamInfoMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDiscovererStreamInfoMethod "getMisc" o = DiscovererStreamInfoGetMiscMethodInfo
ResolveDiscovererStreamInfoMethod "getNext" o = DiscovererStreamInfoGetNextMethodInfo
ResolveDiscovererStreamInfoMethod "getPrevious" o = DiscovererStreamInfoGetPreviousMethodInfo
ResolveDiscovererStreamInfoMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDiscovererStreamInfoMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDiscovererStreamInfoMethod "getStreamId" o = DiscovererStreamInfoGetStreamIdMethodInfo
ResolveDiscovererStreamInfoMethod "getStreamTypeNick" o = DiscovererStreamInfoGetStreamTypeNickMethodInfo
ResolveDiscovererStreamInfoMethod "getTags" o = DiscovererStreamInfoGetTagsMethodInfo
ResolveDiscovererStreamInfoMethod "getToc" o = DiscovererStreamInfoGetTocMethodInfo
ResolveDiscovererStreamInfoMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDiscovererStreamInfoMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDiscovererStreamInfoMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDiscovererStreamInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDiscovererStreamInfoMethod t DiscovererStreamInfo, O.OverloadedMethod info DiscovererStreamInfo p) => OL.IsLabel t (DiscovererStreamInfo -> 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 ~ ResolveDiscovererStreamInfoMethod t DiscovererStreamInfo, O.OverloadedMethod info DiscovererStreamInfo p, R.HasField t DiscovererStreamInfo p) => R.HasField t DiscovererStreamInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDiscovererStreamInfoMethod t DiscovererStreamInfo, O.OverloadedMethodInfo info DiscovererStreamInfo) => OL.IsLabel t (O.MethodProxy info DiscovererStreamInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DiscovererStreamInfo
type instance O.AttributeList DiscovererStreamInfo = DiscovererStreamInfoAttributeList
type DiscovererStreamInfoAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DiscovererStreamInfo = DiscovererStreamInfoSignalList
type DiscovererStreamInfoSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_discoverer_stream_info_get_caps" gst_discoverer_stream_info_get_caps ::
Ptr DiscovererStreamInfo ->
IO (Ptr Gst.Caps.Caps)
discovererStreamInfoGetCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m Gst.Caps.Caps
discovererStreamInfoGetCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m Caps
discovererStreamInfoGetCaps a
info = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
Ptr Caps
result <- Ptr DiscovererStreamInfo -> IO (Ptr Caps)
gst_discoverer_stream_info_get_caps Ptr DiscovererStreamInfo
info'
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetCapsMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetCaps
instance O.OverloadedMethodInfo DiscovererStreamInfoGetCapsMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetCaps",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetCaps"
}
#endif
foreign import ccall "gst_discoverer_stream_info_get_misc" gst_discoverer_stream_info_get_misc ::
Ptr DiscovererStreamInfo ->
IO (Ptr Gst.Structure.Structure)
{-# DEPRECATED discovererStreamInfoGetMisc ["This functions is deprecated since version 1.4, use","@/gst_discoverer_info_get_missing_elements_installer_details/@"] #-}
discovererStreamInfoGetMisc ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m Gst.Structure.Structure
discovererStreamInfoGetMisc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m Structure
discovererStreamInfoGetMisc a
info = IO Structure -> m Structure
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Structure -> m Structure) -> IO Structure -> m Structure
forall a b. (a -> b) -> a -> b
$ do
Ptr DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
Ptr Structure
result <- Ptr DiscovererStreamInfo -> IO (Ptr Structure)
gst_discoverer_stream_info_get_misc Ptr DiscovererStreamInfo
info'
Text -> Ptr Structure -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetMisc" Ptr Structure
result
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
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetMiscMethodInfo
instance (signature ~ (m Gst.Structure.Structure), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetMiscMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetMisc
instance O.OverloadedMethodInfo DiscovererStreamInfoGetMiscMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetMisc",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetMisc"
}
#endif
foreign import ccall "gst_discoverer_stream_info_get_next" gst_discoverer_stream_info_get_next ::
Ptr DiscovererStreamInfo ->
IO (Ptr DiscovererStreamInfo)
discovererStreamInfoGetNext ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m DiscovererStreamInfo
discovererStreamInfoGetNext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m DiscovererStreamInfo
discovererStreamInfoGetNext a
info = IO DiscovererStreamInfo -> m DiscovererStreamInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiscovererStreamInfo -> m DiscovererStreamInfo)
-> IO DiscovererStreamInfo -> m DiscovererStreamInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
Ptr DiscovererStreamInfo
result <- Ptr DiscovererStreamInfo -> IO (Ptr DiscovererStreamInfo)
gst_discoverer_stream_info_get_next Ptr DiscovererStreamInfo
info'
Text -> Ptr DiscovererStreamInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetNext" Ptr DiscovererStreamInfo
result
DiscovererStreamInfo
result' <- ((ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo)
-> Ptr DiscovererStreamInfo -> IO DiscovererStreamInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo
DiscovererStreamInfo) Ptr DiscovererStreamInfo
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
DiscovererStreamInfo -> IO DiscovererStreamInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DiscovererStreamInfo
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetNextMethodInfo
instance (signature ~ (m DiscovererStreamInfo), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetNextMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetNext
instance O.OverloadedMethodInfo DiscovererStreamInfoGetNextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetNext",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetNext"
}
#endif
foreign import ccall "gst_discoverer_stream_info_get_previous" gst_discoverer_stream_info_get_previous ::
Ptr DiscovererStreamInfo ->
IO (Ptr DiscovererStreamInfo)
discovererStreamInfoGetPrevious ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m DiscovererStreamInfo
discovererStreamInfoGetPrevious :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m DiscovererStreamInfo
discovererStreamInfoGetPrevious a
info = IO DiscovererStreamInfo -> m DiscovererStreamInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiscovererStreamInfo -> m DiscovererStreamInfo)
-> IO DiscovererStreamInfo -> m DiscovererStreamInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
Ptr DiscovererStreamInfo
result <- Ptr DiscovererStreamInfo -> IO (Ptr DiscovererStreamInfo)
gst_discoverer_stream_info_get_previous Ptr DiscovererStreamInfo
info'
Text -> Ptr DiscovererStreamInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetPrevious" Ptr DiscovererStreamInfo
result
DiscovererStreamInfo
result' <- ((ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo)
-> Ptr DiscovererStreamInfo -> IO DiscovererStreamInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DiscovererStreamInfo -> DiscovererStreamInfo
DiscovererStreamInfo) Ptr DiscovererStreamInfo
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
DiscovererStreamInfo -> IO DiscovererStreamInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DiscovererStreamInfo
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetPreviousMethodInfo
instance (signature ~ (m DiscovererStreamInfo), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetPreviousMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetPrevious
instance O.OverloadedMethodInfo DiscovererStreamInfoGetPreviousMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetPrevious",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetPrevious"
}
#endif
foreign import ccall "gst_discoverer_stream_info_get_stream_id" gst_discoverer_stream_info_get_stream_id ::
Ptr DiscovererStreamInfo ->
IO CString
discovererStreamInfoGetStreamId ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m T.Text
discovererStreamInfoGetStreamId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m Text
discovererStreamInfoGetStreamId a
info = 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 DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
CString
result <- Ptr DiscovererStreamInfo -> IO CString
gst_discoverer_stream_info_get_stream_id Ptr DiscovererStreamInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetStreamId" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetStreamIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetStreamIdMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetStreamId
instance O.OverloadedMethodInfo DiscovererStreamInfoGetStreamIdMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetStreamId",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetStreamId"
}
#endif
foreign import ccall "gst_discoverer_stream_info_get_stream_type_nick" gst_discoverer_stream_info_get_stream_type_nick ::
Ptr DiscovererStreamInfo ->
IO CString
discovererStreamInfoGetStreamTypeNick ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m T.Text
discovererStreamInfoGetStreamTypeNick :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m Text
discovererStreamInfoGetStreamTypeNick a
info = 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 DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
CString
result <- Ptr DiscovererStreamInfo -> IO CString
gst_discoverer_stream_info_get_stream_type_nick Ptr DiscovererStreamInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetStreamTypeNick" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetStreamTypeNickMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetStreamTypeNickMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetStreamTypeNick
instance O.OverloadedMethodInfo DiscovererStreamInfoGetStreamTypeNickMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetStreamTypeNick",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetStreamTypeNick"
}
#endif
foreign import ccall "gst_discoverer_stream_info_get_tags" gst_discoverer_stream_info_get_tags ::
Ptr DiscovererStreamInfo ->
IO (Ptr Gst.TagList.TagList)
discovererStreamInfoGetTags ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m Gst.TagList.TagList
discovererStreamInfoGetTags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m TagList
discovererStreamInfoGetTags a
info = IO TagList -> m TagList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TagList -> m TagList) -> IO TagList -> m TagList
forall a b. (a -> b) -> a -> b
$ do
Ptr DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
Ptr TagList
result <- Ptr DiscovererStreamInfo -> IO (Ptr TagList)
gst_discoverer_stream_info_get_tags Ptr DiscovererStreamInfo
info'
Text -> Ptr TagList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetTags" Ptr TagList
result
TagList
result' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
TagList -> IO TagList
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetTagsMethodInfo
instance (signature ~ (m Gst.TagList.TagList), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetTagsMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetTags
instance O.OverloadedMethodInfo DiscovererStreamInfoGetTagsMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetTags",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetTags"
}
#endif
foreign import ccall "gst_discoverer_stream_info_get_toc" gst_discoverer_stream_info_get_toc ::
Ptr DiscovererStreamInfo ->
IO (Ptr Gst.Toc.Toc)
discovererStreamInfoGetToc ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a
-> m Gst.Toc.Toc
discovererStreamInfoGetToc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
a -> m Toc
discovererStreamInfoGetToc a
info = IO Toc -> m Toc
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Toc -> m Toc) -> IO Toc -> m Toc
forall a b. (a -> b) -> a -> b
$ do
Ptr DiscovererStreamInfo
info' <- a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
info
Ptr Toc
result <- Ptr DiscovererStreamInfo -> IO (Ptr Toc)
gst_discoverer_stream_info_get_toc Ptr DiscovererStreamInfo
info'
Text -> Ptr Toc -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererStreamInfoGetToc" Ptr Toc
result
Toc
result' <- ((ManagedPtr Toc -> Toc) -> Ptr Toc -> IO Toc
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Toc -> Toc
Gst.Toc.Toc) Ptr Toc
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
info
Toc -> IO Toc
forall (m :: * -> *) a. Monad m => a -> m a
return Toc
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererStreamInfoGetTocMethodInfo
instance (signature ~ (m Gst.Toc.Toc), MonadIO m, IsDiscovererStreamInfo a) => O.OverloadedMethod DiscovererStreamInfoGetTocMethodInfo a signature where
overloadedMethod = discovererStreamInfoGetToc
instance O.OverloadedMethodInfo DiscovererStreamInfoGetTocMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoGetToc",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-DiscovererStreamInfo.html#v:discovererStreamInfoGetToc"
}
#endif
foreign import ccall "gst_discoverer_stream_info_list_free" gst_discoverer_stream_info_list_free ::
Ptr (GList (Ptr DiscovererStreamInfo)) ->
IO ()
discovererStreamInfoListFree ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
[a]
-> m ()
discovererStreamInfoListFree :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererStreamInfo a) =>
[a] -> m ()
discovererStreamInfoListFree [a]
infos = 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 DiscovererStreamInfo]
infos' <- (a -> IO (Ptr DiscovererStreamInfo))
-> [a] -> IO [Ptr DiscovererStreamInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM a -> IO (Ptr DiscovererStreamInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [a]
infos
Ptr (GList (Ptr DiscovererStreamInfo))
infos'' <- [Ptr DiscovererStreamInfo]
-> IO (Ptr (GList (Ptr DiscovererStreamInfo)))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr DiscovererStreamInfo]
infos'
Ptr (GList (Ptr DiscovererStreamInfo)) -> IO ()
gst_discoverer_stream_info_list_free Ptr (GList (Ptr DiscovererStreamInfo))
infos''
(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]
infos
Ptr (GList (Ptr DiscovererStreamInfo)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr DiscovererStreamInfo))
infos''
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif