{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.Toc
(
Toc(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveTocMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TocAppendEntryMethodInfo ,
#endif
tocAppendEntry ,
#if defined(ENABLE_OVERLOADING)
TocDumpMethodInfo ,
#endif
tocDump ,
#if defined(ENABLE_OVERLOADING)
TocFindEntryMethodInfo ,
#endif
tocFindEntry ,
#if defined(ENABLE_OVERLOADING)
TocGetEntriesMethodInfo ,
#endif
tocGetEntries ,
#if defined(ENABLE_OVERLOADING)
TocGetScopeMethodInfo ,
#endif
tocGetScope ,
#if defined(ENABLE_OVERLOADING)
TocGetTagsMethodInfo ,
#endif
tocGetTags ,
#if defined(ENABLE_OVERLOADING)
TocMergeTagsMethodInfo ,
#endif
tocMergeTags ,
tocNew ,
#if defined(ENABLE_OVERLOADING)
TocSetTagsMethodInfo ,
#endif
tocSetTags ,
) 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.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 {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Structs.TagList as Gst.TagList
import {-# SOURCE #-} qualified GI.Gst.Structs.TocEntry as Gst.TocEntry
newtype Toc = Toc (SP.ManagedPtr Toc)
deriving (Toc -> Toc -> Bool
(Toc -> Toc -> Bool) -> (Toc -> Toc -> Bool) -> Eq Toc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Toc -> Toc -> Bool
== :: Toc -> Toc -> Bool
$c/= :: Toc -> Toc -> Bool
/= :: Toc -> Toc -> Bool
Eq)
instance SP.ManagedPtrNewtype Toc where
toManagedPtr :: Toc -> ManagedPtr Toc
toManagedPtr (Toc ManagedPtr Toc
p) = ManagedPtr Toc
p
foreign import ccall "gst_toc_get_type" c_gst_toc_get_type ::
IO GType
type instance O.ParentTypes Toc = '[]
instance O.HasParentTypes Toc
instance B.Types.TypedObject Toc where
glibType :: IO GType
glibType = IO GType
c_gst_toc_get_type
instance B.Types.GBoxed Toc
instance B.GValue.IsGValue (Maybe Toc) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_toc_get_type
gvalueSet_ :: Ptr GValue -> Maybe Toc -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Toc
P.Nothing = Ptr GValue -> Ptr Toc -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Toc
forall a. Ptr a
FP.nullPtr :: FP.Ptr Toc)
gvalueSet_ Ptr GValue
gv (P.Just Toc
obj) = Toc -> (Ptr Toc -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Toc
obj (Ptr GValue -> Ptr Toc -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Toc)
gvalueGet_ Ptr GValue
gv = do
Ptr Toc
ptr <- Ptr GValue -> IO (Ptr Toc)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Toc)
if Ptr Toc
ptr Ptr Toc -> Ptr Toc -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Toc
forall a. Ptr a
FP.nullPtr
then Toc -> Maybe Toc
forall a. a -> Maybe a
P.Just (Toc -> Maybe Toc) -> IO Toc -> IO (Maybe Toc)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Toc -> Toc) -> Ptr Toc -> IO Toc
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Toc -> Toc
Toc Ptr Toc
ptr
else Maybe Toc -> IO (Maybe Toc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Toc
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Toc
type instance O.AttributeList Toc = TocAttributeList
type TocAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gst_toc_new" gst_toc_new ::
CUInt ->
IO (Ptr Toc)
tocNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.TocScope
-> m Toc
tocNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TocScope -> m Toc
tocNew TocScope
scope = IO Toc -> m Toc
forall a. IO a -> m a
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
let scope' :: CUInt
scope' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TocScope -> Int) -> TocScope -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TocScope -> Int
forall a. Enum a => a -> Int
fromEnum) TocScope
scope
Ptr Toc
result <- CUInt -> IO (Ptr Toc)
gst_toc_new CUInt
scope'
Text -> Ptr Toc -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tocNew" Ptr Toc
result
Toc
result' <- ((ManagedPtr Toc -> Toc) -> Ptr Toc -> IO Toc
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Toc -> Toc
Toc) Ptr Toc
result
Toc -> IO Toc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Toc
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_toc_append_entry" gst_toc_append_entry ::
Ptr Toc ->
Ptr Gst.TocEntry.TocEntry ->
IO ()
tocAppendEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> Gst.TocEntry.TocEntry
-> m ()
tocAppendEntry :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Toc -> TocEntry -> m ()
tocAppendEntry Toc
toc TocEntry
entry = 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 Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
Ptr TocEntry
entry' <- TocEntry -> IO (Ptr TocEntry)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TocEntry
entry
Ptr Toc -> Ptr TocEntry -> IO ()
gst_toc_append_entry Ptr Toc
toc' Ptr TocEntry
entry'
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
TocEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TocEntry
entry
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocAppendEntryMethodInfo
instance (signature ~ (Gst.TocEntry.TocEntry -> m ()), MonadIO m) => O.OverloadedMethod TocAppendEntryMethodInfo Toc signature where
overloadedMethod = tocAppendEntry
instance O.OverloadedMethodInfo TocAppendEntryMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocAppendEntry",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocAppendEntry"
})
#endif
foreign import ccall "gst_toc_dump" gst_toc_dump ::
Ptr Toc ->
IO ()
tocDump ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> m ()
tocDump :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Toc -> m ()
tocDump Toc
toc = 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 Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
Ptr Toc -> IO ()
gst_toc_dump Ptr Toc
toc'
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocDumpMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TocDumpMethodInfo Toc signature where
overloadedMethod = tocDump
instance O.OverloadedMethodInfo TocDumpMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocDump",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocDump"
})
#endif
foreign import ccall "gst_toc_find_entry" gst_toc_find_entry ::
Ptr Toc ->
CString ->
IO (Ptr Gst.TocEntry.TocEntry)
tocFindEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> T.Text
-> m (Maybe Gst.TocEntry.TocEntry)
tocFindEntry :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Toc -> Text -> m (Maybe TocEntry)
tocFindEntry Toc
toc Text
uid = IO (Maybe TocEntry) -> m (Maybe TocEntry)
forall a. IO a -> m a
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 Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
CString
uid' <- Text -> IO CString
textToCString Text
uid
Ptr TocEntry
result <- Ptr Toc -> CString -> IO (Ptr TocEntry)
gst_toc_find_entry Ptr Toc
toc' CString
uid'
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
Gst.TocEntry.TocEntry) Ptr TocEntry
result'
TocEntry -> IO TocEntry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TocEntry
result''
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uid'
Maybe TocEntry -> IO (Maybe TocEntry)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TocEntry
maybeResult
#if defined(ENABLE_OVERLOADING)
data TocFindEntryMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.TocEntry.TocEntry)), MonadIO m) => O.OverloadedMethod TocFindEntryMethodInfo Toc signature where
overloadedMethod = tocFindEntry
instance O.OverloadedMethodInfo TocFindEntryMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocFindEntry",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocFindEntry"
})
#endif
foreign import ccall "gst_toc_get_entries" gst_toc_get_entries ::
Ptr Toc ->
IO (Ptr (GList (Ptr Gst.TocEntry.TocEntry)))
tocGetEntries ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> m [Gst.TocEntry.TocEntry]
tocGetEntries :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Toc -> m [TocEntry]
tocGetEntries Toc
toc = IO [TocEntry] -> m [TocEntry]
forall a. IO a -> m a
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 Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
Ptr (GList (Ptr TocEntry))
result <- Ptr Toc -> IO (Ptr (GList (Ptr TocEntry)))
gst_toc_get_entries Ptr Toc
toc'
[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)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [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
Gst.TocEntry.TocEntry) [Ptr TocEntry]
result'
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
[TocEntry] -> IO [TocEntry]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TocEntry]
result''
#if defined(ENABLE_OVERLOADING)
data TocGetEntriesMethodInfo
instance (signature ~ (m [Gst.TocEntry.TocEntry]), MonadIO m) => O.OverloadedMethod TocGetEntriesMethodInfo Toc signature where
overloadedMethod = tocGetEntries
instance O.OverloadedMethodInfo TocGetEntriesMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocGetEntries",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocGetEntries"
})
#endif
foreign import ccall "gst_toc_get_scope" gst_toc_get_scope ::
Ptr Toc ->
IO CUInt
tocGetScope ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> m Gst.Enums.TocScope
tocGetScope :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Toc -> m TocScope
tocGetScope Toc
toc = IO TocScope -> m TocScope
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TocScope -> m TocScope) -> IO TocScope -> m TocScope
forall a b. (a -> b) -> a -> b
$ do
Ptr Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
CUInt
result <- Ptr Toc -> IO CUInt
gst_toc_get_scope Ptr Toc
toc'
let result' :: TocScope
result' = (Int -> TocScope
forall a. Enum a => Int -> a
toEnum (Int -> TocScope) -> (CUInt -> Int) -> CUInt -> TocScope
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
TocScope -> IO TocScope
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TocScope
result'
#if defined(ENABLE_OVERLOADING)
data TocGetScopeMethodInfo
instance (signature ~ (m Gst.Enums.TocScope), MonadIO m) => O.OverloadedMethod TocGetScopeMethodInfo Toc signature where
overloadedMethod = tocGetScope
instance O.OverloadedMethodInfo TocGetScopeMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocGetScope",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocGetScope"
})
#endif
foreign import ccall "gst_toc_get_tags" gst_toc_get_tags ::
Ptr Toc ->
IO (Ptr Gst.TagList.TagList)
tocGetTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> m Gst.TagList.TagList
tocGetTags :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Toc -> m TagList
tocGetTags Toc
toc = IO TagList -> m TagList
forall a. IO a -> m a
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 Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
Ptr TagList
result <- Ptr Toc -> IO (Ptr TagList)
gst_toc_get_tags Ptr Toc
toc'
Text -> Ptr TagList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tocGetTags" 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
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result'
#if defined(ENABLE_OVERLOADING)
data TocGetTagsMethodInfo
instance (signature ~ (m Gst.TagList.TagList), MonadIO m) => O.OverloadedMethod TocGetTagsMethodInfo Toc signature where
overloadedMethod = tocGetTags
instance O.OverloadedMethodInfo TocGetTagsMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocGetTags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocGetTags"
})
#endif
foreign import ccall "gst_toc_merge_tags" gst_toc_merge_tags ::
Ptr Toc ->
Ptr Gst.TagList.TagList ->
CUInt ->
IO ()
tocMergeTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> Maybe (Gst.TagList.TagList)
-> Gst.Enums.TagMergeMode
-> m ()
tocMergeTags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Toc -> Maybe TagList -> TagMergeMode -> m ()
tocMergeTags Toc
toc Maybe TagList
tags TagMergeMode
mode = 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 Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
Ptr TagList
maybeTags <- case Maybe TagList
tags of
Maybe TagList
Nothing -> Ptr TagList -> IO (Ptr TagList)
forall a. a -> IO a
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 a. a -> IO a
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 Toc -> Ptr TagList -> CUInt -> IO ()
gst_toc_merge_tags Ptr Toc
toc' Ptr TagList
maybeTags CUInt
mode'
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocMergeTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> Gst.Enums.TagMergeMode -> m ()), MonadIO m) => O.OverloadedMethod TocMergeTagsMethodInfo Toc signature where
overloadedMethod = tocMergeTags
instance O.OverloadedMethodInfo TocMergeTagsMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocMergeTags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocMergeTags"
})
#endif
foreign import ccall "gst_toc_set_tags" gst_toc_set_tags ::
Ptr Toc ->
Ptr Gst.TagList.TagList ->
IO ()
tocSetTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Toc
-> Maybe (Gst.TagList.TagList)
-> m ()
tocSetTags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Toc -> Maybe TagList -> m ()
tocSetTags Toc
toc Maybe TagList
tags = 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 Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
Ptr TagList
maybeTags <- case Maybe TagList
tags of
Maybe TagList
Nothing -> Ptr TagList -> IO (Ptr TagList)
forall a. a -> IO a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
jTags'
Ptr Toc -> Ptr TagList -> IO ()
gst_toc_set_tags Ptr Toc
toc' Ptr TagList
maybeTags
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TocSetTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> m ()), MonadIO m) => O.OverloadedMethod TocSetTagsMethodInfo Toc signature where
overloadedMethod = tocSetTags
instance O.OverloadedMethodInfo TocSetTagsMethodInfo Toc where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Toc.tocSetTags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-Toc.html#v:tocSetTags"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTocMethod (t :: Symbol) (o :: *) :: * where
ResolveTocMethod "appendEntry" o = TocAppendEntryMethodInfo
ResolveTocMethod "dump" o = TocDumpMethodInfo
ResolveTocMethod "findEntry" o = TocFindEntryMethodInfo
ResolveTocMethod "mergeTags" o = TocMergeTagsMethodInfo
ResolveTocMethod "getEntries" o = TocGetEntriesMethodInfo
ResolveTocMethod "getScope" o = TocGetScopeMethodInfo
ResolveTocMethod "getTags" o = TocGetTagsMethodInfo
ResolveTocMethod "setTags" o = TocSetTagsMethodInfo
ResolveTocMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTocMethod t Toc, O.OverloadedMethod info Toc p) => OL.IsLabel t (Toc -> 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 ~ ResolveTocMethod t Toc, O.OverloadedMethod info Toc p, R.HasField t Toc p) => R.HasField t Toc p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTocMethod t Toc, O.OverloadedMethodInfo info Toc) => OL.IsLabel t (O.MethodProxy info Toc) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif