{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.BufferList
(
BufferList(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveBufferListMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BufferListCalculateSizeMethodInfo ,
#endif
bufferListCalculateSize ,
#if defined(ENABLE_OVERLOADING)
BufferListCopyDeepMethodInfo ,
#endif
bufferListCopyDeep ,
#if defined(ENABLE_OVERLOADING)
BufferListForeachMethodInfo ,
#endif
bufferListForeach ,
#if defined(ENABLE_OVERLOADING)
BufferListGetMethodInfo ,
#endif
bufferListGet ,
#if defined(ENABLE_OVERLOADING)
BufferListGetWritableMethodInfo ,
#endif
bufferListGetWritable ,
#if defined(ENABLE_OVERLOADING)
BufferListInsertMethodInfo ,
#endif
bufferListInsert ,
#if defined(ENABLE_OVERLOADING)
BufferListLengthMethodInfo ,
#endif
bufferListLength ,
bufferListNew ,
bufferListNewSized ,
#if defined(ENABLE_OVERLOADING)
BufferListRemoveMethodInfo ,
#endif
bufferListRemove ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.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.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
newtype BufferList = BufferList (SP.ManagedPtr BufferList)
deriving (BufferList -> BufferList -> Bool
(BufferList -> BufferList -> Bool)
-> (BufferList -> BufferList -> Bool) -> Eq BufferList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferList -> BufferList -> Bool
$c/= :: BufferList -> BufferList -> Bool
== :: BufferList -> BufferList -> Bool
$c== :: BufferList -> BufferList -> Bool
Eq)
instance SP.ManagedPtrNewtype BufferList where
toManagedPtr :: BufferList -> ManagedPtr BufferList
toManagedPtr (BufferList ManagedPtr BufferList
p) = ManagedPtr BufferList
p
foreign import ccall "gst_buffer_list_get_type" c_gst_buffer_list_get_type ::
IO GType
type instance O.ParentTypes BufferList = '[]
instance O.HasParentTypes BufferList
instance B.Types.TypedObject BufferList where
glibType :: IO GType
glibType = IO GType
c_gst_buffer_list_get_type
instance B.Types.GBoxed BufferList
instance B.GValue.IsGValue (Maybe BufferList) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_buffer_list_get_type
gvalueSet_ :: Ptr GValue -> Maybe BufferList -> IO ()
gvalueSet_ Ptr GValue
gv Maybe BufferList
P.Nothing = Ptr GValue -> Ptr BufferList -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr BufferList
forall a. Ptr a
FP.nullPtr :: FP.Ptr BufferList)
gvalueSet_ Ptr GValue
gv (P.Just BufferList
obj) = BufferList -> (Ptr BufferList -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BufferList
obj (Ptr GValue -> Ptr BufferList -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe BufferList)
gvalueGet_ Ptr GValue
gv = do
Ptr BufferList
ptr <- Ptr GValue -> IO (Ptr BufferList)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr BufferList)
if Ptr BufferList
ptr Ptr BufferList -> Ptr BufferList -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr BufferList
forall a. Ptr a
FP.nullPtr
then BufferList -> Maybe BufferList
forall a. a -> Maybe a
P.Just (BufferList -> Maybe BufferList)
-> IO BufferList -> IO (Maybe BufferList)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr BufferList -> BufferList
BufferList Ptr BufferList
ptr
else Maybe BufferList -> IO (Maybe BufferList)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BufferList
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BufferList
type instance O.AttributeList BufferList = BufferListAttributeList
type BufferListAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gst_buffer_list_new" gst_buffer_list_new ::
IO (Ptr BufferList)
bufferListNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m BufferList
bufferListNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m BufferList
bufferListNew = IO BufferList -> m BufferList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BufferList -> m BufferList) -> IO BufferList -> m BufferList
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
result <- IO (Ptr BufferList)
gst_buffer_list_new
Text -> Ptr BufferList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferListNew" Ptr BufferList
result
BufferList
result' <- ((ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BufferList -> BufferList
BufferList) Ptr BufferList
result
BufferList -> IO BufferList
forall (m :: * -> *) a. Monad m => a -> m a
return BufferList
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_buffer_list_new_sized" gst_buffer_list_new_sized ::
Word32 ->
IO (Ptr BufferList)
bufferListNewSized ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m BufferList
bufferListNewSized :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m BufferList
bufferListNewSized Word32
size = IO BufferList -> m BufferList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BufferList -> m BufferList) -> IO BufferList -> m BufferList
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
result <- Word32 -> IO (Ptr BufferList)
gst_buffer_list_new_sized Word32
size
Text -> Ptr BufferList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferListNewSized" Ptr BufferList
result
BufferList
result' <- ((ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BufferList -> BufferList
BufferList) Ptr BufferList
result
BufferList -> IO BufferList
forall (m :: * -> *) a. Monad m => a -> m a
return BufferList
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_buffer_list_calculate_size" gst_buffer_list_calculate_size ::
Ptr BufferList ->
IO Word64
bufferListCalculateSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> m Word64
bufferListCalculateSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> m Word64
bufferListCalculateSize BufferList
list = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
Word64
result <- Ptr BufferList -> IO Word64
gst_buffer_list_calculate_size Ptr BufferList
list'
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data BufferListCalculateSizeMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.OverloadedMethod BufferListCalculateSizeMethodInfo BufferList signature where
overloadedMethod = bufferListCalculateSize
instance O.OverloadedMethodInfo BufferListCalculateSizeMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListCalculateSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListCalculateSize"
})
#endif
foreign import ccall "gst_buffer_list_copy_deep" gst_buffer_list_copy_deep ::
Ptr BufferList ->
IO (Ptr BufferList)
bufferListCopyDeep ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> m BufferList
bufferListCopyDeep :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> m BufferList
bufferListCopyDeep BufferList
list = IO BufferList -> m BufferList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BufferList -> m BufferList) -> IO BufferList -> m BufferList
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
Ptr BufferList
result <- Ptr BufferList -> IO (Ptr BufferList)
gst_buffer_list_copy_deep Ptr BufferList
list'
Text -> Ptr BufferList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferListCopyDeep" Ptr BufferList
result
BufferList
result' <- ((ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BufferList -> BufferList
BufferList) Ptr BufferList
result
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
BufferList -> IO BufferList
forall (m :: * -> *) a. Monad m => a -> m a
return BufferList
result'
#if defined(ENABLE_OVERLOADING)
data BufferListCopyDeepMethodInfo
instance (signature ~ (m BufferList), MonadIO m) => O.OverloadedMethod BufferListCopyDeepMethodInfo BufferList signature where
overloadedMethod = bufferListCopyDeep
instance O.OverloadedMethodInfo BufferListCopyDeepMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListCopyDeep",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListCopyDeep"
})
#endif
foreign import ccall "gst_buffer_list_foreach" gst_buffer_list_foreach ::
Ptr BufferList ->
FunPtr Gst.Callbacks.C_BufferListFunc ->
Ptr () ->
IO CInt
bufferListForeach ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> Gst.Callbacks.BufferListFunc
-> m Bool
bufferListForeach :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> BufferListFunc -> m Bool
bufferListForeach BufferList
list BufferListFunc
func = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
FunPtr C_BufferListFunc
func' <- C_BufferListFunc -> IO (FunPtr C_BufferListFunc)
Gst.Callbacks.mk_BufferListFunc (Maybe (Ptr (FunPtr C_BufferListFunc))
-> BufferListFunc_WithClosures -> C_BufferListFunc
Gst.Callbacks.wrap_BufferListFunc Maybe (Ptr (FunPtr C_BufferListFunc))
forall a. Maybe a
Nothing (BufferListFunc -> BufferListFunc_WithClosures
Gst.Callbacks.drop_closures_BufferListFunc BufferListFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Ptr BufferList -> FunPtr C_BufferListFunc -> Ptr () -> IO CInt
gst_buffer_list_foreach Ptr BufferList
list' FunPtr C_BufferListFunc
func' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_BufferListFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BufferListFunc
func'
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferListForeachMethodInfo
instance (signature ~ (Gst.Callbacks.BufferListFunc -> m Bool), MonadIO m) => O.OverloadedMethod BufferListForeachMethodInfo BufferList signature where
overloadedMethod = bufferListForeach
instance O.OverloadedMethodInfo BufferListForeachMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListForeach",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListForeach"
})
#endif
foreign import ccall "gst_buffer_list_get" gst_buffer_list_get ::
Ptr BufferList ->
Word32 ->
IO (Ptr Gst.Buffer.Buffer)
bufferListGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> Word32
-> m (Maybe Gst.Buffer.Buffer)
bufferListGet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> Word32 -> m (Maybe Buffer)
bufferListGet BufferList
list Word32
idx = IO (Maybe Buffer) -> m (Maybe Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
Ptr Buffer
result <- Ptr BufferList -> Word32 -> IO (Ptr Buffer)
gst_buffer_list_get Ptr BufferList
list' Word32
idx
Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
result' -> do
Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferListGetMethodInfo
instance (signature ~ (Word32 -> m (Maybe Gst.Buffer.Buffer)), MonadIO m) => O.OverloadedMethod BufferListGetMethodInfo BufferList signature where
overloadedMethod = bufferListGet
instance O.OverloadedMethodInfo BufferListGetMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListGet",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListGet"
})
#endif
foreign import ccall "gst_buffer_list_get_writable" gst_buffer_list_get_writable ::
Ptr BufferList ->
Word32 ->
IO (Ptr Gst.Buffer.Buffer)
bufferListGetWritable ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> Word32
-> m (Maybe Gst.Buffer.Buffer)
bufferListGetWritable :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> Word32 -> m (Maybe Buffer)
bufferListGetWritable BufferList
list Word32
idx = IO (Maybe Buffer) -> m (Maybe Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
Ptr Buffer
result <- Ptr BufferList -> Word32 -> IO (Ptr Buffer)
gst_buffer_list_get_writable Ptr BufferList
list' Word32
idx
Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
result' -> do
Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferListGetWritableMethodInfo
instance (signature ~ (Word32 -> m (Maybe Gst.Buffer.Buffer)), MonadIO m) => O.OverloadedMethod BufferListGetWritableMethodInfo BufferList signature where
overloadedMethod = bufferListGetWritable
instance O.OverloadedMethodInfo BufferListGetWritableMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListGetWritable",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListGetWritable"
})
#endif
foreign import ccall "gst_buffer_list_insert" gst_buffer_list_insert ::
Ptr BufferList ->
Int32 ->
Ptr Gst.Buffer.Buffer ->
IO ()
bufferListInsert ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> Int32
-> Gst.Buffer.Buffer
-> m ()
bufferListInsert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> Int32 -> Buffer -> m ()
bufferListInsert BufferList
list Int32
idx Buffer
buffer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buffer
Ptr BufferList -> Int32 -> Ptr Buffer -> IO ()
gst_buffer_list_insert Ptr BufferList
list' Int32
idx Ptr Buffer
buffer'
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferListInsertMethodInfo
instance (signature ~ (Int32 -> Gst.Buffer.Buffer -> m ()), MonadIO m) => O.OverloadedMethod BufferListInsertMethodInfo BufferList signature where
overloadedMethod = bufferListInsert
instance O.OverloadedMethodInfo BufferListInsertMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListInsert",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListInsert"
})
#endif
foreign import ccall "gst_buffer_list_length" gst_buffer_list_length ::
Ptr BufferList ->
IO Word32
bufferListLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> m Word32
bufferListLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> m Word32
bufferListLength BufferList
list = IO Word32 -> m Word32
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 BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
Word32
result <- Ptr BufferList -> IO Word32
gst_buffer_list_length Ptr BufferList
list'
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data BufferListLengthMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod BufferListLengthMethodInfo BufferList signature where
overloadedMethod = bufferListLength
instance O.OverloadedMethodInfo BufferListLengthMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListLength",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListLength"
})
#endif
foreign import ccall "gst_buffer_list_remove" gst_buffer_list_remove ::
Ptr BufferList ->
Word32 ->
Word32 ->
IO ()
bufferListRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
BufferList
-> Word32
-> Word32
-> m ()
bufferListRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BufferList -> Word32 -> Word32 -> m ()
bufferListRemove BufferList
list Word32
idx Word32
length_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
list
Ptr BufferList -> Word32 -> Word32 -> IO ()
gst_buffer_list_remove Ptr BufferList
list' Word32
idx Word32
length_
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferListRemoveMethodInfo
instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m) => O.OverloadedMethod BufferListRemoveMethodInfo BufferList signature where
overloadedMethod = bufferListRemove
instance O.OverloadedMethodInfo BufferListRemoveMethodInfo BufferList where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.BufferList.bufferListRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-BufferList.html#v:bufferListRemove"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveBufferListMethod (t :: Symbol) (o :: *) :: * where
ResolveBufferListMethod "calculateSize" o = BufferListCalculateSizeMethodInfo
ResolveBufferListMethod "copyDeep" o = BufferListCopyDeepMethodInfo
ResolveBufferListMethod "foreach" o = BufferListForeachMethodInfo
ResolveBufferListMethod "get" o = BufferListGetMethodInfo
ResolveBufferListMethod "insert" o = BufferListInsertMethodInfo
ResolveBufferListMethod "length" o = BufferListLengthMethodInfo
ResolveBufferListMethod "remove" o = BufferListRemoveMethodInfo
ResolveBufferListMethod "getWritable" o = BufferListGetWritableMethodInfo
ResolveBufferListMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBufferListMethod t BufferList, O.OverloadedMethod info BufferList p) => OL.IsLabel t (BufferList -> 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 ~ ResolveBufferListMethod t BufferList, O.OverloadedMethod info BufferList p, R.HasField t BufferList p) => R.HasField t BufferList p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveBufferListMethod t BufferList, O.OverloadedMethodInfo info BufferList) => OL.IsLabel t (O.MethodProxy info BufferList) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif