{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Structure used by the collect_pads.

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

module GI.GstBase.Structs.CollectData
    ( 

-- * Exported types
    CollectData(..)                         ,
    newZeroCollectData                      ,
    noCollectData                           ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveCollectDataMethod                ,
#endif




 -- * Properties
-- ** buffer #attr:buffer#
-- | currently queued buffer.

    clearCollectDataBuffer                  ,
#if defined(ENABLE_OVERLOADING)
    collectData_buffer                      ,
#endif
    getCollectDataBuffer                    ,
    setCollectDataBuffer                    ,


-- ** collect #attr:collect#
-- | owner t'GI.GstBase.Objects.CollectPads.CollectPads'

    clearCollectDataCollect                 ,
#if defined(ENABLE_OVERLOADING)
    collectData_collect                     ,
#endif
    getCollectDataCollect                   ,
    setCollectDataCollect                   ,


-- ** pad #attr:pad#
-- | t'GI.Gst.Objects.Pad.Pad' managed by this data

    clearCollectDataPad                     ,
#if defined(ENABLE_OVERLOADING)
    collectData_pad                         ,
#endif
    getCollectDataPad                       ,
    setCollectDataPad                       ,


-- ** pos #attr:pos#
-- | position in the buffer

#if defined(ENABLE_OVERLOADING)
    collectData_pos                         ,
#endif
    getCollectDataPos                       ,
    setCollectDataPos                       ,


-- ** segment #attr:segment#
-- | last segment received.

#if defined(ENABLE_OVERLOADING)
    collectData_segment                     ,
#endif
    getCollectDataSegment                   ,




    ) 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.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 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.Objects.Pad as Gst.Pad
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.Segment as Gst.Segment
import {-# SOURCE #-} qualified GI.GstBase.Objects.CollectPads as GstBase.CollectPads

-- | Memory-managed wrapper type.
newtype CollectData = CollectData (ManagedPtr CollectData)
    deriving (CollectData -> CollectData -> Bool
(CollectData -> CollectData -> Bool)
-> (CollectData -> CollectData -> Bool) -> Eq CollectData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CollectData -> CollectData -> Bool
$c/= :: CollectData -> CollectData -> Bool
== :: CollectData -> CollectData -> Bool
$c== :: CollectData -> CollectData -> Bool
Eq)
instance WrappedPtr CollectData where
    wrappedPtrCalloc :: IO (Ptr CollectData)
wrappedPtrCalloc = Int -> IO (Ptr CollectData)
forall a. Int -> IO (Ptr a)
callocBytes 168
    wrappedPtrCopy :: CollectData -> IO CollectData
wrappedPtrCopy = \p :: CollectData
p -> CollectData
-> (Ptr CollectData -> IO CollectData) -> IO CollectData
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
p (Int -> Ptr CollectData -> IO (Ptr CollectData)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 168 (Ptr CollectData -> IO (Ptr CollectData))
-> (Ptr CollectData -> IO CollectData)
-> Ptr CollectData
-> IO CollectData
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CollectData -> CollectData
CollectData)
    wrappedPtrFree :: Maybe (GDestroyNotify CollectData)
wrappedPtrFree = GDestroyNotify CollectData -> Maybe (GDestroyNotify CollectData)
forall a. a -> Maybe a
Just GDestroyNotify CollectData
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `CollectData` struct initialized to zero.
newZeroCollectData :: MonadIO m => m CollectData
newZeroCollectData :: m CollectData
newZeroCollectData = IO CollectData -> m CollectData
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CollectData -> m CollectData)
-> IO CollectData -> m CollectData
forall a b. (a -> b) -> a -> b
$ IO (Ptr CollectData)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr CollectData)
-> (Ptr CollectData -> IO CollectData) -> IO CollectData
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr CollectData -> CollectData
CollectData

instance tag ~ 'AttrSet => Constructible CollectData tag where
    new :: (ManagedPtr CollectData -> CollectData)
-> [AttrOp CollectData tag] -> m CollectData
new _ attrs :: [AttrOp CollectData tag]
attrs = do
        CollectData
o <- m CollectData
forall (m :: * -> *). MonadIO m => m CollectData
newZeroCollectData
        CollectData -> [AttrOp CollectData 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set CollectData
o [AttrOp CollectData tag]
[AttrOp CollectData 'AttrSet]
attrs
        CollectData -> m CollectData
forall (m :: * -> *) a. Monad m => a -> m a
return CollectData
o


-- | A convenience alias for `Nothing` :: `Maybe` `CollectData`.
noCollectData :: Maybe CollectData
noCollectData :: Maybe CollectData
noCollectData = Maybe CollectData
forall a. Maybe a
Nothing

-- | Get the value of the “@collect@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' collectData #collect
-- @
getCollectDataCollect :: MonadIO m => CollectData -> m (Maybe GstBase.CollectPads.CollectPads)
getCollectDataCollect :: CollectData -> m (Maybe CollectPads)
getCollectDataCollect s :: CollectData
s = IO (Maybe CollectPads) -> m (Maybe CollectPads)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe CollectPads) -> m (Maybe CollectPads))
-> IO (Maybe CollectPads) -> m (Maybe CollectPads)
forall a b. (a -> b) -> a -> b
$ CollectData
-> (Ptr CollectData -> IO (Maybe CollectPads))
-> IO (Maybe CollectPads)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO (Maybe CollectPads))
 -> IO (Maybe CollectPads))
-> (Ptr CollectData -> IO (Maybe CollectPads))
-> IO (Maybe CollectPads)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr CollectPads
val <- Ptr (Ptr CollectPads) -> IO (Ptr CollectPads)
forall a. Storable a => Ptr a -> IO a
peek (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr CollectPads)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO (Ptr GstBase.CollectPads.CollectPads)
    Maybe CollectPads
result <- Ptr CollectPads
-> (Ptr CollectPads -> IO CollectPads) -> IO (Maybe CollectPads)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr CollectPads
val ((Ptr CollectPads -> IO CollectPads) -> IO (Maybe CollectPads))
-> (Ptr CollectPads -> IO CollectPads) -> IO (Maybe CollectPads)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr CollectPads
val' -> do
        CollectPads
val'' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
val'
        CollectPads -> IO CollectPads
forall (m :: * -> *) a. Monad m => a -> m a
return CollectPads
val''
    Maybe CollectPads -> IO (Maybe CollectPads)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CollectPads
result

-- | Set the value of the “@collect@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' collectData [ #collect 'Data.GI.Base.Attributes.:=' value ]
-- @
setCollectDataCollect :: MonadIO m => CollectData -> Ptr GstBase.CollectPads.CollectPads -> m ()
setCollectDataCollect :: CollectData -> Ptr CollectPads -> m ()
setCollectDataCollect s :: CollectData
s val :: Ptr CollectPads
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO ()) -> IO ())
-> (Ptr CollectData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr (Ptr CollectPads) -> Ptr CollectPads -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr CollectPads)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Ptr CollectPads
val :: Ptr GstBase.CollectPads.CollectPads)

-- | Set the value of the “@collect@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #collect
-- @
clearCollectDataCollect :: MonadIO m => CollectData -> m ()
clearCollectDataCollect :: CollectData -> m ()
clearCollectDataCollect s :: CollectData
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO ()) -> IO ())
-> (Ptr CollectData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr (Ptr CollectPads) -> Ptr CollectPads -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr CollectPads)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Ptr CollectPads
forall a. Ptr a
FP.nullPtr :: Ptr GstBase.CollectPads.CollectPads)

#if defined(ENABLE_OVERLOADING)
data CollectDataCollectFieldInfo
instance AttrInfo CollectDataCollectFieldInfo where
    type AttrBaseTypeConstraint CollectDataCollectFieldInfo = (~) CollectData
    type AttrAllowedOps CollectDataCollectFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectDataCollectFieldInfo = (~) (Ptr GstBase.CollectPads.CollectPads)
    type AttrTransferTypeConstraint CollectDataCollectFieldInfo = (~)(Ptr GstBase.CollectPads.CollectPads)
    type AttrTransferType CollectDataCollectFieldInfo = (Ptr GstBase.CollectPads.CollectPads)
    type AttrGetType CollectDataCollectFieldInfo = Maybe GstBase.CollectPads.CollectPads
    type AttrLabel CollectDataCollectFieldInfo = "collect"
    type AttrOrigin CollectDataCollectFieldInfo = CollectData
    attrGet = getCollectDataCollect
    attrSet = setCollectDataCollect
    attrConstruct = undefined
    attrClear = clearCollectDataCollect
    attrTransfer _ v = do
        return v

collectData_collect :: AttrLabelProxy "collect"
collectData_collect = AttrLabelProxy

#endif


-- | Get the value of the “@pad@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' collectData #pad
-- @
getCollectDataPad :: MonadIO m => CollectData -> m (Maybe Gst.Pad.Pad)
getCollectDataPad :: CollectData -> m (Maybe Pad)
getCollectDataPad s :: CollectData
s = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ CollectData
-> (Ptr CollectData -> IO (Maybe Pad)) -> IO (Maybe Pad)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO (Maybe Pad)) -> IO (Maybe Pad))
-> (Ptr CollectData -> IO (Maybe Pad)) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr Pad
val <- Ptr (Ptr Pad) -> IO (Ptr Pad)
forall a. Storable a => Ptr a -> IO a
peek (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr Pad)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO (Ptr Gst.Pad.Pad)
    Maybe Pad
result <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Pad
val ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr Pad
val' -> do
        Pad
val'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Gst.Pad.Pad) Ptr Pad
val'
        Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
val''
    Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
result

-- | Set the value of the “@pad@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' collectData [ #pad 'Data.GI.Base.Attributes.:=' value ]
-- @
setCollectDataPad :: MonadIO m => CollectData -> Ptr Gst.Pad.Pad -> m ()
setCollectDataPad :: CollectData -> Ptr Pad -> m ()
setCollectDataPad s :: CollectData
s val :: Ptr Pad
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO ()) -> IO ())
-> (Ptr CollectData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr (Ptr Pad) -> Ptr Pad -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr Pad)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (Ptr Pad
val :: Ptr Gst.Pad.Pad)

-- | Set the value of the “@pad@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #pad
-- @
clearCollectDataPad :: MonadIO m => CollectData -> m ()
clearCollectDataPad :: CollectData -> m ()
clearCollectDataPad s :: CollectData
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO ()) -> IO ())
-> (Ptr CollectData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr (Ptr Pad) -> Ptr Pad -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr Pad)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (Ptr Pad
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Pad.Pad)

#if defined(ENABLE_OVERLOADING)
data CollectDataPadFieldInfo
instance AttrInfo CollectDataPadFieldInfo where
    type AttrBaseTypeConstraint CollectDataPadFieldInfo = (~) CollectData
    type AttrAllowedOps CollectDataPadFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectDataPadFieldInfo = (~) (Ptr Gst.Pad.Pad)
    type AttrTransferTypeConstraint CollectDataPadFieldInfo = (~)(Ptr Gst.Pad.Pad)
    type AttrTransferType CollectDataPadFieldInfo = (Ptr Gst.Pad.Pad)
    type AttrGetType CollectDataPadFieldInfo = Maybe Gst.Pad.Pad
    type AttrLabel CollectDataPadFieldInfo = "pad"
    type AttrOrigin CollectDataPadFieldInfo = CollectData
    attrGet = getCollectDataPad
    attrSet = setCollectDataPad
    attrConstruct = undefined
    attrClear = clearCollectDataPad
    attrTransfer _ v = do
        return v

collectData_pad :: AttrLabelProxy "pad"
collectData_pad = AttrLabelProxy

#endif


-- | Get the value of the “@buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' collectData #buffer
-- @
getCollectDataBuffer :: MonadIO m => CollectData -> m (Maybe Gst.Buffer.Buffer)
getCollectDataBuffer :: CollectData -> m (Maybe Buffer)
getCollectDataBuffer s :: CollectData
s = 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
$ CollectData
-> (Ptr CollectData -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO (Maybe Buffer)) -> IO (Maybe Buffer))
-> (Ptr CollectData -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr Buffer
val <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (Ptr Gst.Buffer.Buffer)
    Maybe Buffer
result <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Buffer
val ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr Buffer
val' -> do
        Buffer
val'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
val'
        Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
val''
    Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
result

-- | Set the value of the “@buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' collectData [ #buffer 'Data.GI.Base.Attributes.:=' value ]
-- @
setCollectDataBuffer :: MonadIO m => CollectData -> Ptr Gst.Buffer.Buffer -> m ()
setCollectDataBuffer :: CollectData -> Ptr Buffer -> m ()
setCollectDataBuffer s :: CollectData
s val :: Ptr Buffer
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO ()) -> IO ())
-> (Ptr CollectData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr Buffer
val :: Ptr Gst.Buffer.Buffer)

-- | Set the value of the “@buffer@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #buffer
-- @
clearCollectDataBuffer :: MonadIO m => CollectData -> m ()
clearCollectDataBuffer :: CollectData -> m ()
clearCollectDataBuffer s :: CollectData
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO ()) -> IO ())
-> (Ptr CollectData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr Buffer
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING)
data CollectDataBufferFieldInfo
instance AttrInfo CollectDataBufferFieldInfo where
    type AttrBaseTypeConstraint CollectDataBufferFieldInfo = (~) CollectData
    type AttrAllowedOps CollectDataBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectDataBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrTransferTypeConstraint CollectDataBufferFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
    type AttrTransferType CollectDataBufferFieldInfo = (Ptr Gst.Buffer.Buffer)
    type AttrGetType CollectDataBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel CollectDataBufferFieldInfo = "buffer"
    type AttrOrigin CollectDataBufferFieldInfo = CollectData
    attrGet = getCollectDataBuffer
    attrSet = setCollectDataBuffer
    attrConstruct = undefined
    attrClear = clearCollectDataBuffer
    attrTransfer _ v = do
        return v

collectData_buffer :: AttrLabelProxy "buffer"
collectData_buffer = AttrLabelProxy

#endif


-- | Get the value of the “@pos@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' collectData #pos
-- @
getCollectDataPos :: MonadIO m => CollectData -> m Word32
getCollectDataPos :: CollectData -> m Word32
getCollectDataPos s :: CollectData
s = 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
$ CollectData -> (Ptr CollectData -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO Word32) -> IO Word32)
-> (Ptr CollectData -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@pos@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' collectData [ #pos 'Data.GI.Base.Attributes.:=' value ]
-- @
setCollectDataPos :: MonadIO m => CollectData -> Word32 -> m ()
setCollectDataPos :: CollectData -> Word32 -> m ()
setCollectDataPos s :: CollectData
s val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO ()) -> IO ())
-> (Ptr CollectData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data CollectDataPosFieldInfo
instance AttrInfo CollectDataPosFieldInfo where
    type AttrBaseTypeConstraint CollectDataPosFieldInfo = (~) CollectData
    type AttrAllowedOps CollectDataPosFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint CollectDataPosFieldInfo = (~) Word32
    type AttrTransferTypeConstraint CollectDataPosFieldInfo = (~)Word32
    type AttrTransferType CollectDataPosFieldInfo = Word32
    type AttrGetType CollectDataPosFieldInfo = Word32
    type AttrLabel CollectDataPosFieldInfo = "pos"
    type AttrOrigin CollectDataPosFieldInfo = CollectData
    attrGet = getCollectDataPos
    attrSet = setCollectDataPos
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

collectData_pos :: AttrLabelProxy "pos"
collectData_pos = AttrLabelProxy

#endif


-- | Get the value of the “@segment@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' collectData #segment
-- @
getCollectDataSegment :: MonadIO m => CollectData -> m Gst.Segment.Segment
getCollectDataSegment :: CollectData -> m Segment
getCollectDataSegment s :: CollectData
s = IO Segment -> m Segment
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Segment -> m Segment) -> IO Segment -> m Segment
forall a b. (a -> b) -> a -> b
$ CollectData -> (Ptr CollectData -> IO Segment) -> IO Segment
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CollectData
s ((Ptr CollectData -> IO Segment) -> IO Segment)
-> (Ptr CollectData -> IO Segment) -> IO Segment
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr CollectData
ptr -> do
    let val :: Ptr Segment
val = Ptr CollectData
ptr Ptr CollectData -> Int -> Ptr Segment
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32 :: (Ptr Gst.Segment.Segment)
    Segment
val' <- ((ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Segment -> Segment
Gst.Segment.Segment) Ptr Segment
val
    Segment -> IO Segment
forall (m :: * -> *) a. Monad m => a -> m a
return Segment
val'

#if defined(ENABLE_OVERLOADING)
data CollectDataSegmentFieldInfo
instance AttrInfo CollectDataSegmentFieldInfo where
    type AttrBaseTypeConstraint CollectDataSegmentFieldInfo = (~) CollectData
    type AttrAllowedOps CollectDataSegmentFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint CollectDataSegmentFieldInfo = (~) (Ptr Gst.Segment.Segment)
    type AttrTransferTypeConstraint CollectDataSegmentFieldInfo = (~)(Ptr Gst.Segment.Segment)
    type AttrTransferType CollectDataSegmentFieldInfo = (Ptr Gst.Segment.Segment)
    type AttrGetType CollectDataSegmentFieldInfo = Gst.Segment.Segment
    type AttrLabel CollectDataSegmentFieldInfo = "segment"
    type AttrOrigin CollectDataSegmentFieldInfo = CollectData
    attrGet = getCollectDataSegment
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

collectData_segment :: AttrLabelProxy "segment"
collectData_segment = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CollectData
type instance O.AttributeList CollectData = CollectDataAttributeList
type CollectDataAttributeList = ('[ '("collect", CollectDataCollectFieldInfo), '("pad", CollectDataPadFieldInfo), '("buffer", CollectDataBufferFieldInfo), '("pos", CollectDataPosFieldInfo), '("segment", CollectDataSegmentFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCollectDataMethod (t :: Symbol) (o :: *) :: * where
    ResolveCollectDataMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCollectDataMethod t CollectData, O.MethodInfo info CollectData p) => OL.IsLabel t (CollectData -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif