{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Gst.Structs.ParentBufferMeta.ParentBufferMeta' is a t'GI.Gst.Structs.Meta.Meta' which can be attached to a t'GI.Gst.Structs.Buffer.Buffer'
-- to hold a reference to another buffer that is only released when the child
-- t'GI.Gst.Structs.Buffer.Buffer' is released.
-- 
-- Typically, t'GI.Gst.Structs.ParentBufferMeta.ParentBufferMeta' is used when the child buffer is directly
-- using the t'GI.Gst.Structs.Memory.Memory' of the parent buffer, and wants to prevent the parent
-- buffer from being returned to a buffer pool until the t'GI.Gst.Structs.Memory.Memory' is available
-- for re-use.
-- 
-- /Since: 1.6/

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

module GI.Gst.Structs.ParentBufferMeta
    ( 

-- * Exported types
    ParentBufferMeta(..)                    ,
    newZeroParentBufferMeta                 ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveParentBufferMetaMethod           ,
#endif


-- ** getInfo #method:getInfo#

    parentBufferMetaGetInfo                 ,




 -- * Properties
-- ** buffer #attr:buffer#
-- | the t'GI.Gst.Structs.Buffer.Buffer' on which a reference is being held.

    clearParentBufferMetaBuffer             ,
    getParentBufferMetaBuffer               ,
#if defined(ENABLE_OVERLOADING)
    parentBufferMeta_buffer                 ,
#endif
    setParentBufferMetaBuffer               ,


-- ** parent #attr:parent#
-- | the parent t'GI.Gst.Structs.Meta.Meta' structure

    getParentBufferMetaParent               ,
#if defined(ENABLE_OVERLOADING)
    parentBufferMeta_parent                 ,
#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.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 Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.Meta as Gst.Meta
import {-# SOURCE #-} qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo

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

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

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


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

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


-- | Get the value of the “@parent@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' parentBufferMeta #parent
-- @
getParentBufferMetaParent :: MonadIO m => ParentBufferMeta -> m Gst.Meta.Meta
getParentBufferMetaParent :: ParentBufferMeta -> m Meta
getParentBufferMetaParent ParentBufferMeta
s = IO Meta -> m Meta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Meta -> m Meta) -> IO Meta -> m Meta
forall a b. (a -> b) -> a -> b
$ ParentBufferMeta -> (Ptr ParentBufferMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParentBufferMeta
s ((Ptr ParentBufferMeta -> IO Meta) -> IO Meta)
-> (Ptr ParentBufferMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr ParentBufferMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr ParentBufferMeta
ptr Ptr ParentBufferMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.Meta.Meta)
    Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
val
    Meta -> IO Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'

#if defined(ENABLE_OVERLOADING)
data ParentBufferMetaParentFieldInfo
instance AttrInfo ParentBufferMetaParentFieldInfo where
    type AttrBaseTypeConstraint ParentBufferMetaParentFieldInfo = (~) ParentBufferMeta
    type AttrAllowedOps ParentBufferMetaParentFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ParentBufferMetaParentFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint ParentBufferMetaParentFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType ParentBufferMetaParentFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType ParentBufferMetaParentFieldInfo = Gst.Meta.Meta
    type AttrLabel ParentBufferMetaParentFieldInfo = "parent"
    type AttrOrigin ParentBufferMetaParentFieldInfo = ParentBufferMeta
    attrGet = getParentBufferMetaParent
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

parentBufferMeta_parent :: AttrLabelProxy "parent"
parentBufferMeta_parent = AttrLabelProxy

#endif


-- | Get the value of the “@buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' parentBufferMeta #buffer
-- @
getParentBufferMetaBuffer :: MonadIO m => ParentBufferMeta -> m (Maybe Gst.Buffer.Buffer)
getParentBufferMetaBuffer :: ParentBufferMeta -> m (Maybe Buffer)
getParentBufferMetaBuffer ParentBufferMeta
s = IO (Maybe Buffer) -> m (Maybe Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ ParentBufferMeta
-> (Ptr ParentBufferMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParentBufferMeta
s ((Ptr ParentBufferMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer))
-> (Ptr ParentBufferMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr ParentBufferMeta
ptr -> do
    Ptr Buffer
val <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParentBufferMeta
ptr Ptr ParentBufferMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Gst.Buffer.Buffer)
    Maybe Buffer
result <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Buffer
val ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
val' -> do
        Buffer
val'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
val'
        Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
val''
    Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
result

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

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

#if defined(ENABLE_OVERLOADING)
data ParentBufferMetaBufferFieldInfo
instance AttrInfo ParentBufferMetaBufferFieldInfo where
    type AttrBaseTypeConstraint ParentBufferMetaBufferFieldInfo = (~) ParentBufferMeta
    type AttrAllowedOps ParentBufferMetaBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ParentBufferMetaBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrTransferTypeConstraint ParentBufferMetaBufferFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
    type AttrTransferType ParentBufferMetaBufferFieldInfo = (Ptr Gst.Buffer.Buffer)
    type AttrGetType ParentBufferMetaBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel ParentBufferMetaBufferFieldInfo = "buffer"
    type AttrOrigin ParentBufferMetaBufferFieldInfo = ParentBufferMeta
    attrGet = getParentBufferMetaBuffer
    attrSet = setParentBufferMetaBuffer
    attrConstruct = undefined
    attrClear = clearParentBufferMetaBuffer
    attrTransfer _ v = do
        return v

parentBufferMeta_buffer :: AttrLabelProxy "buffer"
parentBufferMeta_buffer = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ParentBufferMeta
type instance O.AttributeList ParentBufferMeta = ParentBufferMetaAttributeList
type ParentBufferMetaAttributeList = ('[ '("parent", ParentBufferMetaParentFieldInfo), '("buffer", ParentBufferMetaBufferFieldInfo)] :: [(Symbol, *)])
#endif

-- method ParentBufferMeta::get_info
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "MetaInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_parent_buffer_meta_get_info" gst_parent_buffer_meta_get_info :: 
    IO (Ptr Gst.MetaInfo.MetaInfo)

-- | Get the global t'GI.Gst.Structs.MetaInfo.MetaInfo' describing  the t'GI.Gst.Structs.ParentBufferMeta.ParentBufferMeta' meta.
-- 
-- /Since: 1.6/
parentBufferMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
    -- ^ __Returns:__ The t'GI.Gst.Structs.MetaInfo.MetaInfo'
parentBufferMetaGetInfo :: m MetaInfo
parentBufferMetaGetInfo  = IO MetaInfo -> m MetaInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MetaInfo -> m MetaInfo) -> IO MetaInfo -> m MetaInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr MetaInfo
result <- IO (Ptr MetaInfo)
gst_parent_buffer_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"parentBufferMetaGetInfo" Ptr MetaInfo
result
    MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MetaInfo -> MetaInfo
Gst.MetaInfo.MetaInfo) Ptr MetaInfo
result
    MetaInfo -> IO MetaInfo
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

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

#endif