{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.TocEntry
(
TocEntry(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveTocEntryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TocEntryAppendSubEntryMethodInfo ,
#endif
tocEntryAppendSubEntry ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetEntryTypeMethodInfo ,
#endif
tocEntryGetEntryType ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetLoopMethodInfo ,
#endif
tocEntryGetLoop ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetParentMethodInfo ,
#endif
tocEntryGetParent ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetStartStopTimesMethodInfo ,
#endif
tocEntryGetStartStopTimes ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetSubEntriesMethodInfo ,
#endif
tocEntryGetSubEntries ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetTagsMethodInfo ,
#endif
tocEntryGetTags ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetTocMethodInfo ,
#endif
tocEntryGetToc ,
#if defined(ENABLE_OVERLOADING)
TocEntryGetUidMethodInfo ,
#endif
tocEntryGetUid ,
#if defined(ENABLE_OVERLOADING)
TocEntryIsAlternativeMethodInfo ,
#endif
tocEntryIsAlternative ,
#if defined(ENABLE_OVERLOADING)
TocEntryIsSequenceMethodInfo ,
#endif
tocEntryIsSequence ,
#if defined(ENABLE_OVERLOADING)
TocEntryMergeTagsMethodInfo ,
#endif
tocEntryMergeTags ,
tocEntryNew ,
#if defined(ENABLE_OVERLOADING)
TocEntrySetLoopMethodInfo ,
#endif
tocEntrySetLoop ,
#if defined(ENABLE_OVERLOADING)
TocEntrySetStartStopTimesMethodInfo ,
#endif
tocEntrySetStartStopTimes ,
#if defined(ENABLE_OVERLOADING)
TocEntrySetTagsMethodInfo ,
#endif
tocEntrySetTags ,
) 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.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 {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Structs.TagList as Gst.TagList
import {-# SOURCE #-} qualified GI.Gst.Structs.Toc as Gst.Toc
newtype TocEntry = TocEntry (SP.ManagedPtr TocEntry)
deriving (TocEntry -> TocEntry -> Bool
(TocEntry -> TocEntry -> Bool)
-> (TocEntry -> TocEntry -> Bool) -> Eq TocEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TocEntry -> TocEntry -> Bool
$c/= :: TocEntry -> TocEntry -> Bool
== :: TocEntry -> TocEntry -> Bool
$c== :: TocEntry -> TocEntry -> Bool
Eq)
instance SP.ManagedPtrNewtype TocEntry where
toManagedPtr :: TocEntry -> ManagedPtr TocEntry
toManagedPtr (TocEntry ManagedPtr TocEntry
p) = ManagedPtr TocEntry
p
foreign import ccall "gst_toc_entry_get_type" c_gst_toc_entry_get_type ::
IO GType
type instance O.ParentTypes TocEntry = '[]
instance O.HasParentTypes TocEntry
instance B.Types.TypedObject TocEntry where
glibType :: IO GType
glibType = IO GType
c_gst_toc_entry_get_type
instance B.Types.GBoxed TocEntry
instance B.GValue.IsGValue TocEntry where
toGValue :: TocEntry -> IO GValue
toGValue TocEntry
o = do
GType
gtype <- IO GType
c_gst_toc_entry_get_type
TocEntry -> (Ptr TocEntry -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TocEntry
o (GType
-> (GValue -> Ptr TocEntry -> IO ()) -> Ptr TocEntry -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TocEntry -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO TocEntry
fromGValue GValue
gv = do
Ptr TocEntry
ptr <- GValue -> IO (Ptr TocEntry)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr TocEntry)
(ManagedPtr TocEntry -> TocEntry) -> Ptr TocEntry -> IO TocEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TocEntry -> TocEntry
TocEntry Ptr TocEntry
ptr
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TocEntry
type instance O.AttributeList TocEntry = TocEntryAttributeList
type TocEntryAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gst_toc_entry_new" gst_toc_entry_new ::
CInt ->
CString ->
IO (Ptr TocEntry)
tocEntryNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.TocEntryType
-> T.Text
-> m TocEntry
tocEntryNew :: TocEntryType -> Text -> m TocEntry
tocEntryNew TocEntryType
type_ Text
uid = IO TocEntry -> m TocEntry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TocEntry -> m TocEntry) -> IO TocEntry -> m TocEntry
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CInt
type_' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (TocEntryType -> Int) -> TocEntryType -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TocEntryType -> Int
forall a. Enum a => a -> Int
fromEnum) TocEntryType
type_
CString
uid' <- Text -> IO CString
textToCString Text
uid
Ptr TocEntry
result <- CInt -> CString -> IO (Ptr TocEntry)
gst_toc_entry_new CInt
type_' CString
uid'
Text -> Ptr TocEntry -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tocEntryNew" Ptr TocEntry
result
TocEntry
result' <- ((ManagedPtr TocEntry -> TocEntry) -> Ptr TocEntry -> IO TocEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TocEntry -> TocEntry
TocEntry) Ptr TocEntry
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uid'
TocEntry -> IO TocEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TocEntry
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_toc_entry_append_sub_entry" gst_toc_entry_append_sub_entry ::
Ptr TocEntry ->
Ptr TocEntry ->
IO ()
tocEntryAppendSubEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> TocEntry
-> m ()
tocEntryAppendSubEntry :: TocEntry -> TocEntry -> m ()
tocEntryAppendSubEntry TocEntry
entry TocEntry
subentry = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr TocEntry
subentry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TocEntry
subentry
Ptr TocEntry -> Ptr TocEntry -> IO ()
gst_toc_entry_append_sub_entry Ptr TocEntry
entry' Ptr TocEntry
subentry'
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
subentry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocEntryAppendSubEntryMethodInfo
instance (signature ~ (TocEntry -> m ()), MonadIO m) => O.MethodInfo TocEntryAppendSubEntryMethodInfo TocEntry signature where
overloadedMethod = tocEntryAppendSubEntry
#endif
foreign import ccall "gst_toc_entry_get_entry_type" gst_toc_entry_get_entry_type ::
Ptr TocEntry ->
IO CInt
tocEntryGetEntryType ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m Gst.Enums.TocEntryType
tocEntryGetEntryType :: TocEntry -> m TocEntryType
tocEntryGetEntryType TocEntry
entry = IO TocEntryType -> m TocEntryType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TocEntryType -> m TocEntryType)
-> IO TocEntryType -> m TocEntryType
forall a b. (a -> b) -> a -> b
$ do
Ptr TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
CInt
result <- Ptr TocEntry -> IO CInt
gst_toc_entry_get_entry_type Ptr TocEntry
entry'
let result' :: TocEntryType
result' = (Int -> TocEntryType
forall a. Enum a => Int -> a
toEnum (Int -> TocEntryType) -> (CInt -> Int) -> CInt -> TocEntryType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
TocEntryType -> IO TocEntryType
forall (m :: * -> *) a. Monad m => a -> m a
return TocEntryType
result'
#if defined(ENABLE_OVERLOADING)
data TocEntryGetEntryTypeMethodInfo
instance (signature ~ (m Gst.Enums.TocEntryType), MonadIO m) => O.MethodInfo TocEntryGetEntryTypeMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetEntryType
#endif
foreign import ccall "gst_toc_entry_get_loop" gst_toc_entry_get_loop ::
Ptr TocEntry ->
Ptr CUInt ->
Ptr Int32 ->
IO CInt
tocEntryGetLoop ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m ((Bool, Gst.Enums.TocLoopType, Int32))
tocEntryGetLoop :: TocEntry -> m (Bool, TocLoopType, Int32)
tocEntryGetLoop TocEntry
entry = IO (Bool, TocLoopType, Int32) -> m (Bool, TocLoopType, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, TocLoopType, Int32) -> m (Bool, TocLoopType, Int32))
-> IO (Bool, TocLoopType, Int32) -> m (Bool, TocLoopType, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr CUInt
loopType <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Int32
repeatCount <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr TocEntry -> Ptr CUInt -> Ptr Int32 -> IO CInt
gst_toc_entry_get_loop Ptr TocEntry
entry' Ptr CUInt
loopType Ptr Int32
repeatCount
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CUInt
loopType' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
loopType
let loopType'' :: TocLoopType
loopType'' = (Int -> TocLoopType
forall a. Enum a => Int -> a
toEnum (Int -> TocLoopType) -> (CUInt -> Int) -> CUInt -> TocLoopType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
loopType'
Int32
repeatCount' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
repeatCount
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
loopType
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
repeatCount
(Bool, TocLoopType, Int32) -> IO (Bool, TocLoopType, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', TocLoopType
loopType'', Int32
repeatCount')
#if defined(ENABLE_OVERLOADING)
data TocEntryGetLoopMethodInfo
instance (signature ~ (m ((Bool, Gst.Enums.TocLoopType, Int32))), MonadIO m) => O.MethodInfo TocEntryGetLoopMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetLoop
#endif
foreign import ccall "gst_toc_entry_get_parent" gst_toc_entry_get_parent ::
Ptr TocEntry ->
IO (Ptr TocEntry)
tocEntryGetParent ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m (Maybe TocEntry)
tocEntryGetParent :: TocEntry -> m (Maybe TocEntry)
tocEntryGetParent TocEntry
entry = IO (Maybe TocEntry) -> m (Maybe TocEntry)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TocEntry) -> m (Maybe TocEntry))
-> IO (Maybe TocEntry) -> m (Maybe TocEntry)
forall a b. (a -> b) -> a -> b
$ do
Ptr TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr TocEntry
result <- Ptr TocEntry -> IO (Ptr TocEntry)
gst_toc_entry_get_parent Ptr TocEntry
entry'
Maybe TocEntry
maybeResult <- Ptr TocEntry
-> (Ptr TocEntry -> IO TocEntry) -> IO (Maybe TocEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TocEntry
result ((Ptr TocEntry -> IO TocEntry) -> IO (Maybe TocEntry))
-> (Ptr TocEntry -> IO TocEntry) -> IO (Maybe TocEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr TocEntry
result' -> do
TocEntry
result'' <- ((ManagedPtr TocEntry -> TocEntry) -> Ptr TocEntry -> IO TocEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TocEntry -> TocEntry
TocEntry) Ptr TocEntry
result'
TocEntry -> IO TocEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TocEntry
result''
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Maybe TocEntry -> IO (Maybe TocEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TocEntry
maybeResult
#if defined(ENABLE_OVERLOADING)
data TocEntryGetParentMethodInfo
instance (signature ~ (m (Maybe TocEntry)), MonadIO m) => O.MethodInfo TocEntryGetParentMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetParent
#endif
foreign import ccall "gst_toc_entry_get_start_stop_times" gst_toc_entry_get_start_stop_times ::
Ptr TocEntry ->
Ptr Int64 ->
Ptr Int64 ->
IO CInt
tocEntryGetStartStopTimes ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m ((Bool, Int64, Int64))
tocEntryGetStartStopTimes :: TocEntry -> m (Bool, Int64, Int64)
tocEntryGetStartStopTimes TocEntry
entry = IO (Bool, Int64, Int64) -> m (Bool, Int64, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64, Int64) -> m (Bool, Int64, Int64))
-> IO (Bool, Int64, Int64) -> m (Bool, Int64, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr Int64
start <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Int64
stop <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr TocEntry -> Ptr Int64 -> Ptr Int64 -> IO CInt
gst_toc_entry_get_start_stop_times Ptr TocEntry
entry' Ptr Int64
start Ptr Int64
stop
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
start' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
start
Int64
stop' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
stop
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
start
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
stop
(Bool, Int64, Int64) -> IO (Bool, Int64, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
start', Int64
stop')
#if defined(ENABLE_OVERLOADING)
data TocEntryGetStartStopTimesMethodInfo
instance (signature ~ (m ((Bool, Int64, Int64))), MonadIO m) => O.MethodInfo TocEntryGetStartStopTimesMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetStartStopTimes
#endif
foreign import ccall "gst_toc_entry_get_sub_entries" gst_toc_entry_get_sub_entries ::
Ptr TocEntry ->
IO (Ptr (GList (Ptr TocEntry)))
tocEntryGetSubEntries ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m [TocEntry]
tocEntryGetSubEntries :: TocEntry -> m [TocEntry]
tocEntryGetSubEntries TocEntry
entry = IO [TocEntry] -> m [TocEntry]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TocEntry] -> m [TocEntry]) -> IO [TocEntry] -> m [TocEntry]
forall a b. (a -> b) -> a -> b
$ do
Ptr TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr (GList (Ptr TocEntry))
result <- Ptr TocEntry -> IO (Ptr (GList (Ptr TocEntry)))
gst_toc_entry_get_sub_entries Ptr TocEntry
entry'
[Ptr TocEntry]
result' <- Ptr (GList (Ptr TocEntry)) -> IO [Ptr TocEntry]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr TocEntry))
result
[TocEntry]
result'' <- (Ptr TocEntry -> IO TocEntry) -> [Ptr TocEntry] -> IO [TocEntry]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr TocEntry -> TocEntry) -> Ptr TocEntry -> IO TocEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TocEntry -> TocEntry
TocEntry) [Ptr TocEntry]
result'
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
[TocEntry] -> IO [TocEntry]
forall (m :: * -> *) a. Monad m => a -> m a
return [TocEntry]
result''
#if defined(ENABLE_OVERLOADING)
data TocEntryGetSubEntriesMethodInfo
instance (signature ~ (m [TocEntry]), MonadIO m) => O.MethodInfo TocEntryGetSubEntriesMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetSubEntries
#endif
foreign import ccall "gst_toc_entry_get_tags" gst_toc_entry_get_tags ::
Ptr TocEntry ->
IO (Ptr Gst.TagList.TagList)
tocEntryGetTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m Gst.TagList.TagList
tocEntryGetTags :: TocEntry -> m TagList
tocEntryGetTags TocEntry
entry = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr TagList
result <- Ptr TocEntry -> IO (Ptr TagList)
gst_toc_entry_get_tags Ptr TocEntry
entry'
Text -> Ptr TagList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tocEntryGetTags" 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
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
TagList -> IO TagList
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result'
#if defined(ENABLE_OVERLOADING)
data TocEntryGetTagsMethodInfo
instance (signature ~ (m Gst.TagList.TagList), MonadIO m) => O.MethodInfo TocEntryGetTagsMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetTags
#endif
foreign import ccall "gst_toc_entry_get_toc" gst_toc_entry_get_toc ::
Ptr TocEntry ->
IO (Ptr Gst.Toc.Toc)
tocEntryGetToc ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m Gst.Toc.Toc
tocEntryGetToc :: TocEntry -> m Toc
tocEntryGetToc TocEntry
entry = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr Toc
result <- Ptr TocEntry -> IO (Ptr Toc)
gst_toc_entry_get_toc Ptr TocEntry
entry'
Text -> Ptr Toc -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tocEntryGetToc" 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
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Toc -> IO Toc
forall (m :: * -> *) a. Monad m => a -> m a
return Toc
result'
#if defined(ENABLE_OVERLOADING)
data TocEntryGetTocMethodInfo
instance (signature ~ (m Gst.Toc.Toc), MonadIO m) => O.MethodInfo TocEntryGetTocMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetToc
#endif
foreign import ccall "gst_toc_entry_get_uid" gst_toc_entry_get_uid ::
Ptr TocEntry ->
IO CString
tocEntryGetUid ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m T.Text
tocEntryGetUid :: TocEntry -> m Text
tocEntryGetUid TocEntry
entry = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
CString
result <- Ptr TocEntry -> IO CString
gst_toc_entry_get_uid Ptr TocEntry
entry'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tocEntryGetUid" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data TocEntryGetUidMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo TocEntryGetUidMethodInfo TocEntry signature where
overloadedMethod = tocEntryGetUid
#endif
foreign import ccall "gst_toc_entry_is_alternative" gst_toc_entry_is_alternative ::
Ptr TocEntry ->
IO CInt
tocEntryIsAlternative ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m Bool
tocEntryIsAlternative :: TocEntry -> m Bool
tocEntryIsAlternative TocEntry
entry = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
CInt
result <- Ptr TocEntry -> IO CInt
gst_toc_entry_is_alternative Ptr TocEntry
entry'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TocEntryIsAlternativeMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo TocEntryIsAlternativeMethodInfo TocEntry signature where
overloadedMethod = tocEntryIsAlternative
#endif
foreign import ccall "gst_toc_entry_is_sequence" gst_toc_entry_is_sequence ::
Ptr TocEntry ->
IO CInt
tocEntryIsSequence ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> m Bool
tocEntryIsSequence :: TocEntry -> m Bool
tocEntryIsSequence TocEntry
entry = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
CInt
result <- Ptr TocEntry -> IO CInt
gst_toc_entry_is_sequence Ptr TocEntry
entry'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TocEntryIsSequenceMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo TocEntryIsSequenceMethodInfo TocEntry signature where
overloadedMethod = tocEntryIsSequence
#endif
foreign import ccall "gst_toc_entry_merge_tags" gst_toc_entry_merge_tags ::
Ptr TocEntry ->
Ptr Gst.TagList.TagList ->
CUInt ->
IO ()
tocEntryMergeTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> Maybe (Gst.TagList.TagList)
-> Gst.Enums.TagMergeMode
-> m ()
tocEntryMergeTags :: TocEntry -> Maybe TagList -> TagMergeMode -> m ()
tocEntryMergeTags TocEntry
entry Maybe TagList
tags TagMergeMode
mode = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr TagList
maybeTags <- case Maybe TagList
tags of
Maybe TagList
Nothing -> Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
forall a. Ptr a
nullPtr
Just TagList
jTags -> do
Ptr TagList
jTags' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
jTags
Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
jTags'
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TagMergeMode -> Int) -> TagMergeMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagMergeMode -> Int
forall a. Enum a => a -> Int
fromEnum) TagMergeMode
mode
Ptr TocEntry -> Ptr TagList -> CUInt -> IO ()
gst_toc_entry_merge_tags Ptr TocEntry
entry' Ptr TagList
maybeTags CUInt
mode'
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Maybe TagList -> (TagList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TagList
tags TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocEntryMergeTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> Gst.Enums.TagMergeMode -> m ()), MonadIO m) => O.MethodInfo TocEntryMergeTagsMethodInfo TocEntry signature where
overloadedMethod = tocEntryMergeTags
#endif
foreign import ccall "gst_toc_entry_set_loop" gst_toc_entry_set_loop ::
Ptr TocEntry ->
CUInt ->
Int32 ->
IO ()
tocEntrySetLoop ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> Gst.Enums.TocLoopType
-> Int32
-> m ()
tocEntrySetLoop :: TocEntry -> TocLoopType -> Int32 -> m ()
tocEntrySetLoop TocEntry
entry TocLoopType
loopType Int32
repeatCount = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
let loopType' :: CUInt
loopType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TocLoopType -> Int) -> TocLoopType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TocLoopType -> Int
forall a. Enum a => a -> Int
fromEnum) TocLoopType
loopType
Ptr TocEntry -> CUInt -> Int32 -> IO ()
gst_toc_entry_set_loop Ptr TocEntry
entry' CUInt
loopType' Int32
repeatCount
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocEntrySetLoopMethodInfo
instance (signature ~ (Gst.Enums.TocLoopType -> Int32 -> m ()), MonadIO m) => O.MethodInfo TocEntrySetLoopMethodInfo TocEntry signature where
overloadedMethod = tocEntrySetLoop
#endif
foreign import ccall "gst_toc_entry_set_start_stop_times" gst_toc_entry_set_start_stop_times ::
Ptr TocEntry ->
Int64 ->
Int64 ->
IO ()
tocEntrySetStartStopTimes ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> Int64
-> Int64
-> m ()
tocEntrySetStartStopTimes :: TocEntry -> Int64 -> Int64 -> m ()
tocEntrySetStartStopTimes TocEntry
entry Int64
start Int64
stop = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr TocEntry -> Int64 -> Int64 -> IO ()
gst_toc_entry_set_start_stop_times Ptr TocEntry
entry' Int64
start Int64
stop
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocEntrySetStartStopTimesMethodInfo
instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo TocEntrySetStartStopTimesMethodInfo TocEntry signature where
overloadedMethod = tocEntrySetStartStopTimes
#endif
foreign import ccall "gst_toc_entry_set_tags" gst_toc_entry_set_tags ::
Ptr TocEntry ->
Ptr Gst.TagList.TagList ->
IO ()
tocEntrySetTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
TocEntry
-> Maybe (Gst.TagList.TagList)
-> m ()
tocEntrySetTags :: TocEntry -> Maybe TagList -> m ()
tocEntrySetTags TocEntry
entry Maybe TagList
tags = 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 TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TocEntry
entry
Ptr TagList
maybeTags <- case Maybe TagList
tags of
Maybe TagList
Nothing -> Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
forall a. Ptr a
nullPtr
Just TagList
jTags -> do
Ptr TagList
jTags' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TagList
jTags
Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
jTags'
Ptr TocEntry -> Ptr TagList -> IO ()
gst_toc_entry_set_tags Ptr TocEntry
entry' Ptr TagList
maybeTags
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
Maybe TagList -> (TagList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TagList
tags TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocEntrySetTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> m ()), MonadIO m) => O.MethodInfo TocEntrySetTagsMethodInfo TocEntry signature where
overloadedMethod = tocEntrySetTags
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTocEntryMethod (t :: Symbol) (o :: *) :: * where
ResolveTocEntryMethod "appendSubEntry" o = TocEntryAppendSubEntryMethodInfo
ResolveTocEntryMethod "isAlternative" o = TocEntryIsAlternativeMethodInfo
ResolveTocEntryMethod "isSequence" o = TocEntryIsSequenceMethodInfo
ResolveTocEntryMethod "mergeTags" o = TocEntryMergeTagsMethodInfo
ResolveTocEntryMethod "getEntryType" o = TocEntryGetEntryTypeMethodInfo
ResolveTocEntryMethod "getLoop" o = TocEntryGetLoopMethodInfo
ResolveTocEntryMethod "getParent" o = TocEntryGetParentMethodInfo
ResolveTocEntryMethod "getStartStopTimes" o = TocEntryGetStartStopTimesMethodInfo
ResolveTocEntryMethod "getSubEntries" o = TocEntryGetSubEntriesMethodInfo
ResolveTocEntryMethod "getTags" o = TocEntryGetTagsMethodInfo
ResolveTocEntryMethod "getToc" o = TocEntryGetTocMethodInfo
ResolveTocEntryMethod "getUid" o = TocEntryGetUidMethodInfo
ResolveTocEntryMethod "setLoop" o = TocEntrySetLoopMethodInfo
ResolveTocEntryMethod "setStartStopTimes" o = TocEntrySetStartStopTimesMethodInfo
ResolveTocEntryMethod "setTags" o = TocEntrySetTagsMethodInfo
ResolveTocEntryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTocEntryMethod t TocEntry, O.MethodInfo info TocEntry p) => OL.IsLabel t (TocEntry -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif