{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.TagList
(
TagList(..) ,
newZeroTagList ,
#if defined(ENABLE_OVERLOADING)
ResolveTagListMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TagListAddValueMethodInfo ,
#endif
tagListAddValue ,
#if defined(ENABLE_OVERLOADING)
TagListCopyMethodInfo ,
#endif
tagListCopy ,
tagListCopyValue ,
#if defined(ENABLE_OVERLOADING)
TagListForeachMethodInfo ,
#endif
tagListForeach ,
#if defined(ENABLE_OVERLOADING)
TagListGetBooleanMethodInfo ,
#endif
tagListGetBoolean ,
#if defined(ENABLE_OVERLOADING)
TagListGetBooleanIndexMethodInfo ,
#endif
tagListGetBooleanIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetDateMethodInfo ,
#endif
tagListGetDate ,
#if defined(ENABLE_OVERLOADING)
TagListGetDateIndexMethodInfo ,
#endif
tagListGetDateIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetDateTimeMethodInfo ,
#endif
tagListGetDateTime ,
#if defined(ENABLE_OVERLOADING)
TagListGetDateTimeIndexMethodInfo ,
#endif
tagListGetDateTimeIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetDoubleMethodInfo ,
#endif
tagListGetDouble ,
#if defined(ENABLE_OVERLOADING)
TagListGetDoubleIndexMethodInfo ,
#endif
tagListGetDoubleIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetFloatMethodInfo ,
#endif
tagListGetFloat ,
#if defined(ENABLE_OVERLOADING)
TagListGetFloatIndexMethodInfo ,
#endif
tagListGetFloatIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetIntMethodInfo ,
#endif
tagListGetInt ,
#if defined(ENABLE_OVERLOADING)
TagListGetInt64MethodInfo ,
#endif
tagListGetInt64 ,
#if defined(ENABLE_OVERLOADING)
TagListGetInt64IndexMethodInfo ,
#endif
tagListGetInt64Index ,
#if defined(ENABLE_OVERLOADING)
TagListGetIntIndexMethodInfo ,
#endif
tagListGetIntIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetPointerMethodInfo ,
#endif
tagListGetPointer ,
#if defined(ENABLE_OVERLOADING)
TagListGetPointerIndexMethodInfo ,
#endif
tagListGetPointerIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetSampleMethodInfo ,
#endif
tagListGetSample ,
#if defined(ENABLE_OVERLOADING)
TagListGetSampleIndexMethodInfo ,
#endif
tagListGetSampleIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetScopeMethodInfo ,
#endif
tagListGetScope ,
#if defined(ENABLE_OVERLOADING)
TagListGetStringMethodInfo ,
#endif
tagListGetString ,
#if defined(ENABLE_OVERLOADING)
TagListGetStringIndexMethodInfo ,
#endif
tagListGetStringIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetTagSizeMethodInfo ,
#endif
tagListGetTagSize ,
#if defined(ENABLE_OVERLOADING)
TagListGetUintMethodInfo ,
#endif
tagListGetUint ,
#if defined(ENABLE_OVERLOADING)
TagListGetUint64MethodInfo ,
#endif
tagListGetUint64 ,
#if defined(ENABLE_OVERLOADING)
TagListGetUint64IndexMethodInfo ,
#endif
tagListGetUint64Index ,
#if defined(ENABLE_OVERLOADING)
TagListGetUintIndexMethodInfo ,
#endif
tagListGetUintIndex ,
#if defined(ENABLE_OVERLOADING)
TagListGetValueIndexMethodInfo ,
#endif
tagListGetValueIndex ,
#if defined(ENABLE_OVERLOADING)
TagListInsertMethodInfo ,
#endif
tagListInsert ,
#if defined(ENABLE_OVERLOADING)
TagListIsEmptyMethodInfo ,
#endif
tagListIsEmpty ,
#if defined(ENABLE_OVERLOADING)
TagListIsEqualMethodInfo ,
#endif
tagListIsEqual ,
#if defined(ENABLE_OVERLOADING)
TagListMergeMethodInfo ,
#endif
tagListMerge ,
#if defined(ENABLE_OVERLOADING)
TagListNTagsMethodInfo ,
#endif
tagListNTags ,
tagListNewEmpty ,
tagListNewFromString ,
#if defined(ENABLE_OVERLOADING)
TagListNthTagNameMethodInfo ,
#endif
tagListNthTagName ,
#if defined(ENABLE_OVERLOADING)
TagListPeekStringIndexMethodInfo ,
#endif
tagListPeekStringIndex ,
#if defined(ENABLE_OVERLOADING)
TagListRemoveTagMethodInfo ,
#endif
tagListRemoveTag ,
#if defined(ENABLE_OVERLOADING)
TagListSetScopeMethodInfo ,
#endif
tagListSetScope ,
#if defined(ENABLE_OVERLOADING)
TagListToStringMethodInfo ,
#endif
tagListToString ,
getTagListMiniObject ,
#if defined(ENABLE_OVERLOADING)
tagList_miniObject ,
#endif
) 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 qualified GI.GLib.Structs.Date as GLib.Date
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Structs.DateTime as Gst.DateTime
import {-# SOURCE #-} qualified GI.Gst.Structs.MiniObject as Gst.MiniObject
import {-# SOURCE #-} qualified GI.Gst.Structs.Sample as Gst.Sample
newtype TagList = TagList (SP.ManagedPtr TagList)
deriving (TagList -> TagList -> Bool
(TagList -> TagList -> Bool)
-> (TagList -> TagList -> Bool) -> Eq TagList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TagList -> TagList -> Bool
== :: TagList -> TagList -> Bool
$c/= :: TagList -> TagList -> Bool
/= :: TagList -> TagList -> Bool
Eq)
instance SP.ManagedPtrNewtype TagList where
toManagedPtr :: TagList -> ManagedPtr TagList
toManagedPtr (TagList ManagedPtr TagList
p) = ManagedPtr TagList
p
foreign import ccall "gst_tag_list_get_type" c_gst_tag_list_get_type ::
IO GType
type instance O.ParentTypes TagList = '[]
instance O.HasParentTypes TagList
instance B.Types.TypedObject TagList where
glibType :: IO GType
glibType = IO GType
c_gst_tag_list_get_type
instance B.Types.GBoxed TagList
instance B.GValue.IsGValue (Maybe TagList) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_tag_list_get_type
gvalueSet_ :: Ptr GValue -> Maybe TagList -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TagList
P.Nothing = Ptr GValue -> Ptr TagList -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr TagList
forall a. Ptr a
FP.nullPtr :: FP.Ptr TagList)
gvalueSet_ Ptr GValue
gv (P.Just TagList
obj) = TagList -> (Ptr TagList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TagList
obj (Ptr GValue -> Ptr TagList -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TagList)
gvalueGet_ Ptr GValue
gv = do
Ptr TagList
ptr <- Ptr GValue -> IO (Ptr TagList)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr TagList)
if Ptr TagList
ptr Ptr TagList -> Ptr TagList -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TagList
forall a. Ptr a
FP.nullPtr
then TagList -> Maybe TagList
forall a. a -> Maybe a
P.Just (TagList -> Maybe TagList) -> IO TagList -> IO (Maybe TagList)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TagList -> TagList
TagList Ptr TagList
ptr
else Maybe TagList -> IO (Maybe TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
forall a. Maybe a
P.Nothing
newZeroTagList :: MonadIO m => m TagList
newZeroTagList :: forall (m :: * -> *). MonadIO m => m TagList
newZeroTagList = 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
$ Int -> IO (Ptr TagList)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
64 IO (Ptr TagList) -> (Ptr TagList -> IO TagList) -> IO TagList
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
TagList
instance tag ~ 'AttrSet => Constructible TagList tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr TagList -> TagList)
-> [AttrOp TagList tag] -> m TagList
new ManagedPtr TagList -> TagList
_ [AttrOp TagList tag]
attrs = do
TagList
o <- m TagList
forall (m :: * -> *). MonadIO m => m TagList
newZeroTagList
TagList -> [AttrOp TagList 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TagList
o [AttrOp TagList tag]
[AttrOp TagList 'AttrSet]
attrs
TagList -> m TagList
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
o
getTagListMiniObject :: MonadIO m => TagList -> m Gst.MiniObject.MiniObject
getTagListMiniObject :: forall (m :: * -> *). MonadIO m => TagList -> m MiniObject
getTagListMiniObject TagList
s = IO MiniObject -> m MiniObject
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MiniObject -> m MiniObject) -> IO MiniObject -> m MiniObject
forall a b. (a -> b) -> a -> b
$ TagList -> (Ptr TagList -> IO MiniObject) -> IO MiniObject
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TagList
s ((Ptr TagList -> IO MiniObject) -> IO MiniObject)
-> (Ptr TagList -> IO MiniObject) -> IO MiniObject
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
ptr -> do
let val :: Ptr MiniObject
val = Ptr TagList
ptr Ptr TagList -> Int -> Ptr MiniObject
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.MiniObject.MiniObject)
MiniObject
val' <- ((ManagedPtr MiniObject -> MiniObject)
-> Ptr MiniObject -> IO MiniObject
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MiniObject -> MiniObject
Gst.MiniObject.MiniObject) Ptr MiniObject
val
MiniObject -> IO MiniObject
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MiniObject
val'
#if defined(ENABLE_OVERLOADING)
data TagListMiniObjectFieldInfo
instance AttrInfo TagListMiniObjectFieldInfo where
type AttrBaseTypeConstraint TagListMiniObjectFieldInfo = (~) TagList
type AttrAllowedOps TagListMiniObjectFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint TagListMiniObjectFieldInfo = (~) (Ptr Gst.MiniObject.MiniObject)
type AttrTransferTypeConstraint TagListMiniObjectFieldInfo = (~)(Ptr Gst.MiniObject.MiniObject)
type AttrTransferType TagListMiniObjectFieldInfo = (Ptr Gst.MiniObject.MiniObject)
type AttrGetType TagListMiniObjectFieldInfo = Gst.MiniObject.MiniObject
type AttrLabel TagListMiniObjectFieldInfo = "mini_object"
type AttrOrigin TagListMiniObjectFieldInfo = TagList
attrGet = getTagListMiniObject
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.miniObject"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#g:attr:miniObject"
})
tagList_miniObject :: AttrLabelProxy "miniObject"
tagList_miniObject = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TagList
type instance O.AttributeList TagList = TagListAttributeList
type TagListAttributeList = ('[ '("miniObject", TagListMiniObjectFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_tag_list_new_empty" gst_tag_list_new_empty ::
IO (Ptr TagList)
tagListNewEmpty ::
(B.CallStack.HasCallStack, MonadIO m) =>
m TagList
tagListNewEmpty :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TagList
tagListNewEmpty = 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 TagList
result <- IO (Ptr TagList)
gst_tag_list_new_empty
Text -> Ptr TagList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListNewEmpty" Ptr TagList
result
TagList
result' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
TagList) Ptr TagList
result
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_tag_list_new_from_string" gst_tag_list_new_from_string ::
CString ->
IO (Ptr TagList)
tagListNewFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe TagList)
tagListNewFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe TagList)
tagListNewFromString Text
str = IO (Maybe TagList) -> m (Maybe TagList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr TagList
result <- CString -> IO (Ptr TagList)
gst_tag_list_new_from_string CString
str'
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Maybe TagList -> IO (Maybe TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_tag_list_add_value" gst_tag_list_add_value ::
Ptr TagList ->
CUInt ->
CString ->
Ptr GValue ->
IO ()
tagListAddValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> Gst.Enums.TagMergeMode
-> T.Text
-> GValue
-> m ()
tagListAddValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> TagMergeMode -> Text -> GValue -> m ()
tagListAddValue TagList
list TagMergeMode
mode Text
tag GValue
value = 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 TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
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
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr TagList -> CUInt -> CString -> Ptr GValue -> IO ()
gst_tag_list_add_value Ptr TagList
list' CUInt
mode' CString
tag' Ptr GValue
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TagListAddValueMethodInfo
instance (signature ~ (Gst.Enums.TagMergeMode -> T.Text -> GValue -> m ()), MonadIO m) => O.OverloadedMethod TagListAddValueMethodInfo TagList signature where
overloadedMethod = tagListAddValue
instance O.OverloadedMethodInfo TagListAddValueMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListAddValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListAddValue"
})
#endif
foreign import ccall "gst_tag_list_copy" gst_tag_list_copy ::
Ptr TagList ->
IO (Ptr TagList)
tagListCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> m TagList
tagListCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> m TagList
tagListCopy TagList
taglist = 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 TagList
taglist' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
taglist
Ptr TagList
result <- Ptr TagList -> IO (Ptr TagList)
gst_tag_list_copy Ptr TagList
taglist'
Text -> Ptr TagList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListCopy" Ptr TagList
result
TagList
result' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
TagList) Ptr TagList
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
taglist
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result'
#if defined(ENABLE_OVERLOADING)
data TagListCopyMethodInfo
instance (signature ~ (m TagList), MonadIO m) => O.OverloadedMethod TagListCopyMethodInfo TagList signature where
overloadedMethod = tagListCopy
instance O.OverloadedMethodInfo TagListCopyMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListCopy"
})
#endif
foreign import ccall "gst_tag_list_foreach" gst_tag_list_foreach ::
Ptr TagList ->
FunPtr Gst.Callbacks.C_TagForeachFunc ->
Ptr () ->
IO ()
tagListForeach ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> Gst.Callbacks.TagForeachFunc
-> m ()
tagListForeach :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> TagForeachFunc -> m ()
tagListForeach TagList
list TagForeachFunc
func = 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 TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
FunPtr C_TagForeachFunc
func' <- C_TagForeachFunc -> IO (FunPtr C_TagForeachFunc)
Gst.Callbacks.mk_TagForeachFunc (Maybe (Ptr (FunPtr C_TagForeachFunc))
-> TagForeachFunc_WithClosures -> C_TagForeachFunc
Gst.Callbacks.wrap_TagForeachFunc Maybe (Ptr (FunPtr C_TagForeachFunc))
forall a. Maybe a
Nothing (TagForeachFunc -> TagForeachFunc_WithClosures
Gst.Callbacks.drop_closures_TagForeachFunc TagForeachFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr TagList -> FunPtr C_TagForeachFunc -> Ptr () -> IO ()
gst_tag_list_foreach Ptr TagList
list' FunPtr C_TagForeachFunc
func' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_TagForeachFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TagForeachFunc
func'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TagListForeachMethodInfo
instance (signature ~ (Gst.Callbacks.TagForeachFunc -> m ()), MonadIO m) => O.OverloadedMethod TagListForeachMethodInfo TagList signature where
overloadedMethod = tagListForeach
instance O.OverloadedMethodInfo TagListForeachMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListForeach",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListForeach"
})
#endif
foreign import ccall "gst_tag_list_get_boolean" gst_tag_list_get_boolean ::
Ptr TagList ->
CString ->
Ptr CInt ->
IO CInt
tagListGetBoolean ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Bool))
tagListGetBoolean :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Bool)
tagListGetBoolean TagList
list Text
tag = IO (Bool, Bool) -> m (Bool, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CInt
value <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
CInt
result <- Ptr TagList -> CString -> Ptr CInt -> IO CInt
gst_tag_list_get_boolean Ptr TagList
list' CString
tag' Ptr CInt
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CInt
value' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
value
let value'' :: Bool
value'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
value
(Bool, Bool) -> IO (Bool, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Bool
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetBooleanMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod TagListGetBooleanMethodInfo TagList signature where
overloadedMethod = tagListGetBoolean
instance O.OverloadedMethodInfo TagListGetBooleanMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetBoolean",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetBoolean"
})
#endif
foreign import ccall "gst_tag_list_get_boolean_index" gst_tag_list_get_boolean_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr CInt ->
IO CInt
tagListGetBooleanIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Bool))
tagListGetBooleanIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Bool)
tagListGetBooleanIndex TagList
list Text
tag Word32
index = IO (Bool, Bool) -> m (Bool, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CInt
value <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr CInt -> IO CInt
gst_tag_list_get_boolean_index Ptr TagList
list' CString
tag' Word32
index Ptr CInt
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CInt
value' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
value
let value'' :: Bool
value'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
value
(Bool, Bool) -> IO (Bool, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Bool
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetBooleanIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod TagListGetBooleanIndexMethodInfo TagList signature where
overloadedMethod = tagListGetBooleanIndex
instance O.OverloadedMethodInfo TagListGetBooleanIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetBooleanIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetBooleanIndex"
})
#endif
foreign import ccall "gst_tag_list_get_date" gst_tag_list_get_date ::
Ptr TagList ->
CString ->
Ptr (Ptr GLib.Date.Date) ->
IO CInt
tagListGetDate ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, GLib.Date.Date))
tagListGetDate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Date)
tagListGetDate TagList
list Text
tag = IO (Bool, Date) -> m (Bool, Date)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Date) -> m (Bool, Date))
-> IO (Bool, Date) -> m (Bool, Date)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr Date)
value <- IO (Ptr (Ptr Date))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.Date.Date))
CInt
result <- Ptr TagList -> CString -> Ptr (Ptr Date) -> IO CInt
gst_tag_list_get_date Ptr TagList
list' CString
tag' Ptr (Ptr Date)
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Date
value' <- Ptr (Ptr Date) -> IO (Ptr Date)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Date)
value
Date
value'' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
GLib.Date.Date) Ptr Date
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr Date) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Date)
value
(Bool, Date) -> IO (Bool, Date)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Date
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetDateMethodInfo
instance (signature ~ (T.Text -> m ((Bool, GLib.Date.Date))), MonadIO m) => O.OverloadedMethod TagListGetDateMethodInfo TagList signature where
overloadedMethod = tagListGetDate
instance O.OverloadedMethodInfo TagListGetDateMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetDate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetDate"
})
#endif
foreign import ccall "gst_tag_list_get_date_index" gst_tag_list_get_date_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr (Ptr GLib.Date.Date) ->
IO CInt
tagListGetDateIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, GLib.Date.Date))
tagListGetDateIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Date)
tagListGetDateIndex TagList
list Text
tag Word32
index = IO (Bool, Date) -> m (Bool, Date)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Date) -> m (Bool, Date))
-> IO (Bool, Date) -> m (Bool, Date)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr Date)
value <- IO (Ptr (Ptr Date))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.Date.Date))
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr (Ptr Date) -> IO CInt
gst_tag_list_get_date_index Ptr TagList
list' CString
tag' Word32
index Ptr (Ptr Date)
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Date
value' <- Ptr (Ptr Date) -> IO (Ptr Date)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Date)
value
Date
value'' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
GLib.Date.Date) Ptr Date
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr Date) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Date)
value
(Bool, Date) -> IO (Bool, Date)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Date
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetDateIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, GLib.Date.Date))), MonadIO m) => O.OverloadedMethod TagListGetDateIndexMethodInfo TagList signature where
overloadedMethod = tagListGetDateIndex
instance O.OverloadedMethodInfo TagListGetDateIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetDateIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetDateIndex"
})
#endif
foreign import ccall "gst_tag_list_get_date_time" gst_tag_list_get_date_time ::
Ptr TagList ->
CString ->
Ptr (Ptr Gst.DateTime.DateTime) ->
IO CInt
tagListGetDateTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Gst.DateTime.DateTime))
tagListGetDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, DateTime)
tagListGetDateTime TagList
list Text
tag = IO (Bool, DateTime) -> m (Bool, DateTime)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, DateTime) -> m (Bool, DateTime))
-> IO (Bool, DateTime) -> m (Bool, DateTime)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr DateTime)
value <- IO (Ptr (Ptr DateTime))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.DateTime.DateTime))
CInt
result <- Ptr TagList -> CString -> Ptr (Ptr DateTime) -> IO CInt
gst_tag_list_get_date_time Ptr TagList
list' CString
tag' Ptr (Ptr DateTime)
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr DateTime
value' <- Ptr (Ptr DateTime) -> IO (Ptr DateTime)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr DateTime)
value
DateTime
value'' <- ((ManagedPtr DateTime -> DateTime) -> Ptr DateTime -> IO DateTime
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DateTime -> DateTime
Gst.DateTime.DateTime) Ptr DateTime
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr DateTime) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr DateTime)
value
(Bool, DateTime) -> IO (Bool, DateTime)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', DateTime
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetDateTimeMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Gst.DateTime.DateTime))), MonadIO m) => O.OverloadedMethod TagListGetDateTimeMethodInfo TagList signature where
overloadedMethod = tagListGetDateTime
instance O.OverloadedMethodInfo TagListGetDateTimeMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetDateTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetDateTime"
})
#endif
foreign import ccall "gst_tag_list_get_date_time_index" gst_tag_list_get_date_time_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr (Ptr Gst.DateTime.DateTime) ->
IO CInt
tagListGetDateTimeIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Gst.DateTime.DateTime))
tagListGetDateTimeIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, DateTime)
tagListGetDateTimeIndex TagList
list Text
tag Word32
index = IO (Bool, DateTime) -> m (Bool, DateTime)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, DateTime) -> m (Bool, DateTime))
-> IO (Bool, DateTime) -> m (Bool, DateTime)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr DateTime)
value <- IO (Ptr (Ptr DateTime))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.DateTime.DateTime))
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr (Ptr DateTime) -> IO CInt
gst_tag_list_get_date_time_index Ptr TagList
list' CString
tag' Word32
index Ptr (Ptr DateTime)
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr DateTime
value' <- Ptr (Ptr DateTime) -> IO (Ptr DateTime)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr DateTime)
value
DateTime
value'' <- ((ManagedPtr DateTime -> DateTime) -> Ptr DateTime -> IO DateTime
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DateTime -> DateTime
Gst.DateTime.DateTime) Ptr DateTime
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr DateTime) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr DateTime)
value
(Bool, DateTime) -> IO (Bool, DateTime)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', DateTime
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetDateTimeIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Gst.DateTime.DateTime))), MonadIO m) => O.OverloadedMethod TagListGetDateTimeIndexMethodInfo TagList signature where
overloadedMethod = tagListGetDateTimeIndex
instance O.OverloadedMethodInfo TagListGetDateTimeIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetDateTimeIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetDateTimeIndex"
})
#endif
foreign import ccall "gst_tag_list_get_double" gst_tag_list_get_double ::
Ptr TagList ->
CString ->
Ptr CDouble ->
IO CInt
tagListGetDouble ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Double))
tagListGetDouble :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Double)
tagListGetDouble TagList
list Text
tag = IO (Bool, Double) -> m (Bool, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Double) -> m (Bool, Double))
-> IO (Bool, Double) -> m (Bool, Double)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CDouble
value <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
CInt
result <- Ptr TagList -> CString -> Ptr CDouble -> IO CInt
gst_tag_list_get_double Ptr TagList
list' CString
tag' Ptr CDouble
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CDouble
value' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
value
let value'' :: Double
value'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
value
(Bool, Double) -> IO (Bool, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Double
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetDoubleMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Double))), MonadIO m) => O.OverloadedMethod TagListGetDoubleMethodInfo TagList signature where
overloadedMethod = tagListGetDouble
instance O.OverloadedMethodInfo TagListGetDoubleMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetDouble",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetDouble"
})
#endif
foreign import ccall "gst_tag_list_get_double_index" gst_tag_list_get_double_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr CDouble ->
IO CInt
tagListGetDoubleIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Double))
tagListGetDoubleIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Double)
tagListGetDoubleIndex TagList
list Text
tag Word32
index = IO (Bool, Double) -> m (Bool, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Double) -> m (Bool, Double))
-> IO (Bool, Double) -> m (Bool, Double)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CDouble
value <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr CDouble -> IO CInt
gst_tag_list_get_double_index Ptr TagList
list' CString
tag' Word32
index Ptr CDouble
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CDouble
value' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
value
let value'' :: Double
value'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
value
(Bool, Double) -> IO (Bool, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Double
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetDoubleIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Double))), MonadIO m) => O.OverloadedMethod TagListGetDoubleIndexMethodInfo TagList signature where
overloadedMethod = tagListGetDoubleIndex
instance O.OverloadedMethodInfo TagListGetDoubleIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetDoubleIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetDoubleIndex"
})
#endif
foreign import ccall "gst_tag_list_get_float" gst_tag_list_get_float ::
Ptr TagList ->
CString ->
Ptr CFloat ->
IO CInt
tagListGetFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Float))
tagListGetFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Float)
tagListGetFloat TagList
list Text
tag = IO (Bool, Float) -> m (Bool, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Float) -> m (Bool, Float))
-> IO (Bool, Float) -> m (Bool, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CFloat
value <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
CInt
result <- Ptr TagList -> CString -> Ptr CFloat -> IO CInt
gst_tag_list_get_float Ptr TagList
list' CString
tag' Ptr CFloat
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CFloat
value' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
value
let value'' :: Float
value'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
value
(Bool, Float) -> IO (Bool, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Float
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetFloatMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Float))), MonadIO m) => O.OverloadedMethod TagListGetFloatMethodInfo TagList signature where
overloadedMethod = tagListGetFloat
instance O.OverloadedMethodInfo TagListGetFloatMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetFloat"
})
#endif
foreign import ccall "gst_tag_list_get_float_index" gst_tag_list_get_float_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr CFloat ->
IO CInt
tagListGetFloatIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Float))
tagListGetFloatIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Float)
tagListGetFloatIndex TagList
list Text
tag Word32
index = IO (Bool, Float) -> m (Bool, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Float) -> m (Bool, Float))
-> IO (Bool, Float) -> m (Bool, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CFloat
value <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr CFloat -> IO CInt
gst_tag_list_get_float_index Ptr TagList
list' CString
tag' Word32
index Ptr CFloat
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CFloat
value' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
value
let value'' :: Float
value'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
value
(Bool, Float) -> IO (Bool, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Float
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetFloatIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Float))), MonadIO m) => O.OverloadedMethod TagListGetFloatIndexMethodInfo TagList signature where
overloadedMethod = tagListGetFloatIndex
instance O.OverloadedMethodInfo TagListGetFloatIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetFloatIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetFloatIndex"
})
#endif
foreign import ccall "gst_tag_list_get_int" gst_tag_list_get_int ::
Ptr TagList ->
CString ->
Ptr Int32 ->
IO CInt
tagListGetInt ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Int32))
tagListGetInt :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Int32)
tagListGetInt TagList
list Text
tag = IO (Bool, Int32) -> m (Bool, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int32) -> m (Bool, Int32))
-> IO (Bool, Int32) -> m (Bool, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Int32
value <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr TagList -> CString -> Ptr Int32 -> IO CInt
gst_tag_list_get_int Ptr TagList
list' CString
tag' Ptr Int32
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
value' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
value
(Bool, Int32) -> IO (Bool, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetIntMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Int32))), MonadIO m) => O.OverloadedMethod TagListGetIntMethodInfo TagList signature where
overloadedMethod = tagListGetInt
instance O.OverloadedMethodInfo TagListGetIntMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetInt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetInt"
})
#endif
foreign import ccall "gst_tag_list_get_int64" gst_tag_list_get_int64 ::
Ptr TagList ->
CString ->
Ptr Int64 ->
IO CInt
tagListGetInt64 ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Int64))
tagListGetInt64 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Int64)
tagListGetInt64 TagList
list Text
tag = IO (Bool, Int64) -> m (Bool, Int64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Int64
value <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr TagList -> CString -> Ptr Int64 -> IO CInt
gst_tag_list_get_int64 Ptr TagList
list' CString
tag' Ptr Int64
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
value' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
value
(Bool, Int64) -> IO (Bool, Int64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetInt64MethodInfo
instance (signature ~ (T.Text -> m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod TagListGetInt64MethodInfo TagList signature where
overloadedMethod = tagListGetInt64
instance O.OverloadedMethodInfo TagListGetInt64MethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetInt64",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetInt64"
})
#endif
foreign import ccall "gst_tag_list_get_int64_index" gst_tag_list_get_int64_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr Int64 ->
IO CInt
tagListGetInt64Index ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Int64))
tagListGetInt64Index :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Int64)
tagListGetInt64Index TagList
list Text
tag Word32
index = IO (Bool, Int64) -> m (Bool, Int64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Int64
value <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr Int64 -> IO CInt
gst_tag_list_get_int64_index Ptr TagList
list' CString
tag' Word32
index Ptr Int64
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
value' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
value
(Bool, Int64) -> IO (Bool, Int64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetInt64IndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod TagListGetInt64IndexMethodInfo TagList signature where
overloadedMethod = tagListGetInt64Index
instance O.OverloadedMethodInfo TagListGetInt64IndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetInt64Index",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetInt64Index"
})
#endif
foreign import ccall "gst_tag_list_get_int_index" gst_tag_list_get_int_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr Int32 ->
IO CInt
tagListGetIntIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Int32))
tagListGetIntIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Int32)
tagListGetIntIndex TagList
list Text
tag Word32
index = IO (Bool, Int32) -> m (Bool, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int32) -> m (Bool, Int32))
-> IO (Bool, Int32) -> m (Bool, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Int32
value <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr Int32 -> IO CInt
gst_tag_list_get_int_index Ptr TagList
list' CString
tag' Word32
index Ptr Int32
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
value' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
value
(Bool, Int32) -> IO (Bool, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetIntIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Int32))), MonadIO m) => O.OverloadedMethod TagListGetIntIndexMethodInfo TagList signature where
overloadedMethod = tagListGetIntIndex
instance O.OverloadedMethodInfo TagListGetIntIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetIntIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetIntIndex"
})
#endif
foreign import ccall "gst_tag_list_get_pointer" gst_tag_list_get_pointer ::
Ptr TagList ->
CString ->
Ptr (Ptr ()) ->
IO CInt
tagListGetPointer ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Ptr ()))
tagListGetPointer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Ptr ())
tagListGetPointer TagList
list Text
tag = IO (Bool, Ptr ()) -> m (Bool, Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Ptr ()) -> m (Bool, Ptr ()))
-> IO (Bool, Ptr ()) -> m (Bool, Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr ())
value <- IO (Ptr (Ptr ()))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr ()))
CInt
result <- Ptr TagList -> CString -> Ptr (Ptr ()) -> IO CInt
gst_tag_list_get_pointer Ptr TagList
list' CString
tag' Ptr (Ptr ())
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr ()
value' <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr ()) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
value
(Bool, Ptr ()) -> IO (Bool, Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Ptr ()
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetPointerMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Ptr ()))), MonadIO m) => O.OverloadedMethod TagListGetPointerMethodInfo TagList signature where
overloadedMethod = tagListGetPointer
instance O.OverloadedMethodInfo TagListGetPointerMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetPointer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetPointer"
})
#endif
foreign import ccall "gst_tag_list_get_pointer_index" gst_tag_list_get_pointer_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr (Ptr ()) ->
IO CInt
tagListGetPointerIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Ptr ()))
tagListGetPointerIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Ptr ())
tagListGetPointerIndex TagList
list Text
tag Word32
index = IO (Bool, Ptr ()) -> m (Bool, Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Ptr ()) -> m (Bool, Ptr ()))
-> IO (Bool, Ptr ()) -> m (Bool, Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr ())
value <- IO (Ptr (Ptr ()))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr ()))
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr (Ptr ()) -> IO CInt
gst_tag_list_get_pointer_index Ptr TagList
list' CString
tag' Word32
index Ptr (Ptr ())
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr ()
value' <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr ()) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
value
(Bool, Ptr ()) -> IO (Bool, Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Ptr ()
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetPointerIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Ptr ()))), MonadIO m) => O.OverloadedMethod TagListGetPointerIndexMethodInfo TagList signature where
overloadedMethod = tagListGetPointerIndex
instance O.OverloadedMethodInfo TagListGetPointerIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetPointerIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetPointerIndex"
})
#endif
foreign import ccall "gst_tag_list_get_sample" gst_tag_list_get_sample ::
Ptr TagList ->
CString ->
Ptr (Ptr Gst.Sample.Sample) ->
IO CInt
tagListGetSample ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Gst.Sample.Sample))
tagListGetSample :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Sample)
tagListGetSample TagList
list Text
tag = IO (Bool, Sample) -> m (Bool, Sample)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Sample) -> m (Bool, Sample))
-> IO (Bool, Sample) -> m (Bool, Sample)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr Sample)
sample <- IO (Ptr (Ptr Sample))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Sample.Sample))
CInt
result <- Ptr TagList -> CString -> Ptr (Ptr Sample) -> IO CInt
gst_tag_list_get_sample Ptr TagList
list' CString
tag' Ptr (Ptr Sample)
sample
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Sample
sample' <- Ptr (Ptr Sample) -> IO (Ptr Sample)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Sample)
sample
Sample
sample'' <- ((ManagedPtr Sample -> Sample) -> Ptr Sample -> IO Sample
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Sample -> Sample
Gst.Sample.Sample) Ptr Sample
sample'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr Sample) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Sample)
sample
(Bool, Sample) -> IO (Bool, Sample)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Sample
sample'')
#if defined(ENABLE_OVERLOADING)
data TagListGetSampleMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Gst.Sample.Sample))), MonadIO m) => O.OverloadedMethod TagListGetSampleMethodInfo TagList signature where
overloadedMethod = tagListGetSample
instance O.OverloadedMethodInfo TagListGetSampleMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetSample",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetSample"
})
#endif
foreign import ccall "gst_tag_list_get_sample_index" gst_tag_list_get_sample_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr (Ptr Gst.Sample.Sample) ->
IO CInt
tagListGetSampleIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Gst.Sample.Sample))
tagListGetSampleIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Sample)
tagListGetSampleIndex TagList
list Text
tag Word32
index = IO (Bool, Sample) -> m (Bool, Sample)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Sample) -> m (Bool, Sample))
-> IO (Bool, Sample) -> m (Bool, Sample)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr (Ptr Sample)
sample <- IO (Ptr (Ptr Sample))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Sample.Sample))
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr (Ptr Sample) -> IO CInt
gst_tag_list_get_sample_index Ptr TagList
list' CString
tag' Word32
index Ptr (Ptr Sample)
sample
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Sample
sample' <- Ptr (Ptr Sample) -> IO (Ptr Sample)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Sample)
sample
Sample
sample'' <- ((ManagedPtr Sample -> Sample) -> Ptr Sample -> IO Sample
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Sample -> Sample
Gst.Sample.Sample) Ptr Sample
sample'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr (Ptr Sample) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Sample)
sample
(Bool, Sample) -> IO (Bool, Sample)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Sample
sample'')
#if defined(ENABLE_OVERLOADING)
data TagListGetSampleIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Gst.Sample.Sample))), MonadIO m) => O.OverloadedMethod TagListGetSampleIndexMethodInfo TagList signature where
overloadedMethod = tagListGetSampleIndex
instance O.OverloadedMethodInfo TagListGetSampleIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetSampleIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetSampleIndex"
})
#endif
foreign import ccall "gst_tag_list_get_scope" gst_tag_list_get_scope ::
Ptr TagList ->
IO CUInt
tagListGetScope ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> m Gst.Enums.TagScope
tagListGetScope :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> m TagScope
tagListGetScope TagList
list = IO TagScope -> m TagScope
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TagScope -> m TagScope) -> IO TagScope -> m TagScope
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CUInt
result <- Ptr TagList -> IO CUInt
gst_tag_list_get_scope Ptr TagList
list'
let result' :: TagScope
result' = (Int -> TagScope
forall a. Enum a => Int -> a
toEnum (Int -> TagScope) -> (CUInt -> Int) -> CUInt -> TagScope
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
TagScope -> IO TagScope
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagScope
result'
#if defined(ENABLE_OVERLOADING)
data TagListGetScopeMethodInfo
instance (signature ~ (m Gst.Enums.TagScope), MonadIO m) => O.OverloadedMethod TagListGetScopeMethodInfo TagList signature where
overloadedMethod = tagListGetScope
instance O.OverloadedMethodInfo TagListGetScopeMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetScope",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetScope"
})
#endif
foreign import ccall "gst_tag_list_get_string" gst_tag_list_get_string ::
Ptr TagList ->
CString ->
Ptr CString ->
IO CInt
tagListGetString ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, T.Text))
tagListGetString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Text)
tagListGetString TagList
list Text
tag = IO (Bool, Text) -> m (Bool, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text) -> m (Bool, Text))
-> IO (Bool, Text) -> m (Bool, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- Ptr TagList -> CString -> Ptr CString -> IO CInt
gst_tag_list_get_string Ptr TagList
list' CString
tag' Ptr CString
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
value' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
value
Text
value'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
value
(Bool, Text) -> IO (Bool, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetStringMethodInfo
instance (signature ~ (T.Text -> m ((Bool, T.Text))), MonadIO m) => O.OverloadedMethod TagListGetStringMethodInfo TagList signature where
overloadedMethod = tagListGetString
instance O.OverloadedMethodInfo TagListGetStringMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetString"
})
#endif
foreign import ccall "gst_tag_list_get_string_index" gst_tag_list_get_string_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr CString ->
IO CInt
tagListGetStringIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, T.Text))
tagListGetStringIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Text)
tagListGetStringIndex TagList
list Text
tag Word32
index = IO (Bool, Text) -> m (Bool, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text) -> m (Bool, Text))
-> IO (Bool, Text) -> m (Bool, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr CString -> IO CInt
gst_tag_list_get_string_index Ptr TagList
list' CString
tag' Word32
index Ptr CString
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
value' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
value
Text
value'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
value
(Bool, Text) -> IO (Bool, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
value'')
#if defined(ENABLE_OVERLOADING)
data TagListGetStringIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, T.Text))), MonadIO m) => O.OverloadedMethod TagListGetStringIndexMethodInfo TagList signature where
overloadedMethod = tagListGetStringIndex
instance O.OverloadedMethodInfo TagListGetStringIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetStringIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetStringIndex"
})
#endif
foreign import ccall "gst_tag_list_get_tag_size" gst_tag_list_get_tag_size ::
Ptr TagList ->
CString ->
IO Word32
tagListGetTagSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m Word32
tagListGetTagSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m Word32
tagListGetTagSize TagList
list Text
tag = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Word32
result <- Ptr TagList -> CString -> IO Word32
gst_tag_list_get_tag_size Ptr TagList
list' CString
tag'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data TagListGetTagSizeMethodInfo
instance (signature ~ (T.Text -> m Word32), MonadIO m) => O.OverloadedMethod TagListGetTagSizeMethodInfo TagList signature where
overloadedMethod = tagListGetTagSize
instance O.OverloadedMethodInfo TagListGetTagSizeMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetTagSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetTagSize"
})
#endif
foreign import ccall "gst_tag_list_get_uint" gst_tag_list_get_uint ::
Ptr TagList ->
CString ->
Ptr Word32 ->
IO CInt
tagListGetUint ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Word32))
tagListGetUint :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Word32)
tagListGetUint TagList
list Text
tag = IO (Bool, Word32) -> m (Bool, Word32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32) -> m (Bool, Word32))
-> IO (Bool, Word32) -> m (Bool, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Word32
value <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CInt
result <- Ptr TagList -> CString -> Ptr Word32 -> IO CInt
gst_tag_list_get_uint Ptr TagList
list' CString
tag' Ptr Word32
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word32
value' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
value
(Bool, Word32) -> IO (Bool, Word32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetUintMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Word32))), MonadIO m) => O.OverloadedMethod TagListGetUintMethodInfo TagList signature where
overloadedMethod = tagListGetUint
instance O.OverloadedMethodInfo TagListGetUintMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetUint",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetUint"
})
#endif
foreign import ccall "gst_tag_list_get_uint64" gst_tag_list_get_uint64 ::
Ptr TagList ->
CString ->
Ptr Word64 ->
IO CInt
tagListGetUint64 ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, Word64))
tagListGetUint64 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, Word64)
tagListGetUint64 TagList
list Text
tag = IO (Bool, Word64) -> m (Bool, Word64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word64) -> m (Bool, Word64))
-> IO (Bool, Word64) -> m (Bool, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Word64
value <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CInt
result <- Ptr TagList -> CString -> Ptr Word64 -> IO CInt
gst_tag_list_get_uint64 Ptr TagList
list' CString
tag' Ptr Word64
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word64
value' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
value
(Bool, Word64) -> IO (Bool, Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word64
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetUint64MethodInfo
instance (signature ~ (T.Text -> m ((Bool, Word64))), MonadIO m) => O.OverloadedMethod TagListGetUint64MethodInfo TagList signature where
overloadedMethod = tagListGetUint64
instance O.OverloadedMethodInfo TagListGetUint64MethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetUint64",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetUint64"
})
#endif
foreign import ccall "gst_tag_list_get_uint64_index" gst_tag_list_get_uint64_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr Word64 ->
IO CInt
tagListGetUint64Index ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Word64))
tagListGetUint64Index :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Word64)
tagListGetUint64Index TagList
list Text
tag Word32
index = IO (Bool, Word64) -> m (Bool, Word64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word64) -> m (Bool, Word64))
-> IO (Bool, Word64) -> m (Bool, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Word64
value <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr Word64 -> IO CInt
gst_tag_list_get_uint64_index Ptr TagList
list' CString
tag' Word32
index Ptr Word64
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word64
value' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
value
(Bool, Word64) -> IO (Bool, Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word64
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetUint64IndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Word64))), MonadIO m) => O.OverloadedMethod TagListGetUint64IndexMethodInfo TagList signature where
overloadedMethod = tagListGetUint64Index
instance O.OverloadedMethodInfo TagListGetUint64IndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetUint64Index",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetUint64Index"
})
#endif
foreign import ccall "gst_tag_list_get_uint_index" gst_tag_list_get_uint_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr Word32 ->
IO CInt
tagListGetUintIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, Word32))
tagListGetUintIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Word32)
tagListGetUintIndex TagList
list Text
tag Word32
index = IO (Bool, Word32) -> m (Bool, Word32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32) -> m (Bool, Word32))
-> IO (Bool, Word32) -> m (Bool, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr Word32
value <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr Word32 -> IO CInt
gst_tag_list_get_uint_index Ptr TagList
list' CString
tag' Word32
index Ptr Word32
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word32
value' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
value
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
value
(Bool, Word32) -> IO (Bool, Word32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
value')
#if defined(ENABLE_OVERLOADING)
data TagListGetUintIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, Word32))), MonadIO m) => O.OverloadedMethod TagListGetUintIndexMethodInfo TagList signature where
overloadedMethod = tagListGetUintIndex
instance O.OverloadedMethodInfo TagListGetUintIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetUintIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetUintIndex"
})
#endif
foreign import ccall "gst_tag_list_get_value_index" gst_tag_list_get_value_index ::
Ptr TagList ->
CString ->
Word32 ->
IO (Ptr GValue)
tagListGetValueIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m (Maybe GValue)
tagListGetValueIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Maybe GValue)
tagListGetValueIndex TagList
list Text
tag Word32
index = IO (Maybe GValue) -> m (Maybe GValue)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GValue) -> m (Maybe GValue))
-> IO (Maybe GValue) -> m (Maybe GValue)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr GValue
result <- Ptr TagList -> CString -> Word32 -> IO (Ptr GValue)
gst_tag_list_get_value_index Ptr TagList
list' CString
tag' Word32
index
Maybe GValue
maybeResult <- Ptr GValue -> (Ptr GValue -> IO GValue) -> IO (Maybe GValue)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GValue
result ((Ptr GValue -> IO GValue) -> IO (Maybe GValue))
-> (Ptr GValue -> IO GValue) -> IO (Maybe GValue)
forall a b. (a -> b) -> a -> b
$ \Ptr GValue
result' -> do
GValue
result'' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
result'
GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result''
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Maybe GValue -> IO (Maybe GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GValue
maybeResult
#if defined(ENABLE_OVERLOADING)
data TagListGetValueIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m (Maybe GValue)), MonadIO m) => O.OverloadedMethod TagListGetValueIndexMethodInfo TagList signature where
overloadedMethod = tagListGetValueIndex
instance O.OverloadedMethodInfo TagListGetValueIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListGetValueIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListGetValueIndex"
})
#endif
foreign import ccall "gst_tag_list_insert" gst_tag_list_insert ::
Ptr TagList ->
Ptr TagList ->
CUInt ->
IO ()
tagListInsert ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> TagList
-> Gst.Enums.TagMergeMode
-> m ()
tagListInsert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> TagList -> TagMergeMode -> m ()
tagListInsert TagList
into TagList
from 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 TagList
into' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
into
Ptr TagList
from' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
from
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 TagList -> Ptr TagList -> CUInt -> IO ()
gst_tag_list_insert Ptr TagList
into' Ptr TagList
from' CUInt
mode'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
into
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
from
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TagListInsertMethodInfo
instance (signature ~ (TagList -> Gst.Enums.TagMergeMode -> m ()), MonadIO m) => O.OverloadedMethod TagListInsertMethodInfo TagList signature where
overloadedMethod = tagListInsert
instance O.OverloadedMethodInfo TagListInsertMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListInsert",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListInsert"
})
#endif
foreign import ccall "gst_tag_list_is_empty" gst_tag_list_is_empty ::
Ptr TagList ->
IO CInt
tagListIsEmpty ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> m Bool
tagListIsEmpty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> m Bool
tagListIsEmpty TagList
list = 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 TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CInt
result <- Ptr TagList -> IO CInt
gst_tag_list_is_empty Ptr TagList
list'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TagListIsEmptyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod TagListIsEmptyMethodInfo TagList signature where
overloadedMethod = tagListIsEmpty
instance O.OverloadedMethodInfo TagListIsEmptyMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListIsEmpty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListIsEmpty"
})
#endif
foreign import ccall "gst_tag_list_is_equal" gst_tag_list_is_equal ::
Ptr TagList ->
Ptr TagList ->
IO CInt
tagListIsEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> TagList
-> m Bool
tagListIsEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> TagList -> m Bool
tagListIsEqual TagList
list1 TagList
list2 = 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 TagList
list1' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list1
Ptr TagList
list2' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list2
CInt
result <- Ptr TagList -> Ptr TagList -> IO CInt
gst_tag_list_is_equal Ptr TagList
list1' Ptr TagList
list2'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list1
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list2
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TagListIsEqualMethodInfo
instance (signature ~ (TagList -> m Bool), MonadIO m) => O.OverloadedMethod TagListIsEqualMethodInfo TagList signature where
overloadedMethod = tagListIsEqual
instance O.OverloadedMethodInfo TagListIsEqualMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListIsEqual",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListIsEqual"
})
#endif
foreign import ccall "gst_tag_list_merge" gst_tag_list_merge ::
Ptr TagList ->
Ptr TagList ->
CUInt ->
IO (Ptr TagList)
tagListMerge ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> Maybe (TagList)
-> Gst.Enums.TagMergeMode
-> m (Maybe TagList)
tagListMerge :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Maybe TagList -> TagMergeMode -> m (Maybe TagList)
tagListMerge TagList
list1 Maybe TagList
list2 TagMergeMode
mode = IO (Maybe TagList) -> m (Maybe TagList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list1' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list1
Ptr TagList
maybeList2 <- case Maybe TagList
list2 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
jList2 -> do
Ptr TagList
jList2' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
jList2
Ptr TagList -> IO (Ptr TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
jList2'
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 TagList
result <- Ptr TagList -> Ptr TagList -> CUInt -> IO (Ptr TagList)
gst_tag_list_merge Ptr TagList
list1' Ptr TagList
maybeList2 CUInt
mode'
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list1
Maybe TagList -> (TagList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TagList
list2 TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe TagList -> IO (Maybe TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
maybeResult
#if defined(ENABLE_OVERLOADING)
data TagListMergeMethodInfo
instance (signature ~ (Maybe (TagList) -> Gst.Enums.TagMergeMode -> m (Maybe TagList)), MonadIO m) => O.OverloadedMethod TagListMergeMethodInfo TagList signature where
overloadedMethod = tagListMerge
instance O.OverloadedMethodInfo TagListMergeMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListMerge",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListMerge"
})
#endif
foreign import ccall "gst_tag_list_n_tags" gst_tag_list_n_tags ::
Ptr TagList ->
IO Int32
tagListNTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> m Int32
tagListNTags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> m Int32
tagListNTags TagList
list = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
Int32
result <- Ptr TagList -> IO Int32
gst_tag_list_n_tags Ptr TagList
list'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data TagListNTagsMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod TagListNTagsMethodInfo TagList signature where
overloadedMethod = tagListNTags
instance O.OverloadedMethodInfo TagListNTagsMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListNTags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListNTags"
})
#endif
foreign import ccall "gst_tag_list_nth_tag_name" gst_tag_list_nth_tag_name ::
Ptr TagList ->
Word32 ->
IO CString
tagListNthTagName ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> Word32
-> m T.Text
tagListNthTagName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Word32 -> m Text
tagListNthTagName TagList
list Word32
index = IO Text -> m Text
forall a. IO a -> m a
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 TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
result <- Ptr TagList -> Word32 -> IO CString
gst_tag_list_nth_tag_name Ptr TagList
list' Word32
index
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tagListNthTagName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data TagListNthTagNameMethodInfo
instance (signature ~ (Word32 -> m T.Text), MonadIO m) => O.OverloadedMethod TagListNthTagNameMethodInfo TagList signature where
overloadedMethod = tagListNthTagName
instance O.OverloadedMethodInfo TagListNthTagNameMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListNthTagName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListNthTagName"
})
#endif
foreign import ccall "gst_tag_list_peek_string_index" gst_tag_list_peek_string_index ::
Ptr TagList ->
CString ->
Word32 ->
Ptr CString ->
IO CInt
tagListPeekStringIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> Word32
-> m ((Bool, T.Text))
tagListPeekStringIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> Word32 -> m (Bool, Text)
tagListPeekStringIndex TagList
list Text
tag Word32
index = IO (Bool, Text) -> m (Bool, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text) -> m (Bool, Text))
-> IO (Bool, Text) -> m (Bool, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- Ptr TagList -> CString -> Word32 -> Ptr CString -> IO CInt
gst_tag_list_peek_string_index Ptr TagList
list' CString
tag' Word32
index Ptr CString
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
value' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
value
Text
value'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
value
(Bool, Text) -> IO (Bool, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
value'')
#if defined(ENABLE_OVERLOADING)
data TagListPeekStringIndexMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ((Bool, T.Text))), MonadIO m) => O.OverloadedMethod TagListPeekStringIndexMethodInfo TagList signature where
overloadedMethod = tagListPeekStringIndex
instance O.OverloadedMethodInfo TagListPeekStringIndexMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListPeekStringIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListPeekStringIndex"
})
#endif
foreign import ccall "gst_tag_list_remove_tag" gst_tag_list_remove_tag ::
Ptr TagList ->
CString ->
IO ()
tagListRemoveTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ()
tagListRemoveTag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m ()
tagListRemoveTag TagList
list Text
tag = 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 TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
Ptr TagList -> CString -> IO ()
gst_tag_list_remove_tag Ptr TagList
list' CString
tag'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TagListRemoveTagMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod TagListRemoveTagMethodInfo TagList signature where
overloadedMethod = tagListRemoveTag
instance O.OverloadedMethodInfo TagListRemoveTagMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListRemoveTag",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListRemoveTag"
})
#endif
foreign import ccall "gst_tag_list_set_scope" gst_tag_list_set_scope ::
Ptr TagList ->
CUInt ->
IO ()
tagListSetScope ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> Gst.Enums.TagScope
-> m ()
tagListSetScope :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> TagScope -> m ()
tagListSetScope TagList
list TagScope
scope = 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 TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
let scope' :: CUInt
scope' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TagScope -> Int) -> TagScope -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagScope -> Int
forall a. Enum a => a -> Int
fromEnum) TagScope
scope
Ptr TagList -> CUInt -> IO ()
gst_tag_list_set_scope Ptr TagList
list' CUInt
scope'
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TagListSetScopeMethodInfo
instance (signature ~ (Gst.Enums.TagScope -> m ()), MonadIO m) => O.OverloadedMethod TagListSetScopeMethodInfo TagList signature where
overloadedMethod = tagListSetScope
instance O.OverloadedMethodInfo TagListSetScopeMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListSetScope",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListSetScope"
})
#endif
foreign import ccall "gst_tag_list_to_string" gst_tag_list_to_string ::
Ptr TagList ->
IO CString
tagListToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> m (Maybe T.Text)
tagListToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> m (Maybe Text)
tagListToString TagList
list = 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 TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
result <- Ptr TagList -> IO CString
gst_tag_list_to_string Ptr TagList
list'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
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 TagListToStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod TagListToStringMethodInfo TagList signature where
overloadedMethod = tagListToString
instance O.OverloadedMethodInfo TagListToStringMethodInfo TagList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.TagList.tagListToString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-TagList.html#v:tagListToString"
})
#endif
foreign import ccall "gst_tag_list_copy_value" gst_tag_list_copy_value ::
Ptr GValue ->
Ptr TagList ->
CString ->
IO CInt
tagListCopyValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
TagList
-> T.Text
-> m ((Bool, GValue))
tagListCopyValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> Text -> m (Bool, GValue)
tagListCopyValue TagList
list Text
tag = IO (Bool, GValue) -> m (Bool, GValue)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, GValue) -> m (Bool, GValue))
-> IO (Bool, GValue) -> m (Bool, GValue)
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
dest <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
Ptr TagList
list' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
list
CString
tag' <- Text -> IO CString
textToCString Text
tag
CInt
result <- Ptr GValue -> Ptr TagList -> CString -> IO CInt
gst_tag_list_copy_value Ptr GValue
dest Ptr TagList
list' CString
tag'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
GValue
dest' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
dest
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
list
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tag'
(Bool, GValue) -> IO (Bool, GValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', GValue
dest')
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTagListMethod (t :: Symbol) (o :: *) :: * where
ResolveTagListMethod "addValue" o = TagListAddValueMethodInfo
ResolveTagListMethod "copy" o = TagListCopyMethodInfo
ResolveTagListMethod "foreach" o = TagListForeachMethodInfo
ResolveTagListMethod "insert" o = TagListInsertMethodInfo
ResolveTagListMethod "isEmpty" o = TagListIsEmptyMethodInfo
ResolveTagListMethod "isEqual" o = TagListIsEqualMethodInfo
ResolveTagListMethod "merge" o = TagListMergeMethodInfo
ResolveTagListMethod "nTags" o = TagListNTagsMethodInfo
ResolveTagListMethod "nthTagName" o = TagListNthTagNameMethodInfo
ResolveTagListMethod "peekStringIndex" o = TagListPeekStringIndexMethodInfo
ResolveTagListMethod "removeTag" o = TagListRemoveTagMethodInfo
ResolveTagListMethod "toString" o = TagListToStringMethodInfo
ResolveTagListMethod "getBoolean" o = TagListGetBooleanMethodInfo
ResolveTagListMethod "getBooleanIndex" o = TagListGetBooleanIndexMethodInfo
ResolveTagListMethod "getDate" o = TagListGetDateMethodInfo
ResolveTagListMethod "getDateIndex" o = TagListGetDateIndexMethodInfo
ResolveTagListMethod "getDateTime" o = TagListGetDateTimeMethodInfo
ResolveTagListMethod "getDateTimeIndex" o = TagListGetDateTimeIndexMethodInfo
ResolveTagListMethod "getDouble" o = TagListGetDoubleMethodInfo
ResolveTagListMethod "getDoubleIndex" o = TagListGetDoubleIndexMethodInfo
ResolveTagListMethod "getFloat" o = TagListGetFloatMethodInfo
ResolveTagListMethod "getFloatIndex" o = TagListGetFloatIndexMethodInfo
ResolveTagListMethod "getInt" o = TagListGetIntMethodInfo
ResolveTagListMethod "getInt64" o = TagListGetInt64MethodInfo
ResolveTagListMethod "getInt64Index" o = TagListGetInt64IndexMethodInfo
ResolveTagListMethod "getIntIndex" o = TagListGetIntIndexMethodInfo
ResolveTagListMethod "getPointer" o = TagListGetPointerMethodInfo
ResolveTagListMethod "getPointerIndex" o = TagListGetPointerIndexMethodInfo
ResolveTagListMethod "getSample" o = TagListGetSampleMethodInfo
ResolveTagListMethod "getSampleIndex" o = TagListGetSampleIndexMethodInfo
ResolveTagListMethod "getScope" o = TagListGetScopeMethodInfo
ResolveTagListMethod "getString" o = TagListGetStringMethodInfo
ResolveTagListMethod "getStringIndex" o = TagListGetStringIndexMethodInfo
ResolveTagListMethod "getTagSize" o = TagListGetTagSizeMethodInfo
ResolveTagListMethod "getUint" o = TagListGetUintMethodInfo
ResolveTagListMethod "getUint64" o = TagListGetUint64MethodInfo
ResolveTagListMethod "getUint64Index" o = TagListGetUint64IndexMethodInfo
ResolveTagListMethod "getUintIndex" o = TagListGetUintIndexMethodInfo
ResolveTagListMethod "getValueIndex" o = TagListGetValueIndexMethodInfo
ResolveTagListMethod "setScope" o = TagListSetScopeMethodInfo
ResolveTagListMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTagListMethod t TagList, O.OverloadedMethod info TagList p) => OL.IsLabel t (TagList -> 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 ~ ResolveTagListMethod t TagList, O.OverloadedMethod info TagList p, R.HasField t TagList p) => R.HasField t TagList p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTagListMethod t TagList, O.OverloadedMethodInfo info TagList) => OL.IsLabel t (O.MethodProxy info TagList) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif