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

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

module GI.Gst.Structs.MetaInfo
    ( 

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


 -- * Properties
-- ** api #attr:api#
    getMetaInfoApi                          ,
    metaInfo_api                            ,
    setMetaInfoApi                          ,


-- ** freeFunc #attr:freeFunc#
    clearMetaInfoFreeFunc                   ,
    getMetaInfoFreeFunc                     ,
    metaInfo_freeFunc                       ,
    setMetaInfoFreeFunc                     ,


-- ** initFunc #attr:initFunc#
    clearMetaInfoInitFunc                   ,
    getMetaInfoInitFunc                     ,
    metaInfo_initFunc                       ,
    setMetaInfoInitFunc                     ,


-- ** size #attr:size#
    getMetaInfoSize                         ,
    metaInfo_size                           ,
    setMetaInfoSize                         ,


-- ** transformFunc #attr:transformFunc#
    clearMetaInfoTransformFunc              ,
    getMetaInfoTransformFunc                ,
    metaInfo_transformFunc                  ,
    setMetaInfoTransformFunc                ,


-- ** type #attr:type#
    getMetaInfoType                         ,
    metaInfo_type                           ,
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.Gst.Callbacks as Gst.Callbacks

newtype MetaInfo = MetaInfo (ManagedPtr MetaInfo)
instance WrappedPtr MetaInfo where
    wrappedPtrCalloc = callocBytes 80
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 80 >=> 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


noMetaInfo :: Maybe MetaInfo
noMetaInfo = Nothing

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'

setMetaInfoApi :: MonadIO m => MetaInfo -> GType -> m ()
setMetaInfoApi s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = gtypeToCGType val
    poke (ptr `plusPtr` 0) (val' :: CGType)

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


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'

setMetaInfoType :: MonadIO m => MetaInfo -> GType -> m ()
setMetaInfoType s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = gtypeToCGType val
    poke (ptr `plusPtr` 8) (val' :: CGType)

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


getMetaInfoSize :: MonadIO m => MetaInfo -> m Word64
getMetaInfoSize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word64
    return val

setMetaInfoSize :: MonadIO m => MetaInfo -> Word64 -> m ()
setMetaInfoSize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word64)

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


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

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)

clearMetaInfoInitFunc :: MonadIO m => MetaInfo -> m ()
clearMetaInfoInitFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MetaInitFunction)

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


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

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)

clearMetaInfoFreeFunc :: MonadIO m => MetaInfo -> m ()
clearMetaInfoFreeFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MetaFreeFunction)

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


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

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)

clearMetaInfoTransformFunc :: MonadIO m => MetaInfo -> m ()
clearMetaInfoTransformFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MetaTransformFunction)

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



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, *)])

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

instance (info ~ ResolveMetaInfoMethod t MetaInfo, O.MethodInfo info MetaInfo p) => O.IsLabelProxy t (MetaInfo -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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