{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Info passed in the t'GI.Gst.Callbacks.PadProbeCallback'.

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

module GI.Gst.Structs.PadProbeInfo
    ( 

-- * Exported types
    PadProbeInfo(..)                        ,
    newZeroPadProbeInfo                     ,
    noPadProbeInfo                          ,


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

#if defined(ENABLE_OVERLOADING)
    ResolvePadProbeInfoMethod               ,
#endif


-- ** getBuffer #method:getBuffer#

#if defined(ENABLE_OVERLOADING)
    PadProbeInfoGetBufferMethodInfo         ,
#endif
    padProbeInfoGetBuffer                   ,


-- ** getBufferList #method:getBufferList#

#if defined(ENABLE_OVERLOADING)
    PadProbeInfoGetBufferListMethodInfo     ,
#endif
    padProbeInfoGetBufferList               ,


-- ** getEvent #method:getEvent#

#if defined(ENABLE_OVERLOADING)
    PadProbeInfoGetEventMethodInfo          ,
#endif
    padProbeInfoGetEvent                    ,


-- ** getQuery #method:getQuery#

#if defined(ENABLE_OVERLOADING)
    PadProbeInfoGetQueryMethodInfo          ,
#endif
    padProbeInfoGetQuery                    ,




 -- * Properties
-- ** data #attr:data#
-- | type specific data, check the /@type@/ field to know the
--    datatype.  This field can be 'P.Nothing'.

    clearPadProbeInfoData                   ,
    getPadProbeInfoData                     ,
#if defined(ENABLE_OVERLOADING)
    padProbeInfo_data                       ,
#endif
    setPadProbeInfoData                     ,


-- ** id #attr:id#
-- | the id of the probe

    getPadProbeInfoId                       ,
#if defined(ENABLE_OVERLOADING)
    padProbeInfo_id                         ,
#endif
    setPadProbeInfoId                       ,


-- ** offset #attr:offset#
-- | offset of pull probe, this field is valid when /@type@/ contains
--    @/GST_PAD_PROBE_TYPE_PULL/@

    getPadProbeInfoOffset                   ,
#if defined(ENABLE_OVERLOADING)
    padProbeInfo_offset                     ,
#endif
    setPadProbeInfoOffset                   ,


-- ** size #attr:size#
-- | size of pull probe, this field is valid when /@type@/ contains
--    @/GST_PAD_PROBE_TYPE_PULL/@

    getPadProbeInfoSize                     ,
#if defined(ENABLE_OVERLOADING)
    padProbeInfo_size                       ,
#endif
    setPadProbeInfoSize                     ,


-- ** type #attr:type#
-- | the current probe type

    getPadProbeInfoType                     ,
#if defined(ENABLE_OVERLOADING)
    padProbeInfo_type                       ,
#endif
    setPadProbeInfoType                     ,




    ) 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 {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.BufferList as Gst.BufferList
import {-# SOURCE #-} qualified GI.Gst.Structs.Event as Gst.Event
import {-# SOURCE #-} qualified GI.Gst.Structs.Query as Gst.Query

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

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

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


-- | A convenience alias for `Nothing` :: `Maybe` `PadProbeInfo`.
noPadProbeInfo :: Maybe PadProbeInfo
noPadProbeInfo :: Maybe PadProbeInfo
noPadProbeInfo = Maybe PadProbeInfo
forall a. Maybe a
Nothing

-- | Get the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' padProbeInfo #type
-- @
getPadProbeInfoType :: MonadIO m => PadProbeInfo -> m [Gst.Flags.PadProbeType]
getPadProbeInfoType :: PadProbeInfo -> m [PadProbeType]
getPadProbeInfoType s :: PadProbeInfo
s = IO [PadProbeType] -> m [PadProbeType]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [PadProbeType] -> m [PadProbeType])
-> IO [PadProbeType] -> m [PadProbeType]
forall a b. (a -> b) -> a -> b
$ PadProbeInfo
-> (Ptr PadProbeInfo -> IO [PadProbeType]) -> IO [PadProbeType]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO [PadProbeType]) -> IO [PadProbeType])
-> (Ptr PadProbeInfo -> IO [PadProbeType]) -> IO [PadProbeType]
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CUInt
    let val' :: [PadProbeType]
val' = CUInt -> [PadProbeType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [PadProbeType] -> IO [PadProbeType]
forall (m :: * -> *) a. Monad m => a -> m a
return [PadProbeType]
val'

-- | Set the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' padProbeInfo [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setPadProbeInfoType :: MonadIO m => PadProbeInfo -> [Gst.Flags.PadProbeType] -> m ()
setPadProbeInfoType :: PadProbeInfo -> [PadProbeType] -> m ()
setPadProbeInfoType s :: PadProbeInfo
s val :: [PadProbeType]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
    let val' :: CUInt
val' = [PadProbeType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadProbeType]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoTypeFieldInfo
instance AttrInfo PadProbeInfoTypeFieldInfo where
    type AttrBaseTypeConstraint PadProbeInfoTypeFieldInfo = (~) PadProbeInfo
    type AttrAllowedOps PadProbeInfoTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PadProbeInfoTypeFieldInfo = (~) [Gst.Flags.PadProbeType]
    type AttrTransferTypeConstraint PadProbeInfoTypeFieldInfo = (~)[Gst.Flags.PadProbeType]
    type AttrTransferType PadProbeInfoTypeFieldInfo = [Gst.Flags.PadProbeType]
    type AttrGetType PadProbeInfoTypeFieldInfo = [Gst.Flags.PadProbeType]
    type AttrLabel PadProbeInfoTypeFieldInfo = "type"
    type AttrOrigin PadProbeInfoTypeFieldInfo = PadProbeInfo
    attrGet = getPadProbeInfoType
    attrSet = setPadProbeInfoType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

padProbeInfo_type :: AttrLabelProxy "type"
padProbeInfo_type = AttrLabelProxy

#endif


-- | Get the value of the “@id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' padProbeInfo #id
-- @
getPadProbeInfoId :: MonadIO m => PadProbeInfo -> m CULong
getPadProbeInfoId :: PadProbeInfo -> m CULong
getPadProbeInfoId s :: PadProbeInfo
s = IO CULong -> m CULong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO CULong) -> IO CULong)
-> (Ptr PadProbeInfo -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
    CULong
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO CULong
    CULong -> IO CULong
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val

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

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoIdFieldInfo
instance AttrInfo PadProbeInfoIdFieldInfo where
    type AttrBaseTypeConstraint PadProbeInfoIdFieldInfo = (~) PadProbeInfo
    type AttrAllowedOps PadProbeInfoIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PadProbeInfoIdFieldInfo = (~) CULong
    type AttrTransferTypeConstraint PadProbeInfoIdFieldInfo = (~)CULong
    type AttrTransferType PadProbeInfoIdFieldInfo = CULong
    type AttrGetType PadProbeInfoIdFieldInfo = CULong
    type AttrLabel PadProbeInfoIdFieldInfo = "id"
    type AttrOrigin PadProbeInfoIdFieldInfo = PadProbeInfo
    attrGet = getPadProbeInfoId
    attrSet = setPadProbeInfoId
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

padProbeInfo_id :: AttrLabelProxy "id"
padProbeInfo_id = AttrLabelProxy

#endif


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

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

-- | Set the value of the “@data@” 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' #data
-- @
clearPadProbeInfoData :: MonadIO m => PadProbeInfo -> m ()
clearPadProbeInfoData :: PadProbeInfo -> m ()
clearPadProbeInfoData s :: PadProbeInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr ()
forall a. Ptr a
FP.nullPtr :: Ptr ())

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoDataFieldInfo
instance AttrInfo PadProbeInfoDataFieldInfo where
    type AttrBaseTypeConstraint PadProbeInfoDataFieldInfo = (~) PadProbeInfo
    type AttrAllowedOps PadProbeInfoDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PadProbeInfoDataFieldInfo = (~) (Ptr ())
    type AttrTransferTypeConstraint PadProbeInfoDataFieldInfo = (~)(Ptr ())
    type AttrTransferType PadProbeInfoDataFieldInfo = (Ptr ())
    type AttrGetType PadProbeInfoDataFieldInfo = Ptr ()
    type AttrLabel PadProbeInfoDataFieldInfo = "data"
    type AttrOrigin PadProbeInfoDataFieldInfo = PadProbeInfo
    attrGet = getPadProbeInfoData
    attrSet = setPadProbeInfoData
    attrConstruct = undefined
    attrClear = clearPadProbeInfoData
    attrTransfer _ v = do
        return v

padProbeInfo_data :: AttrLabelProxy "data"
padProbeInfo_data = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoOffsetFieldInfo
instance AttrInfo PadProbeInfoOffsetFieldInfo where
    type AttrBaseTypeConstraint PadProbeInfoOffsetFieldInfo = (~) PadProbeInfo
    type AttrAllowedOps PadProbeInfoOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PadProbeInfoOffsetFieldInfo = (~) Word64
    type AttrTransferTypeConstraint PadProbeInfoOffsetFieldInfo = (~)Word64
    type AttrTransferType PadProbeInfoOffsetFieldInfo = Word64
    type AttrGetType PadProbeInfoOffsetFieldInfo = Word64
    type AttrLabel PadProbeInfoOffsetFieldInfo = "offset"
    type AttrOrigin PadProbeInfoOffsetFieldInfo = PadProbeInfo
    attrGet = getPadProbeInfoOffset
    attrSet = setPadProbeInfoOffset
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

padProbeInfo_offset :: AttrLabelProxy "offset"
padProbeInfo_offset = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoSizeFieldInfo
instance AttrInfo PadProbeInfoSizeFieldInfo where
    type AttrBaseTypeConstraint PadProbeInfoSizeFieldInfo = (~) PadProbeInfo
    type AttrAllowedOps PadProbeInfoSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PadProbeInfoSizeFieldInfo = (~) Word32
    type AttrTransferTypeConstraint PadProbeInfoSizeFieldInfo = (~)Word32
    type AttrTransferType PadProbeInfoSizeFieldInfo = Word32
    type AttrGetType PadProbeInfoSizeFieldInfo = Word32
    type AttrLabel PadProbeInfoSizeFieldInfo = "size"
    type AttrOrigin PadProbeInfoSizeFieldInfo = PadProbeInfo
    attrGet = getPadProbeInfoSize
    attrSet = setPadProbeInfoSize
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

padProbeInfo_size :: AttrLabelProxy "size"
padProbeInfo_size = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PadProbeInfo
type instance O.AttributeList PadProbeInfo = PadProbeInfoAttributeList
type PadProbeInfoAttributeList = ('[ '("type", PadProbeInfoTypeFieldInfo), '("id", PadProbeInfoIdFieldInfo), '("data", PadProbeInfoDataFieldInfo), '("offset", PadProbeInfoOffsetFieldInfo), '("size", PadProbeInfoSizeFieldInfo)] :: [(Symbol, *)])
#endif

-- method PadProbeInfo::get_buffer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "PadProbeInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstPadProbeInfo" , 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_pad_probe_info_get_buffer" gst_pad_probe_info_get_buffer :: 
    Ptr PadProbeInfo ->                     -- info : TInterface (Name {namespace = "Gst", name = "PadProbeInfo"})
    IO (Ptr Gst.Buffer.Buffer)

-- | /No description available in the introspection data./
padProbeInfoGetBuffer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PadProbeInfo
    -- ^ /@info@/: a t'GI.Gst.Structs.PadProbeInfo.PadProbeInfo'
    -> m (Maybe Gst.Buffer.Buffer)
    -- ^ __Returns:__ The t'GI.Gst.Structs.Buffer.Buffer' from the probe
padProbeInfoGetBuffer :: PadProbeInfo -> m (Maybe Buffer)
padProbeInfoGetBuffer info :: PadProbeInfo
info = 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 PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
    Ptr Buffer
result <- Ptr PadProbeInfo -> IO (Ptr Buffer)
gst_pad_probe_info_get_buffer Ptr PadProbeInfo
info'
    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
$ \result' :: Ptr Buffer
result' -> do
        Buffer
result'' <- ((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
result'
        Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
    PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
    Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetBufferMethodInfo
instance (signature ~ (m (Maybe Gst.Buffer.Buffer)), MonadIO m) => O.MethodInfo PadProbeInfoGetBufferMethodInfo PadProbeInfo signature where
    overloadedMethod = padProbeInfoGetBuffer

#endif

-- method PadProbeInfo::get_buffer_list
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "PadProbeInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstPadProbeInfo" , 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_pad_probe_info_get_buffer_list" gst_pad_probe_info_get_buffer_list :: 
    Ptr PadProbeInfo ->                     -- info : TInterface (Name {namespace = "Gst", name = "PadProbeInfo"})
    IO (Ptr Gst.BufferList.BufferList)

-- | /No description available in the introspection data./
padProbeInfoGetBufferList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PadProbeInfo
    -- ^ /@info@/: a t'GI.Gst.Structs.PadProbeInfo.PadProbeInfo'
    -> m (Maybe Gst.BufferList.BufferList)
    -- ^ __Returns:__ The t'GI.Gst.Structs.BufferList.BufferList' from the probe
padProbeInfoGetBufferList :: PadProbeInfo -> m (Maybe BufferList)
padProbeInfoGetBufferList info :: PadProbeInfo
info = IO (Maybe BufferList) -> m (Maybe BufferList)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BufferList) -> m (Maybe BufferList))
-> IO (Maybe BufferList) -> m (Maybe BufferList)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
    Ptr BufferList
result <- Ptr PadProbeInfo -> IO (Ptr BufferList)
gst_pad_probe_info_get_buffer_list Ptr PadProbeInfo
info'
    Maybe BufferList
maybeResult <- Ptr BufferList
-> (Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BufferList
result ((Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList))
-> (Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr BufferList
result' -> do
        BufferList
result'' <- ((ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr BufferList -> BufferList
Gst.BufferList.BufferList) Ptr BufferList
result'
        BufferList -> IO BufferList
forall (m :: * -> *) a. Monad m => a -> m a
return BufferList
result''
    PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
    Maybe BufferList -> IO (Maybe BufferList)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BufferList
maybeResult

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetBufferListMethodInfo
instance (signature ~ (m (Maybe Gst.BufferList.BufferList)), MonadIO m) => O.MethodInfo PadProbeInfoGetBufferListMethodInfo PadProbeInfo signature where
    overloadedMethod = padProbeInfoGetBufferList

#endif

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

foreign import ccall "gst_pad_probe_info_get_event" gst_pad_probe_info_get_event :: 
    Ptr PadProbeInfo ->                     -- info : TInterface (Name {namespace = "Gst", name = "PadProbeInfo"})
    IO (Ptr Gst.Event.Event)

-- | /No description available in the introspection data./
padProbeInfoGetEvent ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PadProbeInfo
    -- ^ /@info@/: a t'GI.Gst.Structs.PadProbeInfo.PadProbeInfo'
    -> m (Maybe Gst.Event.Event)
    -- ^ __Returns:__ The t'GI.Gst.Structs.Event.Event' from the probe
padProbeInfoGetEvent :: PadProbeInfo -> m (Maybe Event)
padProbeInfoGetEvent info :: PadProbeInfo
info = IO (Maybe Event) -> m (Maybe Event)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Event) -> m (Maybe Event))
-> IO (Maybe Event) -> m (Maybe Event)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
    Ptr Event
result <- Ptr PadProbeInfo -> IO (Ptr Event)
gst_pad_probe_info_get_event Ptr PadProbeInfo
info'
    Maybe Event
maybeResult <- Ptr Event -> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Event
result ((Ptr Event -> IO Event) -> IO (Maybe Event))
-> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Event
result' -> do
        Event
result'' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Event -> Event
Gst.Event.Event) Ptr Event
result'
        Event -> IO Event
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result''
    PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
    Maybe Event -> IO (Maybe Event)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Event
maybeResult

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetEventMethodInfo
instance (signature ~ (m (Maybe Gst.Event.Event)), MonadIO m) => O.MethodInfo PadProbeInfoGetEventMethodInfo PadProbeInfo signature where
    overloadedMethod = padProbeInfoGetEvent

#endif

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

foreign import ccall "gst_pad_probe_info_get_query" gst_pad_probe_info_get_query :: 
    Ptr PadProbeInfo ->                     -- info : TInterface (Name {namespace = "Gst", name = "PadProbeInfo"})
    IO (Ptr Gst.Query.Query)

-- | /No description available in the introspection data./
padProbeInfoGetQuery ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    PadProbeInfo
    -- ^ /@info@/: a t'GI.Gst.Structs.PadProbeInfo.PadProbeInfo'
    -> m (Maybe Gst.Query.Query)
    -- ^ __Returns:__ The t'GI.Gst.Structs.Query.Query' from the probe
padProbeInfoGetQuery :: PadProbeInfo -> m (Maybe Query)
padProbeInfoGetQuery info :: PadProbeInfo
info = IO (Maybe Query) -> m (Maybe Query)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Query) -> m (Maybe Query))
-> IO (Maybe Query) -> m (Maybe Query)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
    Ptr Query
result <- Ptr PadProbeInfo -> IO (Ptr Query)
gst_pad_probe_info_get_query Ptr PadProbeInfo
info'
    Maybe Query
maybeResult <- Ptr Query -> (Ptr Query -> IO Query) -> IO (Maybe Query)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Query
result ((Ptr Query -> IO Query) -> IO (Maybe Query))
-> (Ptr Query -> IO Query) -> IO (Maybe Query)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Query
result' -> do
        Query
result'' <- ((ManagedPtr Query -> Query) -> Ptr Query -> IO Query
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Query -> Query
Gst.Query.Query) Ptr Query
result'
        Query -> IO Query
forall (m :: * -> *) a. Monad m => a -> m a
return Query
result''
    PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
    Maybe Query -> IO (Maybe Query)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Query
maybeResult

#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetQueryMethodInfo
instance (signature ~ (m (Maybe Gst.Query.Query)), MonadIO m) => O.MethodInfo PadProbeInfoGetQueryMethodInfo PadProbeInfo signature where
    overloadedMethod = padProbeInfoGetQuery

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolvePadProbeInfoMethod (t :: Symbol) (o :: *) :: * where
    ResolvePadProbeInfoMethod "getBuffer" o = PadProbeInfoGetBufferMethodInfo
    ResolvePadProbeInfoMethod "getBufferList" o = PadProbeInfoGetBufferListMethodInfo
    ResolvePadProbeInfoMethod "getEvent" o = PadProbeInfoGetEventMethodInfo
    ResolvePadProbeInfoMethod "getQuery" o = PadProbeInfoGetQueryMethodInfo
    ResolvePadProbeInfoMethod l o = O.MethodResolutionFailed l o

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

#endif