{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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                       ,
    noValueTable                            ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded 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


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

import qualified GI.Gst.Callbacks as Gst.Callbacks

-- | Memory-managed wrapper type.
newtype ValueTable = ValueTable (ManagedPtr ValueTable)
    deriving (ValueTable -> ValueTable -> Bool
(ValueTable -> ValueTable -> Bool)
-> (ValueTable -> ValueTable -> Bool) -> Eq ValueTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ValueTable -> ValueTable -> Bool
$c/= :: ValueTable -> ValueTable -> Bool
== :: ValueTable -> ValueTable -> Bool
$c== :: ValueTable -> ValueTable -> Bool
Eq)
instance WrappedPtr ValueTable where
    wrappedPtrCalloc :: IO (Ptr ValueTable)
wrappedPtrCalloc = Int -> IO (Ptr ValueTable)
forall a. Int -> IO (Ptr a)
callocBytes 64
    wrappedPtrCopy :: ValueTable -> IO ValueTable
wrappedPtrCopy = \p :: ValueTable
p -> ValueTable -> (Ptr ValueTable -> IO ValueTable) -> IO ValueTable
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ValueTable
p (Int -> Ptr ValueTable -> IO (Ptr ValueTable)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ValueTable -> ValueTable
ValueTable)
    wrappedPtrFree :: Maybe (GDestroyNotify ValueTable)
wrappedPtrFree = GDestroyNotify ValueTable -> Maybe (GDestroyNotify ValueTable)
forall a. a -> Maybe a
Just GDestroyNotify ValueTable
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `ValueTable` struct initialized to zero.
newZeroValueTable :: MonadIO m => m ValueTable
newZeroValueTable :: m ValueTable
newZeroValueTable = IO ValueTable -> m ValueTable
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. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr ValueTable)
-> (Ptr ValueTable -> IO ValueTable) -> IO ValueTable
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ValueTable -> ValueTable)
-> Ptr ValueTable -> IO ValueTable
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ValueTable -> ValueTable
ValueTable

instance tag ~ 'AttrSet => Constructible ValueTable tag where
    new :: (ManagedPtr ValueTable -> ValueTable)
-> [AttrOp ValueTable tag] -> m ValueTable
new _ attrs :: [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 (m :: * -> *) a. Monad m => a -> m a
return ValueTable
o


-- | A convenience alias for `Nothing` :: `Maybe` `ValueTable`.
noValueTable :: Maybe ValueTable
noValueTable :: Maybe ValueTable
noValueTable = Maybe ValueTable
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' valueTable #type
-- @
getValueTableType :: MonadIO m => ValueTable -> m GType
getValueTableType :: ValueTable -> m GType
getValueTableType s :: ValueTable
s = IO GType -> m GType
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 :: 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` 0) :: IO CGType
    let val' :: GType
val' = CGType -> GType
GType CGType
val
    GType -> IO GType
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 :: ValueTable -> GType -> m ()
setValueTableType s :: ValueTable
s val :: GType
val = IO () -> m ()
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 :: 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` 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

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 :: ValueTable -> m (Maybe ValueCompareFunc)
getValueTableCompare s :: ValueTable
s = IO (Maybe ValueCompareFunc) -> m (Maybe ValueCompareFunc)
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 :: 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` 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
$ \val' :: 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 (m :: * -> *) a. Monad m => a -> m a
return ValueCompareFunc
val''
    Maybe ValueCompareFunc -> IO (Maybe ValueCompareFunc)
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 :: ValueTable -> FunPtr C_ValueCompareFunc -> m ()
setValueTableCompare s :: ValueTable
s val :: FunPtr C_ValueCompareFunc
val = IO () -> m ()
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 :: 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` 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 :: ValueTable -> m ()
clearValueTableCompare s :: ValueTable
s = IO () -> m ()
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 :: 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` 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)

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 :: ValueTable -> m (Maybe ValueSerializeFunc)
getValueTableSerialize s :: ValueTable
s = IO (Maybe ValueSerializeFunc) -> m (Maybe ValueSerializeFunc)
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 :: 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` 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
$ \val' :: 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 (m :: * -> *) a. Monad m => a -> m a
return ValueSerializeFunc
val''
    Maybe ValueSerializeFunc -> IO (Maybe ValueSerializeFunc)
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 :: ValueTable -> FunPtr C_ValueSerializeFunc -> m ()
setValueTableSerialize s :: ValueTable
s val :: FunPtr C_ValueSerializeFunc
val = IO () -> m ()
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 :: 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` 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 :: ValueTable -> m ()
clearValueTableSerialize s :: ValueTable
s = IO () -> m ()
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 :: 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` 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)

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 :: ValueTable -> m (Maybe ValueDeserializeFunc)
getValueTableDeserialize s :: ValueTable
s = IO (Maybe ValueDeserializeFunc) -> m (Maybe ValueDeserializeFunc)
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 :: 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` 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
$ \val' :: 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 (m :: * -> *) a. Monad m => a -> m a
return ValueDeserializeFunc
val''
    Maybe ValueDeserializeFunc -> IO (Maybe ValueDeserializeFunc)
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 :: ValueTable -> FunPtr C_ValueDeserializeFunc -> m ()
setValueTableDeserialize s :: ValueTable
s val :: FunPtr C_ValueDeserializeFunc
val = IO () -> m ()
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 :: 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` 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 :: ValueTable -> m ()
clearValueTableDeserialize s :: ValueTable
s = IO () -> m ()
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 :: 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` 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)

valueTable_deserialize :: AttrLabelProxy "deserialize"
valueTable_deserialize = 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)] :: [(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.MethodInfo 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

#endif