MetaInfo.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

The 'GI.Gst.Structs.MetaInfo.MetaInfo' provides information about a specific metadata
structure.
-}

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

module GI.Gst.Structs.MetaInfo
    ( 

-- * Exported types
    MetaInfo(..)                            ,
    newZeroMetaInfo                         ,
    noMetaInfo                              ,


 -- * Properties
-- ** api #attr:api#
{- | tag identifying the metadata structure and api
-}
    getMetaInfoApi                          ,
#if ENABLE_OVERLOADING
    metaInfo_api                            ,
#endif
    setMetaInfoApi                          ,


-- ** freeFunc #attr:freeFunc#
{- | function for freeing the metadata
-}
    clearMetaInfoFreeFunc                   ,
    getMetaInfoFreeFunc                     ,
#if ENABLE_OVERLOADING
    metaInfo_freeFunc                       ,
#endif
    setMetaInfoFreeFunc                     ,


-- ** initFunc #attr:initFunc#
{- | function for initializing the metadata
-}
    clearMetaInfoInitFunc                   ,
    getMetaInfoInitFunc                     ,
#if ENABLE_OVERLOADING
    metaInfo_initFunc                       ,
#endif
    setMetaInfoInitFunc                     ,


-- ** size #attr:size#
{- | size of the metadata
-}
    getMetaInfoSize                         ,
#if ENABLE_OVERLOADING
    metaInfo_size                           ,
#endif
    setMetaInfoSize                         ,


-- ** transformFunc #attr:transformFunc#
{- | function for transforming the metadata
-}
    clearMetaInfoTransformFunc              ,
    getMetaInfoTransformFunc                ,
#if ENABLE_OVERLOADING
    metaInfo_transformFunc                  ,
#endif
    setMetaInfoTransformFunc                ,


-- ** type #attr:type#
{- | type identifying the implementor of the api
-}
    getMetaInfoType                         ,
#if ENABLE_OVERLOADING
    metaInfo_type                           ,
#endif
    setMetaInfoType                         ,




    ) 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.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 MetaInfo = MetaInfo (ManagedPtr MetaInfo)
instance WrappedPtr MetaInfo where
    wrappedPtrCalloc = callocBytes 48
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 48 >=> wrapPtr MetaInfo)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `MetaInfo` struct initialized to zero.
newZeroMetaInfo :: MonadIO m => m MetaInfo
newZeroMetaInfo = liftIO $ wrappedPtrCalloc >>= wrapPtr MetaInfo

instance tag ~ 'AttrSet => Constructible MetaInfo tag where
    new _ attrs = do
        o <- newZeroMetaInfo
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `MetaInfo`.
noMetaInfo :: Maybe MetaInfo
noMetaInfo = Nothing

{- |
Get the value of the “@api@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' metaInfo #api
@
-}
getMetaInfoApi :: MonadIO m => MetaInfo -> m GType
getMetaInfoApi s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CGType
    let val' = GType val
    return val'

{- |
Set the value of the “@api@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' metaInfo [ #api 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMetaInfoApi :: MonadIO m => MetaInfo -> GType -> m ()
setMetaInfoApi s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = gtypeToCGType val
    poke (ptr `plusPtr` 0) (val' :: CGType)

#if ENABLE_OVERLOADING
data MetaInfoApiFieldInfo
instance AttrInfo MetaInfoApiFieldInfo where
    type AttrAllowedOps MetaInfoApiFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MetaInfoApiFieldInfo = (~) GType
    type AttrBaseTypeConstraint MetaInfoApiFieldInfo = (~) MetaInfo
    type AttrGetType MetaInfoApiFieldInfo = GType
    type AttrLabel MetaInfoApiFieldInfo = "api"
    type AttrOrigin MetaInfoApiFieldInfo = MetaInfo
    attrGet _ = getMetaInfoApi
    attrSet _ = setMetaInfoApi
    attrConstruct = undefined
    attrClear _ = undefined

metaInfo_api :: AttrLabelProxy "api"
metaInfo_api = AttrLabelProxy

#endif


{- |
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' metaInfo #type
@
-}
getMetaInfoType :: MonadIO m => MetaInfo -> m GType
getMetaInfoType s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CGType
    let val' = GType val
    return 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' metaInfo [ #type 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMetaInfoType :: MonadIO m => MetaInfo -> GType -> m ()
setMetaInfoType s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = gtypeToCGType val
    poke (ptr `plusPtr` 8) (val' :: CGType)

#if ENABLE_OVERLOADING
data MetaInfoTypeFieldInfo
instance AttrInfo MetaInfoTypeFieldInfo where
    type AttrAllowedOps MetaInfoTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MetaInfoTypeFieldInfo = (~) GType
    type AttrBaseTypeConstraint MetaInfoTypeFieldInfo = (~) MetaInfo
    type AttrGetType MetaInfoTypeFieldInfo = GType
    type AttrLabel MetaInfoTypeFieldInfo = "type"
    type AttrOrigin MetaInfoTypeFieldInfo = MetaInfo
    attrGet _ = getMetaInfoType
    attrSet _ = setMetaInfoType
    attrConstruct = undefined
    attrClear _ = undefined

metaInfo_type :: AttrLabelProxy "type"
metaInfo_type = AttrLabelProxy

#endif


{- |
Get the value of the “@size@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' metaInfo #size
@
-}
getMetaInfoSize :: MonadIO m => MetaInfo -> m Word64
getMetaInfoSize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word64
    return val

{- |
Set the value of the “@size@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' metaInfo [ #size 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMetaInfoSize :: MonadIO m => MetaInfo -> Word64 -> m ()
setMetaInfoSize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word64)

#if ENABLE_OVERLOADING
data MetaInfoSizeFieldInfo
instance AttrInfo MetaInfoSizeFieldInfo where
    type AttrAllowedOps MetaInfoSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MetaInfoSizeFieldInfo = (~) Word64
    type AttrBaseTypeConstraint MetaInfoSizeFieldInfo = (~) MetaInfo
    type AttrGetType MetaInfoSizeFieldInfo = Word64
    type AttrLabel MetaInfoSizeFieldInfo = "size"
    type AttrOrigin MetaInfoSizeFieldInfo = MetaInfo
    attrGet _ = getMetaInfoSize
    attrSet _ = setMetaInfoSize
    attrConstruct = undefined
    attrClear _ = undefined

metaInfo_size :: AttrLabelProxy "size"
metaInfo_size = AttrLabelProxy

#endif


{- |
Get the value of the “@init_func@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' metaInfo #initFunc
@
-}
getMetaInfoInitFunc :: MonadIO m => MetaInfo -> m (Maybe Gst.Callbacks.MetaInitFunction)
getMetaInfoInitFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO (FunPtr Gst.Callbacks.C_MetaInitFunction)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = Gst.Callbacks.dynamic_MetaInitFunction val'
        return val''
    return result

{- |
Set the value of the “@init_func@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' metaInfo [ #initFunc 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMetaInfoInitFunc :: MonadIO m => MetaInfo -> FunPtr Gst.Callbacks.C_MetaInitFunction -> m ()
setMetaInfoInitFunc s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: FunPtr Gst.Callbacks.C_MetaInitFunction)

{- |
Set the value of the “@init_func@” 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' #initFunc
@
-}
clearMetaInfoInitFunc :: MonadIO m => MetaInfo -> m ()
clearMetaInfoInitFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MetaInitFunction)

#if ENABLE_OVERLOADING
data MetaInfoInitFuncFieldInfo
instance AttrInfo MetaInfoInitFuncFieldInfo where
    type AttrAllowedOps MetaInfoInitFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint MetaInfoInitFuncFieldInfo = (~) (FunPtr Gst.Callbacks.C_MetaInitFunction)
    type AttrBaseTypeConstraint MetaInfoInitFuncFieldInfo = (~) MetaInfo
    type AttrGetType MetaInfoInitFuncFieldInfo = Maybe Gst.Callbacks.MetaInitFunction
    type AttrLabel MetaInfoInitFuncFieldInfo = "init_func"
    type AttrOrigin MetaInfoInitFuncFieldInfo = MetaInfo
    attrGet _ = getMetaInfoInitFunc
    attrSet _ = setMetaInfoInitFunc
    attrConstruct = undefined
    attrClear _ = clearMetaInfoInitFunc

metaInfo_initFunc :: AttrLabelProxy "initFunc"
metaInfo_initFunc = AttrLabelProxy

#endif


{- |
Get the value of the “@free_func@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' metaInfo #freeFunc
@
-}
getMetaInfoFreeFunc :: MonadIO m => MetaInfo -> m (Maybe Gst.Callbacks.MetaFreeFunction)
getMetaInfoFreeFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO (FunPtr Gst.Callbacks.C_MetaFreeFunction)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = Gst.Callbacks.dynamic_MetaFreeFunction val'
        return val''
    return result

{- |
Set the value of the “@free_func@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' metaInfo [ #freeFunc 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMetaInfoFreeFunc :: MonadIO m => MetaInfo -> FunPtr Gst.Callbacks.C_MetaFreeFunction -> m ()
setMetaInfoFreeFunc s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: FunPtr Gst.Callbacks.C_MetaFreeFunction)

{- |
Set the value of the “@free_func@” 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' #freeFunc
@
-}
clearMetaInfoFreeFunc :: MonadIO m => MetaInfo -> m ()
clearMetaInfoFreeFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MetaFreeFunction)

#if ENABLE_OVERLOADING
data MetaInfoFreeFuncFieldInfo
instance AttrInfo MetaInfoFreeFuncFieldInfo where
    type AttrAllowedOps MetaInfoFreeFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint MetaInfoFreeFuncFieldInfo = (~) (FunPtr Gst.Callbacks.C_MetaFreeFunction)
    type AttrBaseTypeConstraint MetaInfoFreeFuncFieldInfo = (~) MetaInfo
    type AttrGetType MetaInfoFreeFuncFieldInfo = Maybe Gst.Callbacks.MetaFreeFunction
    type AttrLabel MetaInfoFreeFuncFieldInfo = "free_func"
    type AttrOrigin MetaInfoFreeFuncFieldInfo = MetaInfo
    attrGet _ = getMetaInfoFreeFunc
    attrSet _ = setMetaInfoFreeFunc
    attrConstruct = undefined
    attrClear _ = clearMetaInfoFreeFunc

metaInfo_freeFunc :: AttrLabelProxy "freeFunc"
metaInfo_freeFunc = AttrLabelProxy

#endif


{- |
Get the value of the “@transform_func@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' metaInfo #transformFunc
@
-}
getMetaInfoTransformFunc :: MonadIO m => MetaInfo -> m (Maybe Gst.Callbacks.MetaTransformFunction)
getMetaInfoTransformFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO (FunPtr Gst.Callbacks.C_MetaTransformFunction)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = Gst.Callbacks.dynamic_MetaTransformFunction val'
        return val''
    return result

{- |
Set the value of the “@transform_func@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' metaInfo [ #transformFunc 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMetaInfoTransformFunc :: MonadIO m => MetaInfo -> FunPtr Gst.Callbacks.C_MetaTransformFunction -> m ()
setMetaInfoTransformFunc s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: FunPtr Gst.Callbacks.C_MetaTransformFunction)

{- |
Set the value of the “@transform_func@” 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' #transformFunc
@
-}
clearMetaInfoTransformFunc :: MonadIO m => MetaInfo -> m ()
clearMetaInfoTransformFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MetaTransformFunction)

#if ENABLE_OVERLOADING
data MetaInfoTransformFuncFieldInfo
instance AttrInfo MetaInfoTransformFuncFieldInfo where
    type AttrAllowedOps MetaInfoTransformFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint MetaInfoTransformFuncFieldInfo = (~) (FunPtr Gst.Callbacks.C_MetaTransformFunction)
    type AttrBaseTypeConstraint MetaInfoTransformFuncFieldInfo = (~) MetaInfo
    type AttrGetType MetaInfoTransformFuncFieldInfo = Maybe Gst.Callbacks.MetaTransformFunction
    type AttrLabel MetaInfoTransformFuncFieldInfo = "transform_func"
    type AttrOrigin MetaInfoTransformFuncFieldInfo = MetaInfo
    attrGet _ = getMetaInfoTransformFunc
    attrSet _ = setMetaInfoTransformFunc
    attrConstruct = undefined
    attrClear _ = clearMetaInfoTransformFunc

metaInfo_transformFunc :: AttrLabelProxy "transformFunc"
metaInfo_transformFunc = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList MetaInfo
type instance O.AttributeList MetaInfo = MetaInfoAttributeList
type MetaInfoAttributeList = ('[ '("api", MetaInfoApiFieldInfo), '("type", MetaInfoTypeFieldInfo), '("size", MetaInfoSizeFieldInfo), '("initFunc", MetaInfoInitFuncFieldInfo), '("freeFunc", MetaInfoFreeFuncFieldInfo), '("transformFunc", MetaInfoTransformFuncFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif