{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.ValueTable
(
ValueTable(..) ,
newZeroValueTable ,
#if defined(ENABLE_OVERLOADING)
ResolveValueTableMethod ,
#endif
clearValueTableCompare ,
getValueTableCompare ,
setValueTableCompare ,
#if defined(ENABLE_OVERLOADING)
valueTable_compare ,
#endif
clearValueTableDeserialize ,
getValueTableDeserialize ,
setValueTableDeserialize ,
#if defined(ENABLE_OVERLOADING)
valueTable_deserialize ,
#endif
clearValueTableDeserializeWithPspec ,
getValueTableDeserializeWithPspec ,
setValueTableDeserializeWithPspec ,
#if defined(ENABLE_OVERLOADING)
valueTable_deserializeWithPspec ,
#endif
clearValueTableSerialize ,
getValueTableSerialize ,
setValueTableSerialize ,
#if defined(ENABLE_OVERLOADING)
valueTable_serialize ,
#endif
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
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
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
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'
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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