#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.JavaScriptCore.Callbacks
(
C_ClassDeletePropertyFunction ,
ClassDeletePropertyFunction ,
dynamic_ClassDeletePropertyFunction ,
genClosure_ClassDeletePropertyFunction ,
mk_ClassDeletePropertyFunction ,
noClassDeletePropertyFunction ,
wrap_ClassDeletePropertyFunction ,
C_ClassEnumeratePropertiesFunction ,
ClassEnumeratePropertiesFunction ,
dynamic_ClassEnumeratePropertiesFunction,
genClosure_ClassEnumeratePropertiesFunction,
mk_ClassEnumeratePropertiesFunction ,
noClassEnumeratePropertiesFunction ,
wrap_ClassEnumeratePropertiesFunction ,
C_ClassGetPropertyFunction ,
ClassGetPropertyFunction ,
dynamic_ClassGetPropertyFunction ,
genClosure_ClassGetPropertyFunction ,
mk_ClassGetPropertyFunction ,
noClassGetPropertyFunction ,
wrap_ClassGetPropertyFunction ,
C_ClassHasPropertyFunction ,
ClassHasPropertyFunction ,
dynamic_ClassHasPropertyFunction ,
genClosure_ClassHasPropertyFunction ,
mk_ClassHasPropertyFunction ,
noClassHasPropertyFunction ,
wrap_ClassHasPropertyFunction ,
C_ClassSetPropertyFunction ,
ClassSetPropertyFunction ,
dynamic_ClassSetPropertyFunction ,
genClosure_ClassSetPropertyFunction ,
mk_ClassSetPropertyFunction ,
noClassSetPropertyFunction ,
wrap_ClassSetPropertyFunction ,
C_ExceptionHandler ,
ExceptionHandler ,
ExceptionHandler_WithClosures ,
drop_closures_ExceptionHandler ,
dynamic_ExceptionHandler ,
genClosure_ExceptionHandler ,
mk_ExceptionHandler ,
noExceptionHandler ,
noExceptionHandler_WithClosures ,
wrap_ExceptionHandler ,
C_OptionsFunc ,
OptionsFunc ,
OptionsFunc_WithClosures ,
drop_closures_OptionsFunc ,
dynamic_OptionsFunc ,
genClosure_OptionsFunc ,
mk_OptionsFunc ,
noOptionsFunc ,
noOptionsFunc_WithClosures ,
wrap_OptionsFunc ,
) 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
import {-# SOURCE #-} qualified GI.JavaScriptCore.Enums as JavaScriptCore.Enums
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Exception as JavaScriptCore.Exception
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value
type C_OptionsFunc =
CString ->
CUInt ->
CString ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_OptionsFunc :: FunPtr C_OptionsFunc -> C_OptionsFunc
dynamic_OptionsFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_OptionsFunc
-> T.Text
-> JavaScriptCore.Enums.OptionType
-> Maybe (T.Text)
-> Ptr ()
-> m Bool
dynamic_OptionsFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_OptionsFunc
-> Text -> OptionType -> Maybe Text -> Ptr () -> m Bool
dynamic_OptionsFunc FunPtr C_OptionsFunc
__funPtr Text
option OptionType
type_ Maybe Text
description Ptr ()
userData = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
option' <- Text -> IO CString
textToCString Text
option
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (OptionType -> Int) -> OptionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OptionType -> Int
forall a. Enum a => a -> Int
fromEnum) OptionType
type_
CString
maybeDescription <- case Maybe Text
description of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jDescription -> do
CString
jDescription' <- Text -> IO CString
textToCString Text
jDescription
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jDescription'
CInt
result <- (FunPtr C_OptionsFunc -> C_OptionsFunc
__dynamic_C_OptionsFunc FunPtr C_OptionsFunc
__funPtr) CString
option' CUInt
type_' CString
maybeDescription Ptr ()
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
option'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeDescription
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_OptionsFunc :: C_OptionsFunc -> IO (FunPtr C_OptionsFunc)
type OptionsFunc =
T.Text
-> JavaScriptCore.Enums.OptionType
-> Maybe T.Text
-> IO Bool
noOptionsFunc :: Maybe OptionsFunc
noOptionsFunc :: Maybe OptionsFunc
noOptionsFunc = Maybe OptionsFunc
forall a. Maybe a
Nothing
type OptionsFunc_WithClosures =
T.Text
-> JavaScriptCore.Enums.OptionType
-> Maybe T.Text
-> Ptr ()
-> IO Bool
noOptionsFunc_WithClosures :: Maybe OptionsFunc_WithClosures
noOptionsFunc_WithClosures :: Maybe OptionsFunc_WithClosures
noOptionsFunc_WithClosures = Maybe OptionsFunc_WithClosures
forall a. Maybe a
Nothing
drop_closures_OptionsFunc :: OptionsFunc -> OptionsFunc_WithClosures
drop_closures_OptionsFunc :: OptionsFunc -> OptionsFunc_WithClosures
drop_closures_OptionsFunc OptionsFunc
_f Text
option OptionType
type_ Maybe Text
description Ptr ()
_ = OptionsFunc
_f Text
option OptionType
type_ Maybe Text
description
genClosure_OptionsFunc :: MonadIO m => OptionsFunc -> m (GClosure C_OptionsFunc)
genClosure_OptionsFunc :: forall (m :: * -> *).
MonadIO m =>
OptionsFunc -> m (GClosure C_OptionsFunc)
genClosure_OptionsFunc OptionsFunc
cb = IO (GClosure C_OptionsFunc) -> m (GClosure C_OptionsFunc)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_OptionsFunc) -> m (GClosure C_OptionsFunc))
-> IO (GClosure C_OptionsFunc) -> m (GClosure C_OptionsFunc)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: OptionsFunc_WithClosures
cb' = OptionsFunc -> OptionsFunc_WithClosures
drop_closures_OptionsFunc OptionsFunc
cb
let cb'' :: C_OptionsFunc
cb'' = Maybe (Ptr (FunPtr C_OptionsFunc))
-> OptionsFunc_WithClosures -> C_OptionsFunc
wrap_OptionsFunc Maybe (Ptr (FunPtr C_OptionsFunc))
forall a. Maybe a
Nothing OptionsFunc_WithClosures
cb'
C_OptionsFunc -> IO (FunPtr C_OptionsFunc)
mk_OptionsFunc C_OptionsFunc
cb'' IO (FunPtr C_OptionsFunc)
-> (FunPtr C_OptionsFunc -> IO (GClosure C_OptionsFunc))
-> IO (GClosure C_OptionsFunc)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_OptionsFunc -> IO (GClosure C_OptionsFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_OptionsFunc ::
Maybe (Ptr (FunPtr C_OptionsFunc)) ->
OptionsFunc_WithClosures ->
C_OptionsFunc
wrap_OptionsFunc :: Maybe (Ptr (FunPtr C_OptionsFunc))
-> OptionsFunc_WithClosures -> C_OptionsFunc
wrap_OptionsFunc Maybe (Ptr (FunPtr C_OptionsFunc))
gi'funptrptr OptionsFunc_WithClosures
gi'cb CString
option CUInt
type_ CString
description Ptr ()
userData = do
Text
option' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
option
let type_' :: OptionType
type_' = (Int -> OptionType
forall a. Enum a => Int -> a
toEnum (Int -> OptionType) -> (CUInt -> Int) -> CUInt -> OptionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
type_
Maybe Text
maybeDescription <-
if CString
description CString -> CString -> Bool
forall a. Eq a => a -> a -> Bool
== CString
forall a. Ptr a
nullPtr
then Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
Nothing
else do
Text
description' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
description
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text -> IO (Maybe Text)) -> Maybe Text -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
description'
Bool
result <- OptionsFunc_WithClosures
gi'cb Text
option' OptionType
type_' Maybe Text
maybeDescription Ptr ()
userData
Maybe (Ptr (FunPtr C_OptionsFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_OptionsFunc))
gi'funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_ExceptionHandler =
Ptr JavaScriptCore.Context.Context ->
Ptr JavaScriptCore.Exception.Exception ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ExceptionHandler :: FunPtr C_ExceptionHandler -> C_ExceptionHandler
dynamic_ExceptionHandler ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a, JavaScriptCore.Exception.IsException b) =>
FunPtr C_ExceptionHandler
-> a
-> b
-> Ptr ()
-> m ()
dynamic_ExceptionHandler :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContext a, IsException b) =>
FunPtr C_ExceptionHandler -> a -> b -> Ptr () -> m ()
dynamic_ExceptionHandler FunPtr C_ExceptionHandler
__funPtr a
context b
exception Ptr ()
userData = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr Exception
exception' <- b -> IO (Ptr Exception)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
exception
(FunPtr C_ExceptionHandler -> C_ExceptionHandler
__dynamic_C_ExceptionHandler FunPtr C_ExceptionHandler
__funPtr) Ptr Context
context' Ptr Exception
exception' Ptr ()
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
exception
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ExceptionHandler :: C_ExceptionHandler -> IO (FunPtr C_ExceptionHandler)
type ExceptionHandler =
JavaScriptCore.Context.Context
-> JavaScriptCore.Exception.Exception
-> IO ()
noExceptionHandler :: Maybe ExceptionHandler
noExceptionHandler :: Maybe ExceptionHandler
noExceptionHandler = Maybe ExceptionHandler
forall a. Maybe a
Nothing
type ExceptionHandler_WithClosures =
JavaScriptCore.Context.Context
-> JavaScriptCore.Exception.Exception
-> Ptr ()
-> IO ()
noExceptionHandler_WithClosures :: Maybe ExceptionHandler_WithClosures
noExceptionHandler_WithClosures :: Maybe ExceptionHandler_WithClosures
noExceptionHandler_WithClosures = Maybe ExceptionHandler_WithClosures
forall a. Maybe a
Nothing
drop_closures_ExceptionHandler :: ExceptionHandler -> ExceptionHandler_WithClosures
drop_closures_ExceptionHandler :: ExceptionHandler -> ExceptionHandler_WithClosures
drop_closures_ExceptionHandler ExceptionHandler
_f Context
context Exception
exception Ptr ()
_ = ExceptionHandler
_f Context
context Exception
exception
genClosure_ExceptionHandler :: MonadIO m => ExceptionHandler -> m (GClosure C_ExceptionHandler)
genClosure_ExceptionHandler :: forall (m :: * -> *).
MonadIO m =>
ExceptionHandler -> m (GClosure C_ExceptionHandler)
genClosure_ExceptionHandler ExceptionHandler
cb = IO (GClosure C_ExceptionHandler) -> m (GClosure C_ExceptionHandler)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ExceptionHandler)
-> m (GClosure C_ExceptionHandler))
-> IO (GClosure C_ExceptionHandler)
-> m (GClosure C_ExceptionHandler)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: ExceptionHandler_WithClosures
cb' = ExceptionHandler -> ExceptionHandler_WithClosures
drop_closures_ExceptionHandler ExceptionHandler
cb
let cb'' :: C_ExceptionHandler
cb'' = Maybe (Ptr (FunPtr C_ExceptionHandler))
-> ExceptionHandler_WithClosures -> C_ExceptionHandler
wrap_ExceptionHandler Maybe (Ptr (FunPtr C_ExceptionHandler))
forall a. Maybe a
Nothing ExceptionHandler_WithClosures
cb'
C_ExceptionHandler -> IO (FunPtr C_ExceptionHandler)
mk_ExceptionHandler C_ExceptionHandler
cb'' IO (FunPtr C_ExceptionHandler)
-> (FunPtr C_ExceptionHandler -> IO (GClosure C_ExceptionHandler))
-> IO (GClosure C_ExceptionHandler)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ExceptionHandler -> IO (GClosure C_ExceptionHandler)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ExceptionHandler ::
Maybe (Ptr (FunPtr C_ExceptionHandler)) ->
ExceptionHandler_WithClosures ->
C_ExceptionHandler
wrap_ExceptionHandler :: Maybe (Ptr (FunPtr C_ExceptionHandler))
-> ExceptionHandler_WithClosures -> C_ExceptionHandler
wrap_ExceptionHandler Maybe (Ptr (FunPtr C_ExceptionHandler))
gi'funptrptr ExceptionHandler_WithClosures
gi'cb Ptr Context
context Ptr Exception
exception Ptr ()
userData = do
Context
context' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Context -> Context
JavaScriptCore.Context.Context) Ptr Context
context
Exception
exception' <- ((ManagedPtr Exception -> Exception)
-> Ptr Exception -> IO Exception
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Exception -> Exception
JavaScriptCore.Exception.Exception) Ptr Exception
exception
ExceptionHandler_WithClosures
gi'cb Context
context' Exception
exception' Ptr ()
userData
Maybe (Ptr (FunPtr C_ExceptionHandler)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ExceptionHandler))
gi'funptrptr
type C_ClassSetPropertyFunction =
Ptr JavaScriptCore.Class.Class ->
Ptr JavaScriptCore.Context.Context ->
Ptr () ->
CString ->
Ptr JavaScriptCore.Value.Value ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_ClassSetPropertyFunction :: FunPtr C_ClassSetPropertyFunction -> C_ClassSetPropertyFunction
dynamic_ClassSetPropertyFunction ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b, JavaScriptCore.Value.IsValue c) =>
FunPtr C_ClassSetPropertyFunction
-> a
-> b
-> Ptr ()
-> T.Text
-> c
-> m Bool
dynamic_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
dynamic_ClassSetPropertyFunction FunPtr C_ClassSetPropertyFunction
__funPtr a
jscClass b
context Ptr ()
instance_ Text
name c
value = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Class
jscClass' <- a -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jscClass
Ptr Context
context' <- b -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Value
value' <- c -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
value
CInt
result <- (FunPtr C_ClassSetPropertyFunction -> C_ClassSetPropertyFunction
__dynamic_C_ClassSetPropertyFunction FunPtr C_ClassSetPropertyFunction
__funPtr) Ptr Class
jscClass' Ptr Context
context' Ptr ()
instance_ CString
name' Ptr Value
value'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_ClassSetPropertyFunction :: C_ClassSetPropertyFunction -> IO (FunPtr C_ClassSetPropertyFunction)
type ClassSetPropertyFunction =
JavaScriptCore.Class.Class
-> JavaScriptCore.Context.Context
-> Ptr ()
-> T.Text
-> JavaScriptCore.Value.Value
-> IO Bool
noClassSetPropertyFunction :: Maybe ClassSetPropertyFunction
noClassSetPropertyFunction :: Maybe ClassSetPropertyFunction
noClassSetPropertyFunction = Maybe ClassSetPropertyFunction
forall a. Maybe a
Nothing
genClosure_ClassSetPropertyFunction :: MonadIO m => ClassSetPropertyFunction -> m (GClosure C_ClassSetPropertyFunction)
genClosure_ClassSetPropertyFunction :: forall (m :: * -> *).
MonadIO m =>
ClassSetPropertyFunction -> m (GClosure C_ClassSetPropertyFunction)
genClosure_ClassSetPropertyFunction ClassSetPropertyFunction
cb = IO (GClosure C_ClassSetPropertyFunction)
-> m (GClosure C_ClassSetPropertyFunction)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ClassSetPropertyFunction)
-> m (GClosure C_ClassSetPropertyFunction))
-> IO (GClosure C_ClassSetPropertyFunction)
-> m (GClosure C_ClassSetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ClassSetPropertyFunction
cb' = Maybe (Ptr (FunPtr C_ClassSetPropertyFunction))
-> ClassSetPropertyFunction -> C_ClassSetPropertyFunction
wrap_ClassSetPropertyFunction Maybe (Ptr (FunPtr C_ClassSetPropertyFunction))
forall a. Maybe a
Nothing ClassSetPropertyFunction
cb
C_ClassSetPropertyFunction
-> IO (FunPtr C_ClassSetPropertyFunction)
mk_ClassSetPropertyFunction C_ClassSetPropertyFunction
cb' IO (FunPtr C_ClassSetPropertyFunction)
-> (FunPtr C_ClassSetPropertyFunction
-> IO (GClosure C_ClassSetPropertyFunction))
-> IO (GClosure C_ClassSetPropertyFunction)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClassSetPropertyFunction
-> IO (GClosure C_ClassSetPropertyFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ClassSetPropertyFunction ::
Maybe (Ptr (FunPtr C_ClassSetPropertyFunction)) ->
ClassSetPropertyFunction ->
C_ClassSetPropertyFunction
wrap_ClassSetPropertyFunction :: Maybe (Ptr (FunPtr C_ClassSetPropertyFunction))
-> ClassSetPropertyFunction -> C_ClassSetPropertyFunction
wrap_ClassSetPropertyFunction Maybe (Ptr (FunPtr C_ClassSetPropertyFunction))
gi'funptrptr ClassSetPropertyFunction
gi'cb Ptr Class
jscClass Ptr Context
context Ptr ()
instance_ CString
name Ptr Value
value = do
Class
jscClass' <- ((ManagedPtr Class -> Class) -> Ptr Class -> IO Class
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Class -> Class
JavaScriptCore.Class.Class) Ptr Class
jscClass
Context
context' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Context -> Context
JavaScriptCore.Context.Context) Ptr Context
context
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
Value
value' <- ((ManagedPtr Value -> Value) -> Ptr Value -> IO Value
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Value -> Value
JavaScriptCore.Value.Value) Ptr Value
value
Bool
result <- ClassSetPropertyFunction
gi'cb Class
jscClass' Context
context' Ptr ()
instance_ Text
name' Value
value'
Maybe (Ptr (FunPtr C_ClassSetPropertyFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClassSetPropertyFunction))
gi'funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_ClassHasPropertyFunction =
Ptr JavaScriptCore.Class.Class ->
Ptr JavaScriptCore.Context.Context ->
Ptr () ->
CString ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_ClassHasPropertyFunction :: FunPtr C_ClassHasPropertyFunction -> C_ClassHasPropertyFunction
dynamic_ClassHasPropertyFunction ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>
FunPtr C_ClassHasPropertyFunction
-> a
-> b
-> Ptr ()
-> T.Text
-> m Bool
dynamic_ClassHasPropertyFunction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassHasPropertyFunction
-> a -> b -> Ptr () -> Text -> m Bool
dynamic_ClassHasPropertyFunction FunPtr C_ClassHasPropertyFunction
__funPtr a
jscClass b
context Ptr ()
instance_ Text
name = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Class
jscClass' <- a -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jscClass
Ptr Context
context' <- b -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- (FunPtr C_ClassHasPropertyFunction -> C_ClassHasPropertyFunction
__dynamic_C_ClassHasPropertyFunction FunPtr C_ClassHasPropertyFunction
__funPtr) Ptr Class
jscClass' Ptr Context
context' Ptr ()
instance_ CString
name'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_ClassHasPropertyFunction :: C_ClassHasPropertyFunction -> IO (FunPtr C_ClassHasPropertyFunction)
type ClassHasPropertyFunction =
JavaScriptCore.Class.Class
-> JavaScriptCore.Context.Context
-> Ptr ()
-> T.Text
-> IO Bool
noClassHasPropertyFunction :: Maybe ClassHasPropertyFunction
noClassHasPropertyFunction :: Maybe ClassHasPropertyFunction
noClassHasPropertyFunction = Maybe ClassHasPropertyFunction
forall a. Maybe a
Nothing
genClosure_ClassHasPropertyFunction :: MonadIO m => ClassHasPropertyFunction -> m (GClosure C_ClassHasPropertyFunction)
genClosure_ClassHasPropertyFunction :: forall (m :: * -> *).
MonadIO m =>
ClassHasPropertyFunction -> m (GClosure C_ClassHasPropertyFunction)
genClosure_ClassHasPropertyFunction ClassHasPropertyFunction
cb = IO (GClosure C_ClassHasPropertyFunction)
-> m (GClosure C_ClassHasPropertyFunction)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ClassHasPropertyFunction)
-> m (GClosure C_ClassHasPropertyFunction))
-> IO (GClosure C_ClassHasPropertyFunction)
-> m (GClosure C_ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ClassHasPropertyFunction
cb' = Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
-> ClassHasPropertyFunction -> C_ClassHasPropertyFunction
wrap_ClassHasPropertyFunction Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
forall a. Maybe a
Nothing ClassHasPropertyFunction
cb
C_ClassHasPropertyFunction
-> IO (FunPtr C_ClassHasPropertyFunction)
mk_ClassHasPropertyFunction C_ClassHasPropertyFunction
cb' IO (FunPtr C_ClassHasPropertyFunction)
-> (FunPtr C_ClassHasPropertyFunction
-> IO (GClosure C_ClassHasPropertyFunction))
-> IO (GClosure C_ClassHasPropertyFunction)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClassHasPropertyFunction
-> IO (GClosure C_ClassHasPropertyFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ClassHasPropertyFunction ::
Maybe (Ptr (FunPtr C_ClassHasPropertyFunction)) ->
ClassHasPropertyFunction ->
C_ClassHasPropertyFunction
wrap_ClassHasPropertyFunction :: Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
-> ClassHasPropertyFunction -> C_ClassHasPropertyFunction
wrap_ClassHasPropertyFunction Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
gi'funptrptr ClassHasPropertyFunction
gi'cb Ptr Class
jscClass Ptr Context
context Ptr ()
instance_ CString
name = do
Class
jscClass' <- ((ManagedPtr Class -> Class) -> Ptr Class -> IO Class
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Class -> Class
JavaScriptCore.Class.Class) Ptr Class
jscClass
Context
context' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Context -> Context
JavaScriptCore.Context.Context) Ptr Context
context
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
Bool
result <- ClassHasPropertyFunction
gi'cb Class
jscClass' Context
context' Ptr ()
instance_ Text
name'
Maybe (Ptr (FunPtr C_ClassHasPropertyFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
gi'funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_ClassGetPropertyFunction =
Ptr JavaScriptCore.Class.Class ->
Ptr JavaScriptCore.Context.Context ->
Ptr () ->
CString ->
IO (Ptr JavaScriptCore.Value.Value)
foreign import ccall "dynamic" __dynamic_C_ClassGetPropertyFunction :: FunPtr C_ClassGetPropertyFunction -> C_ClassGetPropertyFunction
dynamic_ClassGetPropertyFunction ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>
FunPtr C_ClassGetPropertyFunction
-> a
-> b
-> Ptr ()
-> T.Text
-> m (Maybe JavaScriptCore.Value.Value)
dynamic_ClassGetPropertyFunction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassGetPropertyFunction
-> a -> b -> Ptr () -> Text -> m (Maybe Value)
dynamic_ClassGetPropertyFunction FunPtr C_ClassGetPropertyFunction
__funPtr a
jscClass b
context Ptr ()
instance_ Text
name = IO (Maybe Value) -> m (Maybe Value)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Value) -> m (Maybe Value))
-> IO (Maybe Value) -> m (Maybe Value)
forall a b. (a -> b) -> a -> b
$ do
Ptr Class
jscClass' <- a -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jscClass
Ptr Context
context' <- b -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Value
result <- (FunPtr C_ClassGetPropertyFunction -> C_ClassGetPropertyFunction
__dynamic_C_ClassGetPropertyFunction FunPtr C_ClassGetPropertyFunction
__funPtr) Ptr Class
jscClass' Ptr Context
context' Ptr ()
instance_ CString
name'
Maybe Value
maybeResult <- Ptr Value -> (Ptr Value -> IO Value) -> IO (Maybe Value)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Value
result ((Ptr Value -> IO Value) -> IO (Maybe Value))
-> (Ptr Value -> IO Value) -> IO (Maybe Value)
forall a b. (a -> b) -> a -> b
$ \Ptr Value
result' -> do
Value
result'' <- ((ManagedPtr Value -> Value) -> Ptr Value -> IO Value
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Value -> Value
JavaScriptCore.Value.Value) Ptr Value
result'
Value -> IO Value
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe Value -> IO (Maybe Value)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Value
maybeResult
foreign import ccall "wrapper"
mk_ClassGetPropertyFunction :: C_ClassGetPropertyFunction -> IO (FunPtr C_ClassGetPropertyFunction)
type ClassGetPropertyFunction =
JavaScriptCore.Class.Class
-> JavaScriptCore.Context.Context
-> Ptr ()
-> T.Text
-> IO (Maybe JavaScriptCore.Value.Value)
noClassGetPropertyFunction :: Maybe ClassGetPropertyFunction
noClassGetPropertyFunction :: Maybe ClassGetPropertyFunction
noClassGetPropertyFunction = Maybe ClassGetPropertyFunction
forall a. Maybe a
Nothing
genClosure_ClassGetPropertyFunction :: MonadIO m => ClassGetPropertyFunction -> m (GClosure C_ClassGetPropertyFunction)
genClosure_ClassGetPropertyFunction :: forall (m :: * -> *).
MonadIO m =>
ClassGetPropertyFunction -> m (GClosure C_ClassGetPropertyFunction)
genClosure_ClassGetPropertyFunction ClassGetPropertyFunction
cb = IO (GClosure C_ClassGetPropertyFunction)
-> m (GClosure C_ClassGetPropertyFunction)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ClassGetPropertyFunction)
-> m (GClosure C_ClassGetPropertyFunction))
-> IO (GClosure C_ClassGetPropertyFunction)
-> m (GClosure C_ClassGetPropertyFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ClassGetPropertyFunction
cb' = Maybe (Ptr (FunPtr C_ClassGetPropertyFunction))
-> ClassGetPropertyFunction -> C_ClassGetPropertyFunction
wrap_ClassGetPropertyFunction Maybe (Ptr (FunPtr C_ClassGetPropertyFunction))
forall a. Maybe a
Nothing ClassGetPropertyFunction
cb
C_ClassGetPropertyFunction
-> IO (FunPtr C_ClassGetPropertyFunction)
mk_ClassGetPropertyFunction C_ClassGetPropertyFunction
cb' IO (FunPtr C_ClassGetPropertyFunction)
-> (FunPtr C_ClassGetPropertyFunction
-> IO (GClosure C_ClassGetPropertyFunction))
-> IO (GClosure C_ClassGetPropertyFunction)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClassGetPropertyFunction
-> IO (GClosure C_ClassGetPropertyFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ClassGetPropertyFunction ::
Maybe (Ptr (FunPtr C_ClassGetPropertyFunction)) ->
ClassGetPropertyFunction ->
C_ClassGetPropertyFunction
wrap_ClassGetPropertyFunction :: Maybe (Ptr (FunPtr C_ClassGetPropertyFunction))
-> ClassGetPropertyFunction -> C_ClassGetPropertyFunction
wrap_ClassGetPropertyFunction Maybe (Ptr (FunPtr C_ClassGetPropertyFunction))
gi'funptrptr ClassGetPropertyFunction
gi'cb Ptr Class
jscClass Ptr Context
context Ptr ()
instance_ CString
name = do
Class
jscClass' <- ((ManagedPtr Class -> Class) -> Ptr Class -> IO Class
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Class -> Class
JavaScriptCore.Class.Class) Ptr Class
jscClass
Context
context' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Context -> Context
JavaScriptCore.Context.Context) Ptr Context
context
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
Maybe Value
result <- ClassGetPropertyFunction
gi'cb Class
jscClass' Context
context' Ptr ()
instance_ Text
name'
Maybe (Ptr (FunPtr C_ClassGetPropertyFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClassGetPropertyFunction))
gi'funptrptr
Ptr Value
-> Maybe Value -> (Value -> IO (Ptr Value)) -> IO (Ptr Value)
forall (m :: * -> *) b a.
Monad m =>
b -> Maybe a -> (a -> m b) -> m b
maybeM Ptr Value
forall a. Ptr a
FP.nullPtr Maybe Value
result ((Value -> IO (Ptr Value)) -> IO (Ptr Value))
-> (Value -> IO (Ptr Value)) -> IO (Ptr Value)
forall a b. (a -> b) -> a -> b
$ \Value
result' -> do
Ptr Value
result'' <- Value -> IO (Ptr Value)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject Value
result'
Ptr Value -> IO (Ptr Value)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Value
result''
type C_ClassEnumeratePropertiesFunction =
Ptr JavaScriptCore.Class.Class ->
Ptr JavaScriptCore.Context.Context ->
Ptr () ->
IO (Ptr CString)
foreign import ccall "dynamic" __dynamic_C_ClassEnumeratePropertiesFunction :: FunPtr C_ClassEnumeratePropertiesFunction -> C_ClassEnumeratePropertiesFunction
dynamic_ClassEnumeratePropertiesFunction ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>
FunPtr C_ClassEnumeratePropertiesFunction
-> a
-> b
-> Ptr ()
-> m (Maybe [T.Text])
dynamic_ClassEnumeratePropertiesFunction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassEnumeratePropertiesFunction
-> a -> b -> Ptr () -> m (Maybe [Text])
dynamic_ClassEnumeratePropertiesFunction FunPtr C_ClassEnumeratePropertiesFunction
__funPtr a
jscClass b
context Ptr ()
instance_ = IO (Maybe [Text]) -> m (Maybe [Text])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [Text]) -> m (Maybe [Text]))
-> IO (Maybe [Text]) -> m (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ do
Ptr Class
jscClass' <- a -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jscClass
Ptr Context
context' <- b -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
Ptr CString
result <- (FunPtr C_ClassEnumeratePropertiesFunction
-> C_ClassEnumeratePropertiesFunction
__dynamic_C_ClassEnumeratePropertiesFunction FunPtr C_ClassEnumeratePropertiesFunction
__funPtr) Ptr Class
jscClass' Ptr Context
context' Ptr ()
instance_
Maybe [Text]
maybeResult <- Ptr CString -> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CString
result ((Ptr CString -> IO [Text]) -> IO (Maybe [Text]))
-> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ \Ptr CString
result' -> do
[Text]
result'' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result'
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result'
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
Maybe [Text] -> IO (Maybe [Text])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult
foreign import ccall "wrapper"
mk_ClassEnumeratePropertiesFunction :: C_ClassEnumeratePropertiesFunction -> IO (FunPtr C_ClassEnumeratePropertiesFunction)
type ClassEnumeratePropertiesFunction =
JavaScriptCore.Class.Class
-> JavaScriptCore.Context.Context
-> Ptr ()
-> IO (Maybe [T.Text])
noClassEnumeratePropertiesFunction :: Maybe ClassEnumeratePropertiesFunction
noClassEnumeratePropertiesFunction :: Maybe ClassEnumeratePropertiesFunction
noClassEnumeratePropertiesFunction = Maybe ClassEnumeratePropertiesFunction
forall a. Maybe a
Nothing
genClosure_ClassEnumeratePropertiesFunction :: MonadIO m => ClassEnumeratePropertiesFunction -> m (GClosure C_ClassEnumeratePropertiesFunction)
genClosure_ClassEnumeratePropertiesFunction :: forall (m :: * -> *).
MonadIO m =>
ClassEnumeratePropertiesFunction
-> m (GClosure C_ClassEnumeratePropertiesFunction)
genClosure_ClassEnumeratePropertiesFunction ClassEnumeratePropertiesFunction
cb = IO (GClosure C_ClassEnumeratePropertiesFunction)
-> m (GClosure C_ClassEnumeratePropertiesFunction)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ClassEnumeratePropertiesFunction)
-> m (GClosure C_ClassEnumeratePropertiesFunction))
-> IO (GClosure C_ClassEnumeratePropertiesFunction)
-> m (GClosure C_ClassEnumeratePropertiesFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ClassEnumeratePropertiesFunction
cb' = Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction))
-> ClassEnumeratePropertiesFunction
-> C_ClassEnumeratePropertiesFunction
wrap_ClassEnumeratePropertiesFunction Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction))
forall a. Maybe a
Nothing ClassEnumeratePropertiesFunction
cb
C_ClassEnumeratePropertiesFunction
-> IO (FunPtr C_ClassEnumeratePropertiesFunction)
mk_ClassEnumeratePropertiesFunction C_ClassEnumeratePropertiesFunction
cb' IO (FunPtr C_ClassEnumeratePropertiesFunction)
-> (FunPtr C_ClassEnumeratePropertiesFunction
-> IO (GClosure C_ClassEnumeratePropertiesFunction))
-> IO (GClosure C_ClassEnumeratePropertiesFunction)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClassEnumeratePropertiesFunction
-> IO (GClosure C_ClassEnumeratePropertiesFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ClassEnumeratePropertiesFunction ::
Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction)) ->
ClassEnumeratePropertiesFunction ->
C_ClassEnumeratePropertiesFunction
wrap_ClassEnumeratePropertiesFunction :: Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction))
-> ClassEnumeratePropertiesFunction
-> C_ClassEnumeratePropertiesFunction
wrap_ClassEnumeratePropertiesFunction Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction))
gi'funptrptr ClassEnumeratePropertiesFunction
gi'cb Ptr Class
jscClass Ptr Context
context Ptr ()
instance_ = do
Class
jscClass' <- ((ManagedPtr Class -> Class) -> Ptr Class -> IO Class
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Class -> Class
JavaScriptCore.Class.Class) Ptr Class
jscClass
Context
context' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Context -> Context
JavaScriptCore.Context.Context) Ptr Context
context
Maybe [Text]
result <- ClassEnumeratePropertiesFunction
gi'cb Class
jscClass' Context
context' Ptr ()
instance_
Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction))
gi'funptrptr
Ptr CString
-> Maybe [Text] -> ([Text] -> IO (Ptr CString)) -> IO (Ptr CString)
forall (m :: * -> *) b a.
Monad m =>
b -> Maybe a -> (a -> m b) -> m b
maybeM Ptr CString
forall a. Ptr a
FP.nullPtr Maybe [Text]
result (([Text] -> IO (Ptr CString)) -> IO (Ptr CString))
-> ([Text] -> IO (Ptr CString)) -> IO (Ptr CString)
forall a b. (a -> b) -> a -> b
$ \[Text]
result' -> do
Ptr CString
result'' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
result'
Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
result''
type C_ClassDeletePropertyFunction =
Ptr JavaScriptCore.Class.Class ->
Ptr JavaScriptCore.Context.Context ->
Ptr () ->
CString ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_ClassDeletePropertyFunction :: FunPtr C_ClassDeletePropertyFunction -> C_ClassDeletePropertyFunction
dynamic_ClassDeletePropertyFunction ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>
FunPtr C_ClassDeletePropertyFunction
-> a
-> b
-> Ptr ()
-> T.Text
-> m Bool
dynamic_ClassDeletePropertyFunction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClass a, IsContext b) =>
FunPtr C_ClassHasPropertyFunction
-> a -> b -> Ptr () -> Text -> m Bool
dynamic_ClassDeletePropertyFunction FunPtr C_ClassHasPropertyFunction
__funPtr a
jscClass b
context Ptr ()
instance_ Text
name = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Class
jscClass' <- a -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jscClass
Ptr Context
context' <- b -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- (FunPtr C_ClassHasPropertyFunction -> C_ClassHasPropertyFunction
__dynamic_C_ClassDeletePropertyFunction FunPtr C_ClassHasPropertyFunction
__funPtr) Ptr Class
jscClass' Ptr Context
context' Ptr ()
instance_ CString
name'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_ClassDeletePropertyFunction :: C_ClassDeletePropertyFunction -> IO (FunPtr C_ClassDeletePropertyFunction)
type ClassDeletePropertyFunction =
JavaScriptCore.Class.Class
-> JavaScriptCore.Context.Context
-> Ptr ()
-> T.Text
-> IO Bool
noClassDeletePropertyFunction :: Maybe ClassDeletePropertyFunction
noClassDeletePropertyFunction :: Maybe ClassHasPropertyFunction
noClassDeletePropertyFunction = Maybe ClassHasPropertyFunction
forall a. Maybe a
Nothing
genClosure_ClassDeletePropertyFunction :: MonadIO m => ClassDeletePropertyFunction -> m (GClosure C_ClassDeletePropertyFunction)
genClosure_ClassDeletePropertyFunction :: forall (m :: * -> *).
MonadIO m =>
ClassHasPropertyFunction -> m (GClosure C_ClassHasPropertyFunction)
genClosure_ClassDeletePropertyFunction ClassHasPropertyFunction
cb = IO (GClosure C_ClassHasPropertyFunction)
-> m (GClosure C_ClassHasPropertyFunction)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ClassHasPropertyFunction)
-> m (GClosure C_ClassHasPropertyFunction))
-> IO (GClosure C_ClassHasPropertyFunction)
-> m (GClosure C_ClassHasPropertyFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ClassHasPropertyFunction
cb' = Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
-> ClassHasPropertyFunction -> C_ClassHasPropertyFunction
wrap_ClassDeletePropertyFunction Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
forall a. Maybe a
Nothing ClassHasPropertyFunction
cb
C_ClassHasPropertyFunction
-> IO (FunPtr C_ClassHasPropertyFunction)
mk_ClassDeletePropertyFunction C_ClassHasPropertyFunction
cb' IO (FunPtr C_ClassHasPropertyFunction)
-> (FunPtr C_ClassHasPropertyFunction
-> IO (GClosure C_ClassHasPropertyFunction))
-> IO (GClosure C_ClassHasPropertyFunction)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClassHasPropertyFunction
-> IO (GClosure C_ClassHasPropertyFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ClassDeletePropertyFunction ::
Maybe (Ptr (FunPtr C_ClassDeletePropertyFunction)) ->
ClassDeletePropertyFunction ->
C_ClassDeletePropertyFunction
wrap_ClassDeletePropertyFunction :: Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
-> ClassHasPropertyFunction -> C_ClassHasPropertyFunction
wrap_ClassDeletePropertyFunction Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
gi'funptrptr ClassHasPropertyFunction
gi'cb Ptr Class
jscClass Ptr Context
context Ptr ()
instance_ CString
name = do
Class
jscClass' <- ((ManagedPtr Class -> Class) -> Ptr Class -> IO Class
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Class -> Class
JavaScriptCore.Class.Class) Ptr Class
jscClass
Context
context' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Context -> Context
JavaScriptCore.Context.Context) Ptr Context
context
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
Bool
result <- ClassHasPropertyFunction
gi'cb Class
jscClass' Context
context' Ptr ()
instance_ Text
name'
Maybe (Ptr (FunPtr C_ClassHasPropertyFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClassHasPropertyFunction))
gi'funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'