{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Virtual table for a JSCClass. This can be optionally used when registering a t'GI.JavaScriptCore.Objects.Class.Class' in a t'GI.JavaScriptCore.Objects.Context.Context'
-- to provide a custom implementation for the class. All virtual functions are optional and can be set to
-- 'P.Nothing' to fallback to the default implementation.

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

module GI.JavaScriptCore.Structs.ClassVTable
    ( 

-- * Exported types
    ClassVTable(..)                         ,
    newZeroClassVTable                      ,
    noClassVTable                           ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveClassVTableMethod                ,
#endif




 -- * Properties
-- ** deleteProperty #attr:deleteProperty#
-- | a t'GI.JavaScriptCore.Callbacks.ClassDeletePropertyFunction' for deleting a property.

#if defined(ENABLE_OVERLOADING)
    classVTable_deleteProperty              ,
#endif
    clearClassVTableDeleteProperty          ,
    getClassVTableDeleteProperty            ,
    setClassVTableDeleteProperty            ,


-- ** enumerateProperties #attr:enumerateProperties#
-- | a t'GI.JavaScriptCore.Callbacks.ClassEnumeratePropertiesFunction' for enumerating properties.

#if defined(ENABLE_OVERLOADING)
    classVTable_enumerateProperties         ,
#endif
    clearClassVTableEnumerateProperties     ,
    getClassVTableEnumerateProperties       ,
    setClassVTableEnumerateProperties       ,


-- ** getProperty #attr:getProperty#
-- | a t'GI.JavaScriptCore.Callbacks.ClassGetPropertyFunction' for getting a property.

#if defined(ENABLE_OVERLOADING)
    classVTable_getProperty                 ,
#endif
    clearClassVTableGetProperty             ,
    getClassVTableGetProperty               ,
    setClassVTableGetProperty               ,


-- ** hasProperty #attr:hasProperty#
-- | a t'GI.JavaScriptCore.Callbacks.ClassHasPropertyFunction' for querying a property.

#if defined(ENABLE_OVERLOADING)
    classVTable_hasProperty                 ,
#endif
    clearClassVTableHasProperty             ,
    getClassVTableHasProperty               ,
    setClassVTableHasProperty               ,


-- ** setProperty #attr:setProperty#
-- | a t'GI.JavaScriptCore.Callbacks.ClassSetPropertyFunction' for setting a property.

#if defined(ENABLE_OVERLOADING)
    classVTable_setProperty                 ,
#endif
    clearClassVTableSetProperty             ,
    getClassVTableSetProperty               ,
    setClassVTableSetProperty               ,




    ) 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.GI.Base.Signals as B.Signals
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.JavaScriptCore.Callbacks as JavaScriptCore.Callbacks

-- | Memory-managed wrapper type.
newtype ClassVTable = ClassVTable (ManagedPtr ClassVTable)
    deriving (ClassVTable -> ClassVTable -> Bool
(ClassVTable -> ClassVTable -> Bool)
-> (ClassVTable -> ClassVTable -> Bool) -> Eq ClassVTable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClassVTable -> ClassVTable -> Bool
$c/= :: ClassVTable -> ClassVTable -> Bool
== :: ClassVTable -> ClassVTable -> Bool
$c== :: ClassVTable -> ClassVTable -> Bool
Eq)
instance WrappedPtr ClassVTable where
    wrappedPtrCalloc :: IO (Ptr ClassVTable)
wrappedPtrCalloc = Int -> IO (Ptr ClassVTable)
forall a. Int -> IO (Ptr a)
callocBytes 72
    wrappedPtrCopy :: ClassVTable -> IO ClassVTable
wrappedPtrCopy = \p :: ClassVTable
p -> ClassVTable
-> (Ptr ClassVTable -> IO ClassVTable) -> IO ClassVTable
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
p (Int -> Ptr ClassVTable -> IO (Ptr ClassVTable)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 72 (Ptr ClassVTable -> IO (Ptr ClassVTable))
-> (Ptr ClassVTable -> IO ClassVTable)
-> Ptr ClassVTable
-> IO ClassVTable
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ClassVTable -> ClassVTable)
-> Ptr ClassVTable -> IO ClassVTable
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ClassVTable -> ClassVTable
ClassVTable)
    wrappedPtrFree :: Maybe (GDestroyNotify ClassVTable)
wrappedPtrFree = GDestroyNotify ClassVTable -> Maybe (GDestroyNotify ClassVTable)
forall a. a -> Maybe a
Just GDestroyNotify ClassVTable
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `ClassVTable` struct initialized to zero.
newZeroClassVTable :: MonadIO m => m ClassVTable
newZeroClassVTable :: m ClassVTable
newZeroClassVTable = IO ClassVTable -> m ClassVTable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ClassVTable -> m ClassVTable)
-> IO ClassVTable -> m ClassVTable
forall a b. (a -> b) -> a -> b
$ IO (Ptr ClassVTable)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr ClassVTable)
-> (Ptr ClassVTable -> IO ClassVTable) -> IO ClassVTable
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ClassVTable -> ClassVTable)
-> Ptr ClassVTable -> IO ClassVTable
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ClassVTable -> ClassVTable
ClassVTable

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


-- | A convenience alias for `Nothing` :: `Maybe` `ClassVTable`.
noClassVTable :: Maybe ClassVTable
noClassVTable :: Maybe ClassVTable
noClassVTable = Maybe ClassVTable
forall a. Maybe a
Nothing

-- | Get the value of the “@get_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' classVTable #getProperty
-- @
getClassVTableGetProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassGetPropertyFunction)
getClassVTableGetProperty :: ClassVTable -> m (Maybe ClassGetPropertyFunction)
getClassVTableGetProperty s :: ClassVTable
s = IO (Maybe ClassGetPropertyFunction)
-> m (Maybe ClassGetPropertyFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ClassGetPropertyFunction)
 -> m (Maybe ClassGetPropertyFunction))
-> IO (Maybe ClassGetPropertyFunction)
-> m (Maybe ClassGetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ ClassVTable
-> (Ptr ClassVTable -> IO (Maybe ClassGetPropertyFunction))
-> IO (Maybe ClassGetPropertyFunction)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO (Maybe ClassGetPropertyFunction))
 -> IO (Maybe ClassGetPropertyFunction))
-> (Ptr ClassVTable -> IO (Maybe ClassGetPropertyFunction))
-> IO (Maybe ClassGetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    FunPtr C_ClassGetPropertyFunction
val <- Ptr (FunPtr C_ClassGetPropertyFunction)
-> IO (FunPtr C_ClassGetPropertyFunction)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassGetPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction)
    Maybe ClassGetPropertyFunction
result <- FunPtr C_ClassGetPropertyFunction
-> (FunPtr C_ClassGetPropertyFunction
    -> IO ClassGetPropertyFunction)
-> IO (Maybe ClassGetPropertyFunction)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ClassGetPropertyFunction
val ((FunPtr C_ClassGetPropertyFunction -> IO ClassGetPropertyFunction)
 -> IO (Maybe ClassGetPropertyFunction))
-> (FunPtr C_ClassGetPropertyFunction
    -> IO ClassGetPropertyFunction)
-> IO (Maybe ClassGetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_ClassGetPropertyFunction
val' -> do
        let val'' :: ClassGetPropertyFunction
val'' = FunPtr C_ClassGetPropertyFunction -> ClassGetPropertyFunction
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassGetPropertyFunction
-> a -> b -> Ptr () -> Text -> m (Maybe Value)
JavaScriptCore.Callbacks.dynamic_ClassGetPropertyFunction FunPtr C_ClassGetPropertyFunction
val'
        ClassGetPropertyFunction -> IO ClassGetPropertyFunction
forall (m :: * -> *) a. Monad m => a -> m a
return ClassGetPropertyFunction
val''
    Maybe ClassGetPropertyFunction
-> IO (Maybe ClassGetPropertyFunction)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClassGetPropertyFunction
result

-- | Set the value of the “@get_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' classVTable [ #getProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setClassVTableGetProperty :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction -> m ()
setClassVTableGetProperty :: ClassVTable -> FunPtr C_ClassGetPropertyFunction -> m ()
setClassVTableGetProperty s :: ClassVTable
s val :: FunPtr C_ClassGetPropertyFunction
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassGetPropertyFunction)
-> FunPtr C_ClassGetPropertyFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassGetPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (FunPtr C_ClassGetPropertyFunction
val :: FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction)

-- | Set the value of the “@get_property@” 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' #getProperty
-- @
clearClassVTableGetProperty :: MonadIO m => ClassVTable -> m ()
clearClassVTableGetProperty :: ClassVTable -> m ()
clearClassVTableGetProperty s :: ClassVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassGetPropertyFunction)
-> FunPtr C_ClassGetPropertyFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassGetPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (FunPtr C_ClassGetPropertyFunction
forall a. FunPtr a
FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction)

#if defined(ENABLE_OVERLOADING)
data ClassVTableGetPropertyFieldInfo
instance AttrInfo ClassVTableGetPropertyFieldInfo where
    type AttrBaseTypeConstraint ClassVTableGetPropertyFieldInfo = (~) ClassVTable
    type AttrAllowedOps ClassVTableGetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClassVTableGetPropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction)
    type AttrTransferTypeConstraint ClassVTableGetPropertyFieldInfo = (~)JavaScriptCore.Callbacks.ClassGetPropertyFunction
    type AttrTransferType ClassVTableGetPropertyFieldInfo = (FunPtr JavaScriptCore.Callbacks.C_ClassGetPropertyFunction)
    type AttrGetType ClassVTableGetPropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassGetPropertyFunction
    type AttrLabel ClassVTableGetPropertyFieldInfo = "get_property"
    type AttrOrigin ClassVTableGetPropertyFieldInfo = ClassVTable
    attrGet = getClassVTableGetProperty
    attrSet = setClassVTableGetProperty
    attrConstruct = undefined
    attrClear = clearClassVTableGetProperty
    attrTransfer _ v = do
        JavaScriptCore.Callbacks.mk_ClassGetPropertyFunction (JavaScriptCore.Callbacks.wrap_ClassGetPropertyFunction Nothing v)

classVTable_getProperty :: AttrLabelProxy "getProperty"
classVTable_getProperty = AttrLabelProxy

#endif


-- | Get the value of the “@set_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' classVTable #setProperty
-- @
getClassVTableSetProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassSetPropertyFunction)
getClassVTableSetProperty :: ClassVTable -> m (Maybe ClassSetPropertyFunction)
getClassVTableSetProperty s :: ClassVTable
s = IO (Maybe ClassSetPropertyFunction)
-> m (Maybe ClassSetPropertyFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ClassSetPropertyFunction)
 -> m (Maybe ClassSetPropertyFunction))
-> IO (Maybe ClassSetPropertyFunction)
-> m (Maybe ClassSetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ ClassVTable
-> (Ptr ClassVTable -> IO (Maybe ClassSetPropertyFunction))
-> IO (Maybe ClassSetPropertyFunction)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO (Maybe ClassSetPropertyFunction))
 -> IO (Maybe ClassSetPropertyFunction))
-> (Ptr ClassVTable -> IO (Maybe ClassSetPropertyFunction))
-> IO (Maybe ClassSetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    FunPtr C_ClassSetPropertyFunction
val <- Ptr (FunPtr C_ClassSetPropertyFunction)
-> IO (FunPtr C_ClassSetPropertyFunction)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassSetPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction)
    Maybe ClassSetPropertyFunction
result <- FunPtr C_ClassSetPropertyFunction
-> (FunPtr C_ClassSetPropertyFunction
    -> IO ClassSetPropertyFunction)
-> IO (Maybe ClassSetPropertyFunction)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ClassSetPropertyFunction
val ((FunPtr C_ClassSetPropertyFunction -> IO ClassSetPropertyFunction)
 -> IO (Maybe ClassSetPropertyFunction))
-> (FunPtr C_ClassSetPropertyFunction
    -> IO ClassSetPropertyFunction)
-> IO (Maybe ClassSetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_ClassSetPropertyFunction
val' -> do
        let val'' :: ClassSetPropertyFunction
val'' = FunPtr C_ClassSetPropertyFunction -> ClassSetPropertyFunction
forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsClass a, IsContext b, IsValue c) =>
FunPtr C_ClassSetPropertyFunction
-> a -> b -> Ptr () -> Text -> c -> m Bool
JavaScriptCore.Callbacks.dynamic_ClassSetPropertyFunction FunPtr C_ClassSetPropertyFunction
val'
        ClassSetPropertyFunction -> IO ClassSetPropertyFunction
forall (m :: * -> *) a. Monad m => a -> m a
return ClassSetPropertyFunction
val''
    Maybe ClassSetPropertyFunction
-> IO (Maybe ClassSetPropertyFunction)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClassSetPropertyFunction
result

-- | Set the value of the “@set_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' classVTable [ #setProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setClassVTableSetProperty :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction -> m ()
setClassVTableSetProperty :: ClassVTable -> FunPtr C_ClassSetPropertyFunction -> m ()
setClassVTableSetProperty s :: ClassVTable
s val :: FunPtr C_ClassSetPropertyFunction
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassSetPropertyFunction)
-> FunPtr C_ClassSetPropertyFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassSetPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (FunPtr C_ClassSetPropertyFunction
val :: FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction)

-- | Set the value of the “@set_property@” 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' #setProperty
-- @
clearClassVTableSetProperty :: MonadIO m => ClassVTable -> m ()
clearClassVTableSetProperty :: ClassVTable -> m ()
clearClassVTableSetProperty s :: ClassVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassSetPropertyFunction)
-> FunPtr C_ClassSetPropertyFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassSetPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (FunPtr C_ClassSetPropertyFunction
forall a. FunPtr a
FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction)

#if defined(ENABLE_OVERLOADING)
data ClassVTableSetPropertyFieldInfo
instance AttrInfo ClassVTableSetPropertyFieldInfo where
    type AttrBaseTypeConstraint ClassVTableSetPropertyFieldInfo = (~) ClassVTable
    type AttrAllowedOps ClassVTableSetPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClassVTableSetPropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction)
    type AttrTransferTypeConstraint ClassVTableSetPropertyFieldInfo = (~)JavaScriptCore.Callbacks.ClassSetPropertyFunction
    type AttrTransferType ClassVTableSetPropertyFieldInfo = (FunPtr JavaScriptCore.Callbacks.C_ClassSetPropertyFunction)
    type AttrGetType ClassVTableSetPropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassSetPropertyFunction
    type AttrLabel ClassVTableSetPropertyFieldInfo = "set_property"
    type AttrOrigin ClassVTableSetPropertyFieldInfo = ClassVTable
    attrGet = getClassVTableSetProperty
    attrSet = setClassVTableSetProperty
    attrConstruct = undefined
    attrClear = clearClassVTableSetProperty
    attrTransfer _ v = do
        JavaScriptCore.Callbacks.mk_ClassSetPropertyFunction (JavaScriptCore.Callbacks.wrap_ClassSetPropertyFunction Nothing v)

classVTable_setProperty :: AttrLabelProxy "setProperty"
classVTable_setProperty = AttrLabelProxy

#endif


-- | Get the value of the “@has_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' classVTable #hasProperty
-- @
getClassVTableHasProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassHasPropertyFunction)
getClassVTableHasProperty :: ClassVTable -> m (Maybe ClassHasPropertyFunction)
getClassVTableHasProperty s :: ClassVTable
s = IO (Maybe ClassHasPropertyFunction)
-> m (Maybe ClassHasPropertyFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ClassHasPropertyFunction)
 -> m (Maybe ClassHasPropertyFunction))
-> IO (Maybe ClassHasPropertyFunction)
-> m (Maybe ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ ClassVTable
-> (Ptr ClassVTable -> IO (Maybe ClassHasPropertyFunction))
-> IO (Maybe ClassHasPropertyFunction)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO (Maybe ClassHasPropertyFunction))
 -> IO (Maybe ClassHasPropertyFunction))
-> (Ptr ClassVTable -> IO (Maybe ClassHasPropertyFunction))
-> IO (Maybe ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    FunPtr C_ClassHasPropertyFunction
val <- Ptr (FunPtr C_ClassHasPropertyFunction)
-> IO (FunPtr C_ClassHasPropertyFunction)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassHasPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction)
    Maybe ClassHasPropertyFunction
result <- FunPtr C_ClassHasPropertyFunction
-> (FunPtr C_ClassHasPropertyFunction
    -> IO ClassHasPropertyFunction)
-> IO (Maybe ClassHasPropertyFunction)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ClassHasPropertyFunction
val ((FunPtr C_ClassHasPropertyFunction -> IO ClassHasPropertyFunction)
 -> IO (Maybe ClassHasPropertyFunction))
-> (FunPtr C_ClassHasPropertyFunction
    -> IO ClassHasPropertyFunction)
-> IO (Maybe ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_ClassHasPropertyFunction
val' -> do
        let val'' :: ClassHasPropertyFunction
val'' = FunPtr C_ClassHasPropertyFunction -> ClassHasPropertyFunction
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassHasPropertyFunction
-> a -> b -> Ptr () -> Text -> m Bool
JavaScriptCore.Callbacks.dynamic_ClassHasPropertyFunction FunPtr C_ClassHasPropertyFunction
val'
        ClassHasPropertyFunction -> IO ClassHasPropertyFunction
forall (m :: * -> *) a. Monad m => a -> m a
return ClassHasPropertyFunction
val''
    Maybe ClassHasPropertyFunction
-> IO (Maybe ClassHasPropertyFunction)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClassHasPropertyFunction
result

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

-- | Set the value of the “@has_property@” 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' #hasProperty
-- @
clearClassVTableHasProperty :: MonadIO m => ClassVTable -> m ()
clearClassVTableHasProperty :: ClassVTable -> m ()
clearClassVTableHasProperty s :: ClassVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassHasPropertyFunction)
-> FunPtr C_ClassHasPropertyFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassHasPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (FunPtr C_ClassHasPropertyFunction
forall a. FunPtr a
FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction)

#if defined(ENABLE_OVERLOADING)
data ClassVTableHasPropertyFieldInfo
instance AttrInfo ClassVTableHasPropertyFieldInfo where
    type AttrBaseTypeConstraint ClassVTableHasPropertyFieldInfo = (~) ClassVTable
    type AttrAllowedOps ClassVTableHasPropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClassVTableHasPropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction)
    type AttrTransferTypeConstraint ClassVTableHasPropertyFieldInfo = (~)JavaScriptCore.Callbacks.ClassHasPropertyFunction
    type AttrTransferType ClassVTableHasPropertyFieldInfo = (FunPtr JavaScriptCore.Callbacks.C_ClassHasPropertyFunction)
    type AttrGetType ClassVTableHasPropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassHasPropertyFunction
    type AttrLabel ClassVTableHasPropertyFieldInfo = "has_property"
    type AttrOrigin ClassVTableHasPropertyFieldInfo = ClassVTable
    attrGet = getClassVTableHasProperty
    attrSet = setClassVTableHasProperty
    attrConstruct = undefined
    attrClear = clearClassVTableHasProperty
    attrTransfer _ v = do
        JavaScriptCore.Callbacks.mk_ClassHasPropertyFunction (JavaScriptCore.Callbacks.wrap_ClassHasPropertyFunction Nothing v)

classVTable_hasProperty :: AttrLabelProxy "hasProperty"
classVTable_hasProperty = AttrLabelProxy

#endif


-- | Get the value of the “@delete_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' classVTable #deleteProperty
-- @
getClassVTableDeleteProperty :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassDeletePropertyFunction)
getClassVTableDeleteProperty :: ClassVTable -> m (Maybe ClassHasPropertyFunction)
getClassVTableDeleteProperty s :: ClassVTable
s = IO (Maybe ClassHasPropertyFunction)
-> m (Maybe ClassHasPropertyFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ClassHasPropertyFunction)
 -> m (Maybe ClassHasPropertyFunction))
-> IO (Maybe ClassHasPropertyFunction)
-> m (Maybe ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ ClassVTable
-> (Ptr ClassVTable -> IO (Maybe ClassHasPropertyFunction))
-> IO (Maybe ClassHasPropertyFunction)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO (Maybe ClassHasPropertyFunction))
 -> IO (Maybe ClassHasPropertyFunction))
-> (Ptr ClassVTable -> IO (Maybe ClassHasPropertyFunction))
-> IO (Maybe ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    FunPtr C_ClassHasPropertyFunction
val <- Ptr (FunPtr C_ClassHasPropertyFunction)
-> IO (FunPtr C_ClassHasPropertyFunction)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassHasPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction)
    Maybe ClassHasPropertyFunction
result <- FunPtr C_ClassHasPropertyFunction
-> (FunPtr C_ClassHasPropertyFunction
    -> IO ClassHasPropertyFunction)
-> IO (Maybe ClassHasPropertyFunction)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ClassHasPropertyFunction
val ((FunPtr C_ClassHasPropertyFunction -> IO ClassHasPropertyFunction)
 -> IO (Maybe ClassHasPropertyFunction))
-> (FunPtr C_ClassHasPropertyFunction
    -> IO ClassHasPropertyFunction)
-> IO (Maybe ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_ClassHasPropertyFunction
val' -> do
        let val'' :: ClassHasPropertyFunction
val'' = FunPtr C_ClassHasPropertyFunction -> ClassHasPropertyFunction
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassHasPropertyFunction
-> a -> b -> Ptr () -> Text -> m Bool
JavaScriptCore.Callbacks.dynamic_ClassDeletePropertyFunction FunPtr C_ClassHasPropertyFunction
val'
        ClassHasPropertyFunction -> IO ClassHasPropertyFunction
forall (m :: * -> *) a. Monad m => a -> m a
return ClassHasPropertyFunction
val''
    Maybe ClassHasPropertyFunction
-> IO (Maybe ClassHasPropertyFunction)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClassHasPropertyFunction
result

-- | Set the value of the “@delete_property@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' classVTable [ #deleteProperty 'Data.GI.Base.Attributes.:=' value ]
-- @
setClassVTableDeleteProperty :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction -> m ()
setClassVTableDeleteProperty :: ClassVTable -> FunPtr C_ClassHasPropertyFunction -> m ()
setClassVTableDeleteProperty s :: ClassVTable
s val :: FunPtr C_ClassHasPropertyFunction
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassHasPropertyFunction)
-> FunPtr C_ClassHasPropertyFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassHasPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (FunPtr C_ClassHasPropertyFunction
val :: FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction)

-- | Set the value of the “@delete_property@” 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' #deleteProperty
-- @
clearClassVTableDeleteProperty :: MonadIO m => ClassVTable -> m ()
clearClassVTableDeleteProperty :: ClassVTable -> m ()
clearClassVTableDeleteProperty s :: ClassVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassHasPropertyFunction)
-> FunPtr C_ClassHasPropertyFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable -> Int -> Ptr (FunPtr C_ClassHasPropertyFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (FunPtr C_ClassHasPropertyFunction
forall a. FunPtr a
FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction)

#if defined(ENABLE_OVERLOADING)
data ClassVTableDeletePropertyFieldInfo
instance AttrInfo ClassVTableDeletePropertyFieldInfo where
    type AttrBaseTypeConstraint ClassVTableDeletePropertyFieldInfo = (~) ClassVTable
    type AttrAllowedOps ClassVTableDeletePropertyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClassVTableDeletePropertyFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction)
    type AttrTransferTypeConstraint ClassVTableDeletePropertyFieldInfo = (~)JavaScriptCore.Callbacks.ClassDeletePropertyFunction
    type AttrTransferType ClassVTableDeletePropertyFieldInfo = (FunPtr JavaScriptCore.Callbacks.C_ClassDeletePropertyFunction)
    type AttrGetType ClassVTableDeletePropertyFieldInfo = Maybe JavaScriptCore.Callbacks.ClassDeletePropertyFunction
    type AttrLabel ClassVTableDeletePropertyFieldInfo = "delete_property"
    type AttrOrigin ClassVTableDeletePropertyFieldInfo = ClassVTable
    attrGet = getClassVTableDeleteProperty
    attrSet = setClassVTableDeleteProperty
    attrConstruct = undefined
    attrClear = clearClassVTableDeleteProperty
    attrTransfer _ v = do
        JavaScriptCore.Callbacks.mk_ClassDeletePropertyFunction (JavaScriptCore.Callbacks.wrap_ClassDeletePropertyFunction Nothing v)

classVTable_deleteProperty :: AttrLabelProxy "deleteProperty"
classVTable_deleteProperty = AttrLabelProxy

#endif


-- | Get the value of the “@enumerate_properties@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' classVTable #enumerateProperties
-- @
getClassVTableEnumerateProperties :: MonadIO m => ClassVTable -> m (Maybe JavaScriptCore.Callbacks.ClassEnumeratePropertiesFunction)
getClassVTableEnumerateProperties :: ClassVTable -> m (Maybe ClassEnumeratePropertiesFunction)
getClassVTableEnumerateProperties s :: ClassVTable
s = IO (Maybe ClassEnumeratePropertiesFunction)
-> m (Maybe ClassEnumeratePropertiesFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ClassEnumeratePropertiesFunction)
 -> m (Maybe ClassEnumeratePropertiesFunction))
-> IO (Maybe ClassEnumeratePropertiesFunction)
-> m (Maybe ClassEnumeratePropertiesFunction)
forall a b. (a -> b) -> a -> b
$ ClassVTable
-> (Ptr ClassVTable -> IO (Maybe ClassEnumeratePropertiesFunction))
-> IO (Maybe ClassEnumeratePropertiesFunction)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO (Maybe ClassEnumeratePropertiesFunction))
 -> IO (Maybe ClassEnumeratePropertiesFunction))
-> (Ptr ClassVTable -> IO (Maybe ClassEnumeratePropertiesFunction))
-> IO (Maybe ClassEnumeratePropertiesFunction)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    FunPtr C_ClassEnumeratePropertiesFunction
val <- Ptr (FunPtr C_ClassEnumeratePropertiesFunction)
-> IO (FunPtr C_ClassEnumeratePropertiesFunction)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ClassVTable
ptr Ptr ClassVTable
-> Int -> Ptr (FunPtr C_ClassEnumeratePropertiesFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) :: IO (FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction)
    Maybe ClassEnumeratePropertiesFunction
result <- FunPtr C_ClassEnumeratePropertiesFunction
-> (FunPtr C_ClassEnumeratePropertiesFunction
    -> IO ClassEnumeratePropertiesFunction)
-> IO (Maybe ClassEnumeratePropertiesFunction)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ClassEnumeratePropertiesFunction
val ((FunPtr C_ClassEnumeratePropertiesFunction
  -> IO ClassEnumeratePropertiesFunction)
 -> IO (Maybe ClassEnumeratePropertiesFunction))
-> (FunPtr C_ClassEnumeratePropertiesFunction
    -> IO ClassEnumeratePropertiesFunction)
-> IO (Maybe ClassEnumeratePropertiesFunction)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_ClassEnumeratePropertiesFunction
val' -> do
        let val'' :: ClassEnumeratePropertiesFunction
val'' = FunPtr C_ClassEnumeratePropertiesFunction
-> ClassEnumeratePropertiesFunction
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassEnumeratePropertiesFunction
-> a -> b -> Ptr () -> m (Maybe [Text])
JavaScriptCore.Callbacks.dynamic_ClassEnumeratePropertiesFunction FunPtr C_ClassEnumeratePropertiesFunction
val'
        ClassEnumeratePropertiesFunction
-> IO ClassEnumeratePropertiesFunction
forall (m :: * -> *) a. Monad m => a -> m a
return ClassEnumeratePropertiesFunction
val''
    Maybe ClassEnumeratePropertiesFunction
-> IO (Maybe ClassEnumeratePropertiesFunction)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClassEnumeratePropertiesFunction
result

-- | Set the value of the “@enumerate_properties@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' classVTable [ #enumerateProperties 'Data.GI.Base.Attributes.:=' value ]
-- @
setClassVTableEnumerateProperties :: MonadIO m => ClassVTable -> FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction -> m ()
setClassVTableEnumerateProperties :: ClassVTable -> FunPtr C_ClassEnumeratePropertiesFunction -> m ()
setClassVTableEnumerateProperties s :: ClassVTable
s val :: FunPtr C_ClassEnumeratePropertiesFunction
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassEnumeratePropertiesFunction)
-> FunPtr C_ClassEnumeratePropertiesFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable
-> Int -> Ptr (FunPtr C_ClassEnumeratePropertiesFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (FunPtr C_ClassEnumeratePropertiesFunction
val :: FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction)

-- | Set the value of the “@enumerate_properties@” 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' #enumerateProperties
-- @
clearClassVTableEnumerateProperties :: MonadIO m => ClassVTable -> m ()
clearClassVTableEnumerateProperties :: ClassVTable -> m ()
clearClassVTableEnumerateProperties s :: ClassVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ClassVTable -> (Ptr ClassVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ClassVTable
s ((Ptr ClassVTable -> IO ()) -> IO ())
-> (Ptr ClassVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr ClassVTable
ptr -> do
    Ptr (FunPtr C_ClassEnumeratePropertiesFunction)
-> FunPtr C_ClassEnumeratePropertiesFunction -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ClassVTable
ptr Ptr ClassVTable
-> Int -> Ptr (FunPtr C_ClassEnumeratePropertiesFunction)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (FunPtr C_ClassEnumeratePropertiesFunction
forall a. FunPtr a
FP.nullFunPtr :: FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction)

#if defined(ENABLE_OVERLOADING)
data ClassVTableEnumeratePropertiesFieldInfo
instance AttrInfo ClassVTableEnumeratePropertiesFieldInfo where
    type AttrBaseTypeConstraint ClassVTableEnumeratePropertiesFieldInfo = (~) ClassVTable
    type AttrAllowedOps ClassVTableEnumeratePropertiesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClassVTableEnumeratePropertiesFieldInfo = (~) (FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction)
    type AttrTransferTypeConstraint ClassVTableEnumeratePropertiesFieldInfo = (~)JavaScriptCore.Callbacks.ClassEnumeratePropertiesFunction
    type AttrTransferType ClassVTableEnumeratePropertiesFieldInfo = (FunPtr JavaScriptCore.Callbacks.C_ClassEnumeratePropertiesFunction)
    type AttrGetType ClassVTableEnumeratePropertiesFieldInfo = Maybe JavaScriptCore.Callbacks.ClassEnumeratePropertiesFunction
    type AttrLabel ClassVTableEnumeratePropertiesFieldInfo = "enumerate_properties"
    type AttrOrigin ClassVTableEnumeratePropertiesFieldInfo = ClassVTable
    attrGet = getClassVTableEnumerateProperties
    attrSet = setClassVTableEnumerateProperties
    attrConstruct = undefined
    attrClear = clearClassVTableEnumerateProperties
    attrTransfer _ v = do
        JavaScriptCore.Callbacks.mk_ClassEnumeratePropertiesFunction (JavaScriptCore.Callbacks.wrap_ClassEnumeratePropertiesFunction Nothing v)

classVTable_enumerateProperties :: AttrLabelProxy "enumerateProperties"
classVTable_enumerateProperties = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ClassVTable
type instance O.AttributeList ClassVTable = ClassVTableAttributeList
type ClassVTableAttributeList = ('[ '("getProperty", ClassVTableGetPropertyFieldInfo), '("setProperty", ClassVTableSetPropertyFieldInfo), '("hasProperty", ClassVTableHasPropertyFieldInfo), '("deleteProperty", ClassVTableDeletePropertyFieldInfo), '("enumerateProperties", ClassVTableEnumeratePropertiesFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif