{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- VTable for the t'GI.GObject.Structs.Value.Value' /@type@/.

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

module GI.Gst.Structs.ValueTable
    ( 

-- * Exported types
    ValueTable(..)                          ,
    newZeroValueTable                       ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveValueTableMethod                 ,
#endif



 -- * Properties


-- ** compare #attr:compare#
-- | a t'GI.Gst.Callbacks.ValueCompareFunc'

    clearValueTableCompare                  ,
    getValueTableCompare                    ,
    setValueTableCompare                    ,
#if defined(ENABLE_OVERLOADING)
    valueTable_compare                      ,
#endif


-- ** deserialize #attr:deserialize#
-- | a t'GI.Gst.Callbacks.ValueDeserializeFunc'

    clearValueTableDeserialize              ,
    getValueTableDeserialize                ,
    setValueTableDeserialize                ,
#if defined(ENABLE_OVERLOADING)
    valueTable_deserialize                  ,
#endif


-- ** deserializeWithPspec #attr:deserializeWithPspec#
-- | a t'GI.Gst.Callbacks.ValueDeserializeWithPSpecFunc'
-- 
-- /Since: 1.20/

    clearValueTableDeserializeWithPspec     ,
    getValueTableDeserializeWithPspec       ,
    setValueTableDeserializeWithPspec       ,
#if defined(ENABLE_OVERLOADING)
    valueTable_deserializeWithPspec         ,
#endif


-- ** serialize #attr:serialize#
-- | a t'GI.Gst.Callbacks.ValueSerializeFunc'

    clearValueTableSerialize                ,
    getValueTableSerialize                  ,
    setValueTableSerialize                  ,
#if defined(ENABLE_OVERLOADING)
    valueTable_serialize                    ,
#endif


-- ** type #attr:type#
-- | a t'GType'

    getValueTableType                       ,
    setValueTableType                       ,
#if defined(ENABLE_OVERLOADING)
    valueTable_type                         ,
#endif




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.Gst.Callbacks as Gst.Callbacks

-- | Memory-managed wrapper type.
newtype ValueTable = ValueTable (SP.ManagedPtr ValueTable)
    deriving (ValueTable -> ValueTable -> Bool
(ValueTable -> ValueTable -> Bool)
-> (ValueTable -> ValueTable -> Bool) -> Eq ValueTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ValueTable -> ValueTable -> Bool
== :: ValueTable -> ValueTable -> Bool
$c/= :: ValueTable -> ValueTable -> Bool
/= :: ValueTable -> ValueTable -> Bool
Eq)

instance SP.ManagedPtrNewtype ValueTable where
    toManagedPtr :: ValueTable -> ManagedPtr ValueTable
toManagedPtr (ValueTable ManagedPtr ValueTable
p) = ManagedPtr ValueTable
p

instance BoxedPtr ValueTable where
    boxedPtrCopy :: ValueTable -> IO ValueTable
boxedPtrCopy = \ValueTable
p -> ValueTable -> (Ptr ValueTable -> IO ValueTable) -> IO ValueTable
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ValueTable
p (Int -> Ptr ValueTable -> IO (Ptr ValueTable)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr ValueTable -> IO (Ptr ValueTable))
-> (Ptr ValueTable -> IO ValueTable)
-> Ptr ValueTable
-> IO ValueTable
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ValueTable -> ValueTable)
-> Ptr ValueTable -> IO ValueTable
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ValueTable -> ValueTable
ValueTable)
    boxedPtrFree :: ValueTable -> IO ()
boxedPtrFree = \ValueTable
x -> ValueTable -> (Ptr ValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ValueTable
x Ptr ValueTable -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ValueTable where
    boxedPtrCalloc :: IO (Ptr ValueTable)
boxedPtrCalloc = Int -> IO (Ptr ValueTable)
forall a. Int -> IO (Ptr a)
callocBytes Int
64


-- | Construct a `ValueTable` struct initialized to zero.
newZeroValueTable :: MonadIO m => m ValueTable
newZeroValueTable :: forall (m :: * -> *). MonadIO m => m ValueTable
newZeroValueTable = IO ValueTable -> m ValueTable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ValueTable -> m ValueTable) -> IO ValueTable -> m ValueTable
forall a b. (a -> b) -> a -> b
$ IO (Ptr ValueTable)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ValueTable)
-> (Ptr ValueTable -> IO ValueTable) -> IO ValueTable
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ValueTable -> ValueTable)
-> Ptr ValueTable -> IO ValueTable
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ValueTable -> ValueTable
ValueTable

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


-- | 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' valueTable #type
-- @
getValueTableType :: MonadIO m => ValueTable -> m GType
getValueTableType :: forall (m :: * -> *). MonadIO m => ValueTable -> m GType
getValueTableType ValueTable
s = IO GType -> m GType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ ValueTable -> (Ptr ValueTable -> IO GType) -> IO GType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO GType) -> IO GType)
-> (Ptr ValueTable -> IO GType) -> IO GType
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    CGType
val <- Ptr CGType -> IO CGType
forall a. Storable a => Ptr a -> IO a
peek (Ptr ValueTable
ptr Ptr ValueTable -> Int -> Ptr CGType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CGType
    let val' :: GType
val' = CGType -> GType
GType CGType
val
    GType -> IO GType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GType
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' valueTable [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setValueTableType :: MonadIO m => ValueTable -> GType -> m ()
setValueTableType :: forall (m :: * -> *). MonadIO m => ValueTable -> GType -> m ()
setValueTableType ValueTable
s GType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ValueTable -> (Ptr ValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO ()) -> IO ())
-> (Ptr ValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    let val' :: CGType
val' = GType -> CGType
gtypeToCGType GType
val
    Ptr CGType -> CGType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ValueTable
ptr Ptr ValueTable -> Int -> Ptr CGType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CGType
val' :: CGType)

#if defined(ENABLE_OVERLOADING)
data ValueTableTypeFieldInfo
instance AttrInfo ValueTableTypeFieldInfo where
    type AttrBaseTypeConstraint ValueTableTypeFieldInfo = (~) ValueTable
    type AttrAllowedOps ValueTableTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ValueTableTypeFieldInfo = (~) GType
    type AttrTransferTypeConstraint ValueTableTypeFieldInfo = (~)GType
    type AttrTransferType ValueTableTypeFieldInfo = GType
    type AttrGetType ValueTableTypeFieldInfo = GType
    type AttrLabel ValueTableTypeFieldInfo = "type"
    type AttrOrigin ValueTableTypeFieldInfo = ValueTable
    attrGet = getValueTableType
    attrSet = setValueTableType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ValueTable.type"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-ValueTable.html#g:attr:type"
        })

valueTable_type :: AttrLabelProxy "type"
valueTable_type = AttrLabelProxy

#endif


-- | Get the value of the “@compare@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' valueTable #compare
-- @
getValueTableCompare :: MonadIO m => ValueTable -> m (Maybe Gst.Callbacks.ValueCompareFunc)
getValueTableCompare :: forall (m :: * -> *).
MonadIO m =>
ValueTable -> m (Maybe ValueCompareFunc)
getValueTableCompare ValueTable
s = IO (Maybe ValueCompareFunc) -> m (Maybe ValueCompareFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ValueCompareFunc) -> m (Maybe ValueCompareFunc))
-> IO (Maybe ValueCompareFunc) -> m (Maybe ValueCompareFunc)
forall a b. (a -> b) -> a -> b
$ ValueTable
-> (Ptr ValueTable -> IO (Maybe ValueCompareFunc))
-> IO (Maybe ValueCompareFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO (Maybe ValueCompareFunc))
 -> IO (Maybe ValueCompareFunc))
-> (Ptr ValueTable -> IO (Maybe ValueCompareFunc))
-> IO (Maybe ValueCompareFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    FunPtr C_ValueCompareFunc
val <- Ptr (FunPtr C_ValueCompareFunc) -> IO (FunPtr C_ValueCompareFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ValueTable
ptr Ptr ValueTable -> Int -> Ptr (FunPtr C_ValueCompareFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (FunPtr Gst.Callbacks.C_ValueCompareFunc)
    Maybe ValueCompareFunc
result <- FunPtr C_ValueCompareFunc
-> (FunPtr C_ValueCompareFunc -> IO ValueCompareFunc)
-> IO (Maybe ValueCompareFunc)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ValueCompareFunc
val ((FunPtr C_ValueCompareFunc -> IO ValueCompareFunc)
 -> IO (Maybe ValueCompareFunc))
-> (FunPtr C_ValueCompareFunc -> IO ValueCompareFunc)
-> IO (Maybe ValueCompareFunc)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ValueCompareFunc
val' -> do
        let val'' :: ValueCompareFunc
val'' = FunPtr C_ValueCompareFunc -> ValueCompareFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_ValueCompareFunc -> GValue -> GValue -> m Int32
Gst.Callbacks.dynamic_ValueCompareFunc FunPtr C_ValueCompareFunc
val'
        ValueCompareFunc -> IO ValueCompareFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ValueCompareFunc
val''
    Maybe ValueCompareFunc -> IO (Maybe ValueCompareFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ValueCompareFunc
result

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

-- | Set the value of the “@compare@” 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' #compare
-- @
clearValueTableCompare :: MonadIO m => ValueTable -> m ()
clearValueTableCompare :: forall (m :: * -> *). MonadIO m => ValueTable -> m ()
clearValueTableCompare ValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ValueTable -> (Ptr ValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO ()) -> IO ())
-> (Ptr ValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    Ptr (FunPtr C_ValueCompareFunc)
-> FunPtr C_ValueCompareFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ValueTable
ptr Ptr ValueTable -> Int -> Ptr (FunPtr C_ValueCompareFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_ValueCompareFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gst.Callbacks.C_ValueCompareFunc)

#if defined(ENABLE_OVERLOADING)
data ValueTableCompareFieldInfo
instance AttrInfo ValueTableCompareFieldInfo where
    type AttrBaseTypeConstraint ValueTableCompareFieldInfo = (~) ValueTable
    type AttrAllowedOps ValueTableCompareFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ValueTableCompareFieldInfo = (~) (FunPtr Gst.Callbacks.C_ValueCompareFunc)
    type AttrTransferTypeConstraint ValueTableCompareFieldInfo = (~)Gst.Callbacks.ValueCompareFunc
    type AttrTransferType ValueTableCompareFieldInfo = (FunPtr Gst.Callbacks.C_ValueCompareFunc)
    type AttrGetType ValueTableCompareFieldInfo = Maybe Gst.Callbacks.ValueCompareFunc
    type AttrLabel ValueTableCompareFieldInfo = "compare"
    type AttrOrigin ValueTableCompareFieldInfo = ValueTable
    attrGet = getValueTableCompare
    attrSet = setValueTableCompare
    attrConstruct = undefined
    attrClear = clearValueTableCompare
    attrTransfer _ v = do
        Gst.Callbacks.mk_ValueCompareFunc (Gst.Callbacks.wrap_ValueCompareFunc Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ValueTable.compare"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-ValueTable.html#g:attr:compare"
        })

valueTable_compare :: AttrLabelProxy "compare"
valueTable_compare = AttrLabelProxy

#endif


-- | Get the value of the “@serialize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' valueTable #serialize
-- @
getValueTableSerialize :: MonadIO m => ValueTable -> m (Maybe Gst.Callbacks.ValueSerializeFunc)
getValueTableSerialize :: forall (m :: * -> *).
MonadIO m =>
ValueTable -> m (Maybe ValueSerializeFunc)
getValueTableSerialize ValueTable
s = IO (Maybe ValueSerializeFunc) -> m (Maybe ValueSerializeFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ValueSerializeFunc) -> m (Maybe ValueSerializeFunc))
-> IO (Maybe ValueSerializeFunc) -> m (Maybe ValueSerializeFunc)
forall a b. (a -> b) -> a -> b
$ ValueTable
-> (Ptr ValueTable -> IO (Maybe ValueSerializeFunc))
-> IO (Maybe ValueSerializeFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO (Maybe ValueSerializeFunc))
 -> IO (Maybe ValueSerializeFunc))
-> (Ptr ValueTable -> IO (Maybe ValueSerializeFunc))
-> IO (Maybe ValueSerializeFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    FunPtr C_ValueSerializeFunc
val <- Ptr (FunPtr C_ValueSerializeFunc)
-> IO (FunPtr C_ValueSerializeFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ValueTable
ptr Ptr ValueTable -> Int -> Ptr (FunPtr C_ValueSerializeFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (FunPtr Gst.Callbacks.C_ValueSerializeFunc)
    Maybe ValueSerializeFunc
result <- FunPtr C_ValueSerializeFunc
-> (FunPtr C_ValueSerializeFunc -> IO ValueSerializeFunc)
-> IO (Maybe ValueSerializeFunc)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ValueSerializeFunc
val ((FunPtr C_ValueSerializeFunc -> IO ValueSerializeFunc)
 -> IO (Maybe ValueSerializeFunc))
-> (FunPtr C_ValueSerializeFunc -> IO ValueSerializeFunc)
-> IO (Maybe ValueSerializeFunc)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ValueSerializeFunc
val' -> do
        let val'' :: ValueSerializeFunc
val'' = FunPtr C_ValueSerializeFunc -> ValueSerializeFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_ValueSerializeFunc -> GValue -> m Text
Gst.Callbacks.dynamic_ValueSerializeFunc FunPtr C_ValueSerializeFunc
val'
        ValueSerializeFunc -> IO ValueSerializeFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ValueSerializeFunc
val''
    Maybe ValueSerializeFunc -> IO (Maybe ValueSerializeFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ValueSerializeFunc
result

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

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

#if defined(ENABLE_OVERLOADING)
data ValueTableSerializeFieldInfo
instance AttrInfo ValueTableSerializeFieldInfo where
    type AttrBaseTypeConstraint ValueTableSerializeFieldInfo = (~) ValueTable
    type AttrAllowedOps ValueTableSerializeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ValueTableSerializeFieldInfo = (~) (FunPtr Gst.Callbacks.C_ValueSerializeFunc)
    type AttrTransferTypeConstraint ValueTableSerializeFieldInfo = (~)Gst.Callbacks.ValueSerializeFunc
    type AttrTransferType ValueTableSerializeFieldInfo = (FunPtr Gst.Callbacks.C_ValueSerializeFunc)
    type AttrGetType ValueTableSerializeFieldInfo = Maybe Gst.Callbacks.ValueSerializeFunc
    type AttrLabel ValueTableSerializeFieldInfo = "serialize"
    type AttrOrigin ValueTableSerializeFieldInfo = ValueTable
    attrGet = getValueTableSerialize
    attrSet = setValueTableSerialize
    attrConstruct = undefined
    attrClear = clearValueTableSerialize
    attrTransfer _ v = do
        Gst.Callbacks.mk_ValueSerializeFunc (Gst.Callbacks.wrap_ValueSerializeFunc Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ValueTable.serialize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-ValueTable.html#g:attr:serialize"
        })

valueTable_serialize :: AttrLabelProxy "serialize"
valueTable_serialize = AttrLabelProxy

#endif


-- | Get the value of the “@deserialize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' valueTable #deserialize
-- @
getValueTableDeserialize :: MonadIO m => ValueTable -> m (Maybe Gst.Callbacks.ValueDeserializeFunc)
getValueTableDeserialize :: forall (m :: * -> *).
MonadIO m =>
ValueTable -> m (Maybe ValueDeserializeFunc)
getValueTableDeserialize ValueTable
s = IO (Maybe ValueDeserializeFunc) -> m (Maybe ValueDeserializeFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ValueDeserializeFunc) -> m (Maybe ValueDeserializeFunc))
-> IO (Maybe ValueDeserializeFunc)
-> m (Maybe ValueDeserializeFunc)
forall a b. (a -> b) -> a -> b
$ ValueTable
-> (Ptr ValueTable -> IO (Maybe ValueDeserializeFunc))
-> IO (Maybe ValueDeserializeFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO (Maybe ValueDeserializeFunc))
 -> IO (Maybe ValueDeserializeFunc))
-> (Ptr ValueTable -> IO (Maybe ValueDeserializeFunc))
-> IO (Maybe ValueDeserializeFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    FunPtr C_ValueDeserializeFunc
val <- Ptr (FunPtr C_ValueDeserializeFunc)
-> IO (FunPtr C_ValueDeserializeFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ValueTable
ptr Ptr ValueTable -> Int -> Ptr (FunPtr C_ValueDeserializeFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (FunPtr Gst.Callbacks.C_ValueDeserializeFunc)
    Maybe ValueDeserializeFunc
result <- FunPtr C_ValueDeserializeFunc
-> (FunPtr C_ValueDeserializeFunc -> IO ValueDeserializeFunc)
-> IO (Maybe ValueDeserializeFunc)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ValueDeserializeFunc
val ((FunPtr C_ValueDeserializeFunc -> IO ValueDeserializeFunc)
 -> IO (Maybe ValueDeserializeFunc))
-> (FunPtr C_ValueDeserializeFunc -> IO ValueDeserializeFunc)
-> IO (Maybe ValueDeserializeFunc)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ValueDeserializeFunc
val' -> do
        let val'' :: ValueDeserializeFunc
val'' = FunPtr C_ValueDeserializeFunc -> ValueDeserializeFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_ValueDeserializeFunc -> GValue -> Text -> m Bool
Gst.Callbacks.dynamic_ValueDeserializeFunc FunPtr C_ValueDeserializeFunc
val'
        ValueDeserializeFunc -> IO ValueDeserializeFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ValueDeserializeFunc
val''
    Maybe ValueDeserializeFunc -> IO (Maybe ValueDeserializeFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ValueDeserializeFunc
result

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

-- | Set the value of the “@deserialize@” 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' #deserialize
-- @
clearValueTableDeserialize :: MonadIO m => ValueTable -> m ()
clearValueTableDeserialize :: forall (m :: * -> *). MonadIO m => ValueTable -> m ()
clearValueTableDeserialize ValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ValueTable -> (Ptr ValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO ()) -> IO ())
-> (Ptr ValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    Ptr (FunPtr C_ValueDeserializeFunc)
-> FunPtr C_ValueDeserializeFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ValueTable
ptr Ptr ValueTable -> Int -> Ptr (FunPtr C_ValueDeserializeFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (FunPtr C_ValueDeserializeFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gst.Callbacks.C_ValueDeserializeFunc)

#if defined(ENABLE_OVERLOADING)
data ValueTableDeserializeFieldInfo
instance AttrInfo ValueTableDeserializeFieldInfo where
    type AttrBaseTypeConstraint ValueTableDeserializeFieldInfo = (~) ValueTable
    type AttrAllowedOps ValueTableDeserializeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ValueTableDeserializeFieldInfo = (~) (FunPtr Gst.Callbacks.C_ValueDeserializeFunc)
    type AttrTransferTypeConstraint ValueTableDeserializeFieldInfo = (~)Gst.Callbacks.ValueDeserializeFunc
    type AttrTransferType ValueTableDeserializeFieldInfo = (FunPtr Gst.Callbacks.C_ValueDeserializeFunc)
    type AttrGetType ValueTableDeserializeFieldInfo = Maybe Gst.Callbacks.ValueDeserializeFunc
    type AttrLabel ValueTableDeserializeFieldInfo = "deserialize"
    type AttrOrigin ValueTableDeserializeFieldInfo = ValueTable
    attrGet = getValueTableDeserialize
    attrSet = setValueTableDeserialize
    attrConstruct = undefined
    attrClear = clearValueTableDeserialize
    attrTransfer _ v = do
        Gst.Callbacks.mk_ValueDeserializeFunc (Gst.Callbacks.wrap_ValueDeserializeFunc Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ValueTable.deserialize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-ValueTable.html#g:attr:deserialize"
        })

valueTable_deserialize :: AttrLabelProxy "deserialize"
valueTable_deserialize = AttrLabelProxy

#endif


-- | Get the value of the “@deserialize_with_pspec@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' valueTable #deserializeWithPspec
-- @
getValueTableDeserializeWithPspec :: MonadIO m => ValueTable -> m (Maybe Gst.Callbacks.ValueDeserializeWithPSpecFunc)
getValueTableDeserializeWithPspec :: forall (m :: * -> *).
MonadIO m =>
ValueTable -> m (Maybe ValueDeserializeWithPSpecFunc)
getValueTableDeserializeWithPspec ValueTable
s = IO (Maybe ValueDeserializeWithPSpecFunc)
-> m (Maybe ValueDeserializeWithPSpecFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ValueDeserializeWithPSpecFunc)
 -> m (Maybe ValueDeserializeWithPSpecFunc))
-> IO (Maybe ValueDeserializeWithPSpecFunc)
-> m (Maybe ValueDeserializeWithPSpecFunc)
forall a b. (a -> b) -> a -> b
$ ValueTable
-> (Ptr ValueTable -> IO (Maybe ValueDeserializeWithPSpecFunc))
-> IO (Maybe ValueDeserializeWithPSpecFunc)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO (Maybe ValueDeserializeWithPSpecFunc))
 -> IO (Maybe ValueDeserializeWithPSpecFunc))
-> (Ptr ValueTable -> IO (Maybe ValueDeserializeWithPSpecFunc))
-> IO (Maybe ValueDeserializeWithPSpecFunc)
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    FunPtr C_ValueDeserializeWithPSpecFunc
val <- Ptr (FunPtr C_ValueDeserializeWithPSpecFunc)
-> IO (FunPtr C_ValueDeserializeWithPSpecFunc)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ValueTable
ptr Ptr ValueTable
-> Int -> Ptr (FunPtr C_ValueDeserializeWithPSpecFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr Gst.Callbacks.C_ValueDeserializeWithPSpecFunc)
    Maybe ValueDeserializeWithPSpecFunc
result <- FunPtr C_ValueDeserializeWithPSpecFunc
-> (FunPtr C_ValueDeserializeWithPSpecFunc
    -> IO ValueDeserializeWithPSpecFunc)
-> IO (Maybe ValueDeserializeWithPSpecFunc)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ValueDeserializeWithPSpecFunc
val ((FunPtr C_ValueDeserializeWithPSpecFunc
  -> IO ValueDeserializeWithPSpecFunc)
 -> IO (Maybe ValueDeserializeWithPSpecFunc))
-> (FunPtr C_ValueDeserializeWithPSpecFunc
    -> IO ValueDeserializeWithPSpecFunc)
-> IO (Maybe ValueDeserializeWithPSpecFunc)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ValueDeserializeWithPSpecFunc
val' -> do
        let val'' :: ValueDeserializeWithPSpecFunc
val'' = FunPtr C_ValueDeserializeWithPSpecFunc
-> ValueDeserializeWithPSpecFunc
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_ValueDeserializeWithPSpecFunc
-> GValue -> Text -> GParamSpec -> m Bool
Gst.Callbacks.dynamic_ValueDeserializeWithPSpecFunc FunPtr C_ValueDeserializeWithPSpecFunc
val'
        ValueDeserializeWithPSpecFunc -> IO ValueDeserializeWithPSpecFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ValueDeserializeWithPSpecFunc
val''
    Maybe ValueDeserializeWithPSpecFunc
-> IO (Maybe ValueDeserializeWithPSpecFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ValueDeserializeWithPSpecFunc
result

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

-- | Set the value of the “@deserialize_with_pspec@” 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' #deserializeWithPspec
-- @
clearValueTableDeserializeWithPspec :: MonadIO m => ValueTable -> m ()
clearValueTableDeserializeWithPspec :: forall (m :: * -> *). MonadIO m => ValueTable -> m ()
clearValueTableDeserializeWithPspec ValueTable
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ValueTable -> (Ptr ValueTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
s ((Ptr ValueTable -> IO ()) -> IO ())
-> (Ptr ValueTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ValueTable
ptr -> do
    Ptr (FunPtr C_ValueDeserializeWithPSpecFunc)
-> FunPtr C_ValueDeserializeWithPSpecFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ValueTable
ptr Ptr ValueTable
-> Int -> Ptr (FunPtr C_ValueDeserializeWithPSpecFunc)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_ValueDeserializeWithPSpecFunc
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gst.Callbacks.C_ValueDeserializeWithPSpecFunc)

#if defined(ENABLE_OVERLOADING)
data ValueTableDeserializeWithPspecFieldInfo
instance AttrInfo ValueTableDeserializeWithPspecFieldInfo where
    type AttrBaseTypeConstraint ValueTableDeserializeWithPspecFieldInfo = (~) ValueTable
    type AttrAllowedOps ValueTableDeserializeWithPspecFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ValueTableDeserializeWithPspecFieldInfo = (~) (FunPtr Gst.Callbacks.C_ValueDeserializeWithPSpecFunc)
    type AttrTransferTypeConstraint ValueTableDeserializeWithPspecFieldInfo = (~)Gst.Callbacks.ValueDeserializeWithPSpecFunc
    type AttrTransferType ValueTableDeserializeWithPspecFieldInfo = (FunPtr Gst.Callbacks.C_ValueDeserializeWithPSpecFunc)
    type AttrGetType ValueTableDeserializeWithPspecFieldInfo = Maybe Gst.Callbacks.ValueDeserializeWithPSpecFunc
    type AttrLabel ValueTableDeserializeWithPspecFieldInfo = "deserialize_with_pspec"
    type AttrOrigin ValueTableDeserializeWithPspecFieldInfo = ValueTable
    attrGet = getValueTableDeserializeWithPspec
    attrSet = setValueTableDeserializeWithPspec
    attrConstruct = undefined
    attrClear = clearValueTableDeserializeWithPspec
    attrTransfer _ v = do
        Gst.Callbacks.mk_ValueDeserializeWithPSpecFunc (Gst.Callbacks.wrap_ValueDeserializeWithPSpecFunc Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ValueTable.deserializeWithPspec"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-ValueTable.html#g:attr:deserializeWithPspec"
        })

valueTable_deserializeWithPspec :: AttrLabelProxy "deserializeWithPspec"
valueTable_deserializeWithPspec = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ValueTable
type instance O.AttributeList ValueTable = ValueTableAttributeList
type ValueTableAttributeList = ('[ '("type", ValueTableTypeFieldInfo), '("compare", ValueTableCompareFieldInfo), '("serialize", ValueTableSerializeFieldInfo), '("deserialize", ValueTableDeserializeFieldInfo), '("deserializeWithPspec", ValueTableDeserializeWithPspecFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveValueTableMethod t ValueTable, O.OverloadedMethod info ValueTable p, R.HasField t ValueTable p) => R.HasField t ValueTable p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveValueTableMethod t ValueTable, O.OverloadedMethodInfo info ValueTable) => OL.IsLabel t (O.MethodProxy info ValueTable) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif