{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.ValueList
(
ValueList(..) ,
IsValueList ,
toValueList ,
#if defined(ENABLE_OVERLOADING)
ResolveValueListMethod ,
#endif
valueListAppendAndTakeValue ,
valueListAppendValue ,
valueListConcat ,
valueListGetSize ,
valueListGetValue ,
valueListInit ,
valueListMerge ,
valueListPrependValue ,
) 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.Kind as DK
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
newtype ValueList = ValueList (SP.ManagedPtr ValueList)
deriving (ValueList -> ValueList -> Bool
(ValueList -> ValueList -> Bool)
-> (ValueList -> ValueList -> Bool) -> Eq ValueList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ValueList -> ValueList -> Bool
== :: ValueList -> ValueList -> Bool
$c/= :: ValueList -> ValueList -> Bool
/= :: ValueList -> ValueList -> Bool
Eq)
instance SP.ManagedPtrNewtype ValueList where
toManagedPtr :: ValueList -> ManagedPtr ValueList
toManagedPtr (ValueList ManagedPtr ValueList
p) = ManagedPtr ValueList
p
foreign import ccall "gst_value_list_get_type"
c_gst_value_list_get_type :: IO B.Types.GType
instance B.Types.TypedObject ValueList where
glibType :: IO GType
glibType = IO GType
c_gst_value_list_get_type
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf ValueList o) => IsValueList o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf ValueList o) => IsValueList o
instance O.HasParentTypes ValueList
type instance O.ParentTypes ValueList = '[]
toValueList :: (MIO.MonadIO m, IsValueList o) => o -> m ValueList
toValueList :: forall (m :: * -> *) o.
(MonadIO m, IsValueList o) =>
o -> m ValueList
toValueList = IO ValueList -> m ValueList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ValueList -> m ValueList)
-> (o -> IO ValueList) -> o -> m ValueList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ValueList -> ValueList) -> o -> IO ValueList
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ValueList -> ValueList
ValueList
#if defined(ENABLE_OVERLOADING)
type family ResolveValueListMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveValueListMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveValueListMethod t ValueList, O.OverloadedMethod info ValueList p) => OL.IsLabel t (ValueList -> 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 ~ ResolveValueListMethod t ValueList, O.OverloadedMethod info ValueList p, R.HasField t ValueList p) => R.HasField t ValueList p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveValueListMethod t ValueList, O.OverloadedMethodInfo info ValueList) => OL.IsLabel t (O.MethodProxy info ValueList) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
instance BoxedPtr ValueList where
boxedPtrCopy :: ValueList -> IO ValueList
boxedPtrCopy = ValueList -> IO ValueList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
boxedPtrFree :: ValueList -> IO ()
boxedPtrFree = \ValueList
_x -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "gst_value_list_append_and_take_value" gst_value_list_append_and_take_value ::
Ptr GValue ->
Ptr GValue ->
IO ()
valueListAppendAndTakeValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> GValue
-> m ()
valueListAppendAndTakeValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> GValue -> m ()
valueListAppendAndTakeValue GValue
value GValue
appendValue = 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
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr GValue
appendValue' <- GValue -> IO (Ptr GValue)
B.GValue.disownGValue GValue
appendValue
Ptr GValue -> Ptr GValue -> IO ()
gst_value_list_append_and_take_value Ptr GValue
value' Ptr GValue
appendValue'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
appendValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_value_list_append_value" gst_value_list_append_value ::
Ptr GValue ->
Ptr GValue ->
IO ()
valueListAppendValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> GValue
-> m ()
valueListAppendValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> GValue -> m ()
valueListAppendValue GValue
value GValue
appendValue = 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
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr GValue
appendValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
appendValue
Ptr GValue -> Ptr GValue -> IO ()
gst_value_list_append_value Ptr GValue
value' Ptr GValue
appendValue'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
appendValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_value_list_concat" gst_value_list_concat ::
Ptr GValue ->
Ptr GValue ->
Ptr GValue ->
IO ()
valueListConcat ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> GValue
-> m (GValue)
valueListConcat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> GValue -> m GValue
valueListConcat GValue
value1 GValue
value2 = IO GValue -> m GValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
dest <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
Ptr GValue
value1' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value1
Ptr GValue
value2' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value2
Ptr GValue -> Ptr GValue -> Ptr GValue -> IO ()
gst_value_list_concat Ptr GValue
dest Ptr GValue
value1' Ptr GValue
value2'
GValue
dest' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
dest
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value1
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value2
GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
dest'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_value_list_get_size" gst_value_list_get_size ::
Ptr GValue ->
IO Word32
valueListGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> m Word32
valueListGetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> m Word32
valueListGetSize GValue
value = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Word32
result <- Ptr GValue -> IO Word32
gst_value_list_get_size Ptr GValue
value'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_value_list_get_value" gst_value_list_get_value ::
Ptr GValue ->
Word32 ->
IO (Ptr GValue)
valueListGetValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> Word32
-> m GValue
valueListGetValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> Word32 -> m GValue
valueListGetValue GValue
value Word32
index = IO GValue -> m GValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr GValue
result <- Ptr GValue -> Word32 -> IO (Ptr GValue)
gst_value_list_get_value Ptr GValue
value' Word32
index
Text -> Ptr GValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueListGetValue" Ptr GValue
result
GValue
result' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
result
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_value_list_init" gst_value_list_init ::
Ptr GValue ->
Word32 ->
IO (Ptr GValue)
valueListInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> Word32
-> m GValue
valueListInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> Word32 -> m GValue
valueListInit GValue
value Word32
prealloc = IO GValue -> m GValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr GValue
result <- Ptr GValue -> Word32 -> IO (Ptr GValue)
gst_value_list_init Ptr GValue
value' Word32
prealloc
Text -> Ptr GValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueListInit" Ptr GValue
result
GValue
result' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
result
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_value_list_merge" gst_value_list_merge ::
Ptr GValue ->
Ptr GValue ->
Ptr GValue ->
IO ()
valueListMerge ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> GValue
-> m (GValue)
valueListMerge :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> GValue -> m GValue
valueListMerge GValue
value1 GValue
value2 = IO GValue -> m GValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
dest <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
Ptr GValue
value1' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value1
Ptr GValue
value2' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value2
Ptr GValue -> Ptr GValue -> Ptr GValue -> IO ()
gst_value_list_merge Ptr GValue
dest Ptr GValue
value1' Ptr GValue
value2'
GValue
dest' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
dest
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value1
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value2
GValue -> IO GValue
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
dest'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_value_list_prepend_value" gst_value_list_prepend_value ::
Ptr GValue ->
Ptr GValue ->
IO ()
valueListPrependValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> GValue
-> m ()
valueListPrependValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GValue -> GValue -> m ()
valueListPrependValue GValue
value GValue
prependValue = 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
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr GValue
prependValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
prependValue
Ptr GValue -> Ptr GValue -> IO ()
gst_value_list_prepend_value Ptr GValue
value' Ptr GValue
prependValue'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
prependValue
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif