{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

Structure used by the collect_pads.
-}

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

module GI.GstBase.Structs.CollectData
    ( 

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


 -- * Properties
-- ** buffer #attr:buffer#
{- | currently queued buffer.
-}
    clearCollectDataBuffer                  ,
#if ENABLE_OVERLOADING
    collectData_buffer                      ,
#endif
    getCollectDataBuffer                    ,
    setCollectDataBuffer                    ,


-- ** collect #attr:collect#
{- | owner 'GI.GstBase.Objects.CollectPads.CollectPads'
-}
    clearCollectDataCollect                 ,
#if ENABLE_OVERLOADING
    collectData_collect                     ,
#endif
    getCollectDataCollect                   ,
    setCollectDataCollect                   ,


-- ** pad #attr:pad#
{- | 'GI.Gst.Objects.Pad.Pad' managed by this data
-}
    clearCollectDataPad                     ,
#if ENABLE_OVERLOADING
    collectData_pad                         ,
#endif
    getCollectDataPad                       ,
    setCollectDataPad                       ,


-- ** pos #attr:pos#
{- | position in the buffer
-}
#if ENABLE_OVERLOADING
    collectData_pos                         ,
#endif
    getCollectDataPos                       ,
    setCollectDataPos                       ,


-- ** segment #attr:segment#
{- | last segment received.
-}
#if 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.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)
instance WrappedPtr CollectData where
    wrappedPtrCalloc = callocBytes 168
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 168 >=> wrapPtr CollectData)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `CollectData` struct initialized to zero.
newZeroCollectData :: MonadIO m => m CollectData
newZeroCollectData = liftIO $ wrappedPtrCalloc >>= wrapPtr CollectData

instance tag ~ 'AttrSet => Constructible CollectData tag where
    new _ attrs = do
        o <- newZeroCollectData
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `CollectData`.
noCollectData :: Maybe CollectData
noCollectData = 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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr GstBase.CollectPads.CollectPads)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject GstBase.CollectPads.CollectPads) val'
        return val''
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr GstBase.CollectPads.CollectPads)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.Pad.Pad)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gst.Pad.Pad) val'
        return val''
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.Pad.Pad)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gst.Buffer.Buffer)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed Gst.Buffer.Buffer) val'
        return val''
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    let val = ptr `plusPtr` 32 :: (Ptr Gst.Segment.Segment)
    val' <- (newBoxed Gst.Segment.Segment) val
    return val'

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

collectData_segment :: AttrLabelProxy "segment"
collectData_segment = AttrLabelProxy

#endif



#if 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 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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif