{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Buffer lists are an object containing a list of buffers.
-- 
-- Buffer lists are created with 'GI.Gst.Structs.BufferList.bufferListNew' and filled with data
-- using a 'GI.Gst.Structs.BufferList.bufferListInsert'.
-- 
-- Buffer lists can be pushed on a srcpad with 'GI.Gst.Objects.Pad.padPushList'. This is
-- interesting when multiple buffers need to be pushed in one go because it
-- can reduce the amount of overhead for pushing each buffer individually.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gst.Structs.BufferList
    ( 

-- * Exported types
    BufferList(..)                          ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveBufferListMethod                 ,
#endif


-- ** calculateSize #method:calculateSize#

#if defined(ENABLE_OVERLOADING)
    BufferListCalculateSizeMethodInfo       ,
#endif
    bufferListCalculateSize                 ,


-- ** copyDeep #method:copyDeep#

#if defined(ENABLE_OVERLOADING)
    BufferListCopyDeepMethodInfo            ,
#endif
    bufferListCopyDeep                      ,


-- ** foreach #method:foreach#

#if defined(ENABLE_OVERLOADING)
    BufferListForeachMethodInfo             ,
#endif
    bufferListForeach                       ,


-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    BufferListGetMethodInfo                 ,
#endif
    bufferListGet                           ,


-- ** getWritable #method:getWritable#

#if defined(ENABLE_OVERLOADING)
    BufferListGetWritableMethodInfo         ,
#endif
    bufferListGetWritable                   ,


-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    BufferListInsertMethodInfo              ,
#endif
    bufferListInsert                        ,


-- ** length #method:length#

#if defined(ENABLE_OVERLOADING)
    BufferListLengthMethodInfo              ,
#endif
    bufferListLength                        ,


-- ** new #method:new#

    bufferListNew                           ,


-- ** newSized #method:newSized#

    bufferListNewSized                      ,


-- ** remove #method:remove#

#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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer

-- | Memory-managed wrapper type.
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

-- | Convert 'BufferList' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue BufferList where
    toGValue :: BufferList -> IO GValue
toGValue BufferList
o = do
        GType
gtype <- IO GType
c_gst_buffer_list_get_type
        BufferList -> (Ptr BufferList -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BufferList
o (GType
-> (GValue -> Ptr BufferList -> IO ())
-> Ptr BufferList
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr BufferList -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO BufferList
fromGValue GValue
gv = do
        Ptr BufferList
ptr <- GValue -> IO (Ptr BufferList)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr BufferList)
        (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
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BufferList
type instance O.AttributeList BufferList = BufferListAttributeList
type BufferListAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method BufferList::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "BufferList" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_new" gst_buffer_list_new :: 
    IO (Ptr BufferList)

-- | Creates a new, empty t'GI.Gst.Structs.BufferList.BufferList'. The caller is responsible for unreffing
-- the returned t'GI.Gst.Structs.BufferList.BufferList'.
-- 
-- Free-function: gst_buffer_list_unref
bufferListNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m BufferList
    -- ^ __Returns:__ the new t'GI.Gst.Structs.BufferList.BufferList'. @/gst_buffer_list_unref()/@
    --     after usage.
bufferListNew :: 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

-- method BufferList::new_sized
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "size"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an initial reserved size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "BufferList" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_new_sized" gst_buffer_list_new_sized :: 
    Word32 ->                               -- size : TBasicType TUInt
    IO (Ptr BufferList)

-- | Creates a new, empty t'GI.Gst.Structs.BufferList.BufferList'. The caller is responsible for unreffing
-- the returned t'GI.Gst.Structs.BufferList.BufferList'. The list will have /@size@/ space preallocated so
-- that memory reallocations can be avoided.
-- 
-- Free-function: gst_buffer_list_unref
bufferListNewSized ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    -- ^ /@size@/: an initial reserved size
    -> m BufferList
    -- ^ __Returns:__ the new t'GI.Gst.Structs.BufferList.BufferList'. @/gst_buffer_list_unref()/@
    --     after usage.
bufferListNewSized :: 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

-- method BufferList::calculate_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferList" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_calculate_size" gst_buffer_list_calculate_size :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    IO Word64

-- | Calculates the size of the data contained in buffer list by adding the
-- size of all buffers.
-- 
-- /Since: 1.14/
bufferListCalculateSize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a t'GI.Gst.Structs.BufferList.BufferList'
    -> m Word64
    -- ^ __Returns:__ the size of the data contained in buffer list in bytes.
bufferListCalculateSize :: 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.MethodInfo BufferListCalculateSizeMethodInfo BufferList signature where
    overloadedMethod = bufferListCalculateSize

#endif

-- method BufferList::copy_deep
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferList" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "BufferList" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_copy_deep" gst_buffer_list_copy_deep :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    IO (Ptr BufferList)

-- | Create a copy of the given buffer list. This will make a newly allocated
-- copy of the buffer that the source buffer list contains.
-- 
-- /Since: 1.6/
bufferListCopyDeep ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a t'GI.Gst.Structs.BufferList.BufferList'
    -> m BufferList
    -- ^ __Returns:__ a new copy of /@list@/.
bufferListCopyDeep :: 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.MethodInfo BufferListCopyDeepMethodInfo BufferList signature where
    overloadedMethod = bufferListCopyDeep

#endif

-- method BufferList::foreach
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferList" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferListFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferListFunc to call"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed to @func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_foreach" gst_buffer_list_foreach :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    FunPtr Gst.Callbacks.C_BufferListFunc -> -- func : TInterface (Name {namespace = "Gst", name = "BufferListFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO CInt

-- | Call /@func@/ with /@data@/ for each buffer in /@list@/.
-- 
-- /@func@/ can modify the passed buffer pointer or its contents. The return value
-- of /@func@/ define if this function returns or if the remaining buffers in
-- the list should be skipped.
bufferListForeach ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a t'GI.Gst.Structs.BufferList.BufferList'
    -> Gst.Callbacks.BufferListFunc
    -- ^ /@func@/: a t'GI.Gst.Callbacks.BufferListFunc' to call
    -> m Bool
    -- ^ __Returns:__ 'P.True' when /@func@/ returned 'P.True' for each buffer in /@list@/ or when
    -- /@list@/ is empty.
bufferListForeach :: 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.MethodInfo BufferListForeachMethodInfo BufferList signature where
    overloadedMethod = bufferListForeach

#endif

-- method BufferList::get
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferList" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Buffer" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_get" gst_buffer_list_get :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    Word32 ->                               -- idx : TBasicType TUInt
    IO (Ptr Gst.Buffer.Buffer)

-- | Get the buffer at /@idx@/.
-- 
-- You must make sure that /@idx@/ does not exceed the number of
-- buffers available.
bufferListGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a t'GI.Gst.Structs.BufferList.BufferList'
    -> Word32
    -- ^ /@idx@/: the index
    -> m (Maybe Gst.Buffer.Buffer)
    -- ^ __Returns:__ the buffer at /@idx@/ in /@group@/
    --     or 'P.Nothing' when there is no buffer. The buffer remains valid as
    --     long as /@list@/ is valid and buffer is not removed from the list.
bufferListGet :: 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.MethodInfo BufferListGetMethodInfo BufferList signature where
    overloadedMethod = bufferListGet

#endif

-- method BufferList::get_writable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a (writable) #GstBufferList"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Buffer" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_get_writable" gst_buffer_list_get_writable :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    Word32 ->                               -- idx : TBasicType TUInt
    IO (Ptr Gst.Buffer.Buffer)

-- | Gets the buffer at /@idx@/, ensuring it is a writable buffer.
-- 
-- You must make sure that /@idx@/ does not exceed the number of
-- buffers available.
-- 
-- /Since: 1.14/
bufferListGetWritable ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a (writable) t'GI.Gst.Structs.BufferList.BufferList'
    -> Word32
    -- ^ /@idx@/: the index
    -> m (Maybe Gst.Buffer.Buffer)
    -- ^ __Returns:__ the buffer at /@idx@/ in /@group@/.
    --     The returned  buffer remains valid as long as /@list@/ is valid and
    --     the buffer is not removed from the list.
bufferListGetWritable :: 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.MethodInfo BufferListGetWritableMethodInfo BufferList signature where
    overloadedMethod = bufferListGetWritable

#endif

-- method BufferList::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferList" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "buffer"
--           , argType = TInterface Name { namespace = "Gst" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBuffer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_insert" gst_buffer_list_insert :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    Int32 ->                                -- idx : TBasicType TInt
    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})
    IO ()

-- | Insert /@buffer@/ at /@idx@/ in /@list@/. Other buffers are moved to make room for
-- this new buffer.
-- 
-- A -1 value for /@idx@/ will append the buffer at the end.
bufferListInsert ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a t'GI.Gst.Structs.BufferList.BufferList'
    -> Int32
    -- ^ /@idx@/: the index
    -> Gst.Buffer.Buffer
    -- ^ /@buffer@/: a t'GI.Gst.Structs.Buffer.Buffer'
    -> m ()
bufferListInsert :: 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.MethodInfo BufferListInsertMethodInfo BufferList signature where
    overloadedMethod = bufferListInsert

#endif

-- method BufferList::length
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferList" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_length" gst_buffer_list_length :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    IO Word32

-- | Returns the number of buffers in /@list@/.
bufferListLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a t'GI.Gst.Structs.BufferList.BufferList'
    -> m Word32
    -- ^ __Returns:__ the number of buffers in the buffer list
bufferListLength :: 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.MethodInfo BufferListLengthMethodInfo BufferList signature where
    overloadedMethod = bufferListLength

#endif

-- method BufferList::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "list"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "BufferList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstBufferList" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the amount to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_buffer_list_remove" gst_buffer_list_remove :: 
    Ptr BufferList ->                       -- list : TInterface (Name {namespace = "Gst", name = "BufferList"})
    Word32 ->                               -- idx : TBasicType TUInt
    Word32 ->                               -- length : TBasicType TUInt
    IO ()

-- | Remove /@length@/ buffers starting from /@idx@/ in /@list@/. The following buffers
-- are moved to close the gap.
bufferListRemove ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    BufferList
    -- ^ /@list@/: a t'GI.Gst.Structs.BufferList.BufferList'
    -> Word32
    -- ^ /@idx@/: the index
    -> Word32
    -- ^ /@length@/: the amount to remove
    -> m ()
bufferListRemove :: 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.MethodInfo BufferListRemoveMethodInfo BufferList signature where
    overloadedMethod = 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.MethodInfo 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

#endif