{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.JavaScriptCore.Objects.Class
(
Class(..) ,
IsClass ,
toClass ,
#if defined(ENABLE_OVERLOADING)
ResolveClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ClassAddConstructorMethodInfo ,
#endif
classAddConstructor ,
#if defined(ENABLE_OVERLOADING)
ClassAddConstructorVariadicMethodInfo ,
#endif
classAddConstructorVariadic ,
#if defined(ENABLE_OVERLOADING)
ClassAddMethodMethodInfo ,
#endif
classAddMethod ,
#if defined(ENABLE_OVERLOADING)
ClassAddMethodVariadicMethodInfo ,
#endif
classAddMethodVariadic ,
#if defined(ENABLE_OVERLOADING)
ClassAddPropertyMethodInfo ,
#endif
classAddProperty ,
#if defined(ENABLE_OVERLOADING)
ClassGetNameMethodInfo ,
#endif
classGetName ,
#if defined(ENABLE_OVERLOADING)
ClassGetParentMethodInfo ,
#endif
classGetParent ,
#if defined(ENABLE_OVERLOADING)
ClassContextPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
classContext ,
#endif
constructClassContext ,
#if defined(ENABLE_OVERLOADING)
ClassNamePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
className ,
#endif
constructClassName ,
getClassName ,
#if defined(ENABLE_OVERLOADING)
ClassParentPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
classParent ,
#endif
constructClassParent ,
getClassParent ,
) 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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value
newtype Class = Class (SP.ManagedPtr Class)
deriving (Class -> Class -> Bool
(Class -> Class -> Bool) -> (Class -> Class -> Bool) -> Eq Class
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Class -> Class -> Bool
$c/= :: Class -> Class -> Bool
== :: Class -> Class -> Bool
$c== :: Class -> Class -> Bool
Eq)
instance SP.ManagedPtrNewtype Class where
toManagedPtr :: Class -> ManagedPtr Class
toManagedPtr (Class ManagedPtr Class
p) = ManagedPtr Class
p
foreign import ccall "jsc_class_get_type"
c_jsc_class_get_type :: IO B.Types.GType
instance B.Types.TypedObject Class where
glibType :: IO GType
glibType = IO GType
c_jsc_class_get_type
instance B.Types.GObject Class
class (SP.GObject o, O.IsDescendantOf Class o) => IsClass o
instance (SP.GObject o, O.IsDescendantOf Class o) => IsClass o
instance O.HasParentTypes Class
type instance O.ParentTypes Class = '[GObject.Object.Object]
toClass :: (MIO.MonadIO m, IsClass o) => o -> m Class
toClass :: forall (m :: * -> *) o. (MonadIO m, IsClass o) => o -> m Class
toClass = IO Class -> m Class
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Class -> m Class) -> (o -> IO Class) -> o -> m Class
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Class -> Class) -> o -> IO Class
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Class -> Class
Class
instance B.GValue.IsGValue (Maybe Class) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_jsc_class_get_type
gvalueSet_ :: Ptr GValue -> Maybe Class -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Class
P.Nothing = Ptr GValue -> Ptr Class -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Class
forall a. Ptr a
FP.nullPtr :: FP.Ptr Class)
gvalueSet_ Ptr GValue
gv (P.Just Class
obj) = Class -> (Ptr Class -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Class
obj (Ptr GValue -> Ptr Class -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Class)
gvalueGet_ Ptr GValue
gv = do
Ptr Class
ptr <- Ptr GValue -> IO (Ptr Class)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Class)
if Ptr Class
ptr Ptr Class -> Ptr Class -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Class
forall a. Ptr a
FP.nullPtr
then Class -> Maybe Class
forall a. a -> Maybe a
P.Just (Class -> Maybe Class) -> IO Class -> IO (Maybe Class)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Class -> Class) -> Ptr Class -> IO Class
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Class -> Class
Class Ptr Class
ptr
else Maybe Class -> IO (Maybe Class)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Class
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveClassMethod (t :: Symbol) (o :: *) :: * where
ResolveClassMethod "addConstructor" o = ClassAddConstructorMethodInfo
ResolveClassMethod "addConstructorVariadic" o = ClassAddConstructorVariadicMethodInfo
ResolveClassMethod "addMethod" o = ClassAddMethodMethodInfo
ResolveClassMethod "addMethodVariadic" o = ClassAddMethodVariadicMethodInfo
ResolveClassMethod "addProperty" o = ClassAddPropertyMethodInfo
ResolveClassMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveClassMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveClassMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveClassMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveClassMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveClassMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveClassMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveClassMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveClassMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveClassMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveClassMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveClassMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveClassMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveClassMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveClassMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveClassMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveClassMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveClassMethod "getName" o = ClassGetNameMethodInfo
ResolveClassMethod "getParent" o = ClassGetParentMethodInfo
ResolveClassMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveClassMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveClassMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveClassMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveClassMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveClassMethod t Class, O.OverloadedMethod info Class p) => OL.IsLabel t (Class -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveClassMethod t Class, O.OverloadedMethod info Class p, R.HasField t Class p) => R.HasField t Class p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveClassMethod t Class, O.OverloadedMethodInfo info Class) => OL.IsLabel t (O.MethodProxy info Class) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
constructClassContext :: (IsClass o, MIO.MonadIO m, JavaScriptCore.Context.IsContext a) => a -> m (GValueConstruct o)
constructClassContext :: forall o (m :: * -> *) a.
(IsClass o, MonadIO m, IsContext a) =>
a -> m (GValueConstruct o)
constructClassContext a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"context" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data ClassContextPropertyInfo
instance AttrInfo ClassContextPropertyInfo where
type AttrAllowedOps ClassContextPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
type AttrBaseTypeConstraint ClassContextPropertyInfo = IsClass
type AttrSetTypeConstraint ClassContextPropertyInfo = JavaScriptCore.Context.IsContext
type AttrTransferTypeConstraint ClassContextPropertyInfo = JavaScriptCore.Context.IsContext
type AttrTransferType ClassContextPropertyInfo = JavaScriptCore.Context.Context
type AttrGetType ClassContextPropertyInfo = ()
type AttrLabel ClassContextPropertyInfo = "context"
type AttrOrigin ClassContextPropertyInfo = Class
attrGet = undefined
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo JavaScriptCore.Context.Context v
attrConstruct = constructClassContext
attrClear = undefined
#endif
getClassName :: (MonadIO m, IsClass o) => o -> m T.Text
getClassName :: forall (m :: * -> *) o. (MonadIO m, IsClass o) => o -> m Text
getClassName o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getClassName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"name"
constructClassName :: (IsClass o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructClassName :: forall o (m :: * -> *).
(IsClass o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructClassName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data ClassNamePropertyInfo
instance AttrInfo ClassNamePropertyInfo where
type AttrAllowedOps ClassNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ClassNamePropertyInfo = IsClass
type AttrSetTypeConstraint ClassNamePropertyInfo = (~) T.Text
type AttrTransferTypeConstraint ClassNamePropertyInfo = (~) T.Text
type AttrTransferType ClassNamePropertyInfo = T.Text
type AttrGetType ClassNamePropertyInfo = T.Text
type AttrLabel ClassNamePropertyInfo = "name"
type AttrOrigin ClassNamePropertyInfo = Class
attrGet = getClassName
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructClassName
attrClear = undefined
#endif
getClassParent :: (MonadIO m, IsClass o) => o -> m Class
getClassParent :: forall (m :: * -> *) o. (MonadIO m, IsClass o) => o -> m Class
getClassParent o
obj = IO Class -> m Class
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Class -> m Class) -> IO Class -> m Class
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Class) -> IO Class
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getClassParent" (IO (Maybe Class) -> IO Class) -> IO (Maybe Class) -> IO Class
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Class -> Class) -> IO (Maybe Class)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"parent" ManagedPtr Class -> Class
Class
constructClassParent :: (IsClass o, MIO.MonadIO m, IsClass a) => a -> m (GValueConstruct o)
constructClassParent :: forall o (m :: * -> *) a.
(IsClass o, MonadIO m, IsClass a) =>
a -> m (GValueConstruct o)
constructClassParent a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"parent" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data ClassParentPropertyInfo
instance AttrInfo ClassParentPropertyInfo where
type AttrAllowedOps ClassParentPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ClassParentPropertyInfo = IsClass
type AttrSetTypeConstraint ClassParentPropertyInfo = IsClass
type AttrTransferTypeConstraint ClassParentPropertyInfo = IsClass
type AttrTransferType ClassParentPropertyInfo = Class
type AttrGetType ClassParentPropertyInfo = Class
type AttrLabel ClassParentPropertyInfo = "parent"
type AttrOrigin ClassParentPropertyInfo = Class
attrGet = getClassParent
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Class v
attrConstruct = constructClassParent
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Class
type instance O.AttributeList Class = ClassAttributeList
type ClassAttributeList = ('[ '("context", ClassContextPropertyInfo), '("name", ClassNamePropertyInfo), '("parent", ClassParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
classContext :: AttrLabelProxy "context"
classContext = AttrLabelProxy
className :: AttrLabelProxy "name"
className = AttrLabelProxy
classParent :: AttrLabelProxy "parent"
classParent = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Class = ClassSignalList
type ClassSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "jsc_class_add_constructor_variadic" jsc_class_add_constructor_variadic ::
Ptr Class ->
CString ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
CGType ->
IO (Ptr JavaScriptCore.Value.Value)
classAddConstructorVariadic ::
(B.CallStack.HasCallStack, MonadIO m, IsClass a) =>
a
-> Maybe (T.Text)
-> GObject.Callbacks.Callback
-> GType
-> m JavaScriptCore.Value.Value
classAddConstructorVariadic :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClass a) =>
a -> Maybe Text -> IO () -> GType -> m Value
classAddConstructorVariadic a
jscClass Maybe Text
name IO ()
callback GType
returnType = IO Value -> m Value
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Value -> m Value) -> IO Value -> m 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 CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
FunPtr (IO ())
callback' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback Maybe (Ptr (FunPtr (IO ())))
forall a. Maybe a
Nothing IO ()
callback)
let returnType' :: CGType
returnType' = GType -> CGType
gtypeToCGType GType
returnType
let userData :: Ptr ()
userData = FunPtr (IO ()) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (IO ())
callback'
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Value
result <- Ptr Class
-> Ptr CChar
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> CGType
-> IO (Ptr Value)
jsc_class_add_constructor_variadic Ptr Class
jscClass' Ptr CChar
maybeName FunPtr (IO ())
callback' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify CGType
returnType'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"classAddConstructorVariadic" Ptr Value
result
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
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data ClassAddConstructorVariadicMethodInfo
instance (signature ~ (Maybe (T.Text) -> GObject.Callbacks.Callback -> GType -> m JavaScriptCore.Value.Value), MonadIO m, IsClass a) => O.OverloadedMethod ClassAddConstructorVariadicMethodInfo a signature where
overloadedMethod = classAddConstructorVariadic
instance O.OverloadedMethodInfo ClassAddConstructorVariadicMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Class.classAddConstructorVariadic",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Class.html#v:classAddConstructorVariadic"
}
#endif
foreign import ccall "jsc_class_add_constructorv" jsc_class_add_constructorv ::
Ptr Class ->
CString ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
CGType ->
Word32 ->
Ptr CGType ->
IO (Ptr JavaScriptCore.Value.Value)
classAddConstructor ::
(B.CallStack.HasCallStack, MonadIO m, IsClass a) =>
a
-> Maybe (T.Text)
-> GObject.Callbacks.Callback
-> GType
-> Maybe ([GType])
-> m JavaScriptCore.Value.Value
classAddConstructor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClass a) =>
a -> Maybe Text -> IO () -> GType -> Maybe [GType] -> m Value
classAddConstructor a
jscClass Maybe Text
name IO ()
callback GType
returnType Maybe [GType]
parameterTypes = IO Value -> m Value
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Value -> m Value) -> IO Value -> m Value
forall a b. (a -> b) -> a -> b
$ do
let nParameters :: Word32
nParameters = case Maybe [GType]
parameterTypes of
Maybe [GType]
Nothing -> Word32
0
Just [GType]
jParameterTypes -> Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [GType] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GType]
jParameterTypes
Ptr Class
jscClass' <- a -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jscClass
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
FunPtr (IO ())
callback' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback Maybe (Ptr (FunPtr (IO ())))
forall a. Maybe a
Nothing IO ()
callback)
let returnType' :: CGType
returnType' = GType -> CGType
gtypeToCGType GType
returnType
Ptr CGType
maybeParameterTypes <- case Maybe [GType]
parameterTypes of
Maybe [GType]
Nothing -> Ptr CGType -> IO (Ptr CGType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CGType
forall a. Ptr a
nullPtr
Just [GType]
jParameterTypes -> do
Ptr CGType
jParameterTypes' <- ((GType -> CGType) -> [GType] -> IO (Ptr CGType)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray GType -> CGType
gtypeToCGType) [GType]
jParameterTypes
Ptr CGType -> IO (Ptr CGType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CGType
jParameterTypes'
let userData :: Ptr ()
userData = FunPtr (IO ()) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (IO ())
callback'
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Value
result <- Ptr Class
-> Ptr CChar
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> CGType
-> Word32
-> Ptr CGType
-> IO (Ptr Value)
jsc_class_add_constructorv Ptr Class
jscClass' Ptr CChar
maybeName FunPtr (IO ())
callback' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify CGType
returnType' Word32
nParameters Ptr CGType
maybeParameterTypes
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"classAddConstructor" Ptr Value
result
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
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Ptr CGType -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CGType
maybeParameterTypes
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data ClassAddConstructorMethodInfo
instance (signature ~ (Maybe (T.Text) -> GObject.Callbacks.Callback -> GType -> Maybe ([GType]) -> m JavaScriptCore.Value.Value), MonadIO m, IsClass a) => O.OverloadedMethod ClassAddConstructorMethodInfo a signature where
overloadedMethod = classAddConstructor
instance O.OverloadedMethodInfo ClassAddConstructorMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Class.classAddConstructor",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Class.html#v:classAddConstructor"
}
#endif
foreign import ccall "jsc_class_add_method_variadic" jsc_class_add_method_variadic ::
Ptr Class ->
CString ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
CGType ->
IO ()
classAddMethodVariadic ::
(B.CallStack.HasCallStack, MonadIO m, IsClass a) =>
a
-> T.Text
-> GObject.Callbacks.Callback
-> GType
-> m ()
classAddMethodVariadic :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClass a) =>
a -> Text -> IO () -> GType -> m ()
classAddMethodVariadic a
jscClass Text
name IO ()
callback GType
returnType = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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 CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
FunPtr (IO ())
callback' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback Maybe (Ptr (FunPtr (IO ())))
forall a. Maybe a
Nothing IO ()
callback)
let returnType' :: CGType
returnType' = GType -> CGType
gtypeToCGType GType
returnType
let userData :: Ptr ()
userData = FunPtr (IO ()) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (IO ())
callback'
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Class
-> Ptr CChar
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> CGType
-> IO ()
jsc_class_add_method_variadic Ptr Class
jscClass' Ptr CChar
name' FunPtr (IO ())
callback' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify CGType
returnType'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ClassAddMethodVariadicMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> GType -> m ()), MonadIO m, IsClass a) => O.OverloadedMethod ClassAddMethodVariadicMethodInfo a signature where
overloadedMethod = classAddMethodVariadic
instance O.OverloadedMethodInfo ClassAddMethodVariadicMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Class.classAddMethodVariadic",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Class.html#v:classAddMethodVariadic"
}
#endif
foreign import ccall "jsc_class_add_methodv" jsc_class_add_methodv ::
Ptr Class ->
CString ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
CGType ->
Word32 ->
Ptr CGType ->
IO ()
classAddMethod ::
(B.CallStack.HasCallStack, MonadIO m, IsClass a) =>
a
-> T.Text
-> GObject.Callbacks.Callback
-> GType
-> Maybe ([GType])
-> m ()
classAddMethod :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClass a) =>
a -> Text -> IO () -> GType -> Maybe [GType] -> m ()
classAddMethod a
jscClass Text
name IO ()
callback GType
returnType Maybe [GType]
parameterTypes = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let nParameters :: Word32
nParameters = case Maybe [GType]
parameterTypes of
Maybe [GType]
Nothing -> Word32
0
Just [GType]
jParameterTypes -> Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [GType] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GType]
jParameterTypes
Ptr Class
jscClass' <- a -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jscClass
Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
FunPtr (IO ())
callback' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback Maybe (Ptr (FunPtr (IO ())))
forall a. Maybe a
Nothing IO ()
callback)
let returnType' :: CGType
returnType' = GType -> CGType
gtypeToCGType GType
returnType
Ptr CGType
maybeParameterTypes <- case Maybe [GType]
parameterTypes of
Maybe [GType]
Nothing -> Ptr CGType -> IO (Ptr CGType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CGType
forall a. Ptr a
nullPtr
Just [GType]
jParameterTypes -> do
Ptr CGType
jParameterTypes' <- ((GType -> CGType) -> [GType] -> IO (Ptr CGType)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray GType -> CGType
gtypeToCGType) [GType]
jParameterTypes
Ptr CGType -> IO (Ptr CGType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CGType
jParameterTypes'
let userData :: Ptr ()
userData = FunPtr (IO ()) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (IO ())
callback'
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Class
-> Ptr CChar
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> CGType
-> Word32
-> Ptr CGType
-> IO ()
jsc_class_add_methodv Ptr Class
jscClass' Ptr CChar
name' FunPtr (IO ())
callback' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify CGType
returnType' Word32
nParameters Ptr CGType
maybeParameterTypes
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
Ptr CGType -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CGType
maybeParameterTypes
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ClassAddMethodMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> GType -> Maybe ([GType]) -> m ()), MonadIO m, IsClass a) => O.OverloadedMethod ClassAddMethodMethodInfo a signature where
overloadedMethod = classAddMethod
instance O.OverloadedMethodInfo ClassAddMethodMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Class.classAddMethod",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Class.html#v:classAddMethod"
}
#endif
foreign import ccall "jsc_class_add_property" jsc_class_add_property ::
Ptr Class ->
CString ->
CGType ->
FunPtr GObject.Callbacks.C_Callback ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
classAddProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsClass a) =>
a
-> T.Text
-> GType
-> Maybe (GObject.Callbacks.Callback)
-> Maybe (GObject.Callbacks.Callback)
-> m ()
classAddProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClass a) =>
a -> Text -> GType -> Maybe (IO ()) -> Maybe (IO ()) -> m ()
classAddProperty a
jscClass Text
name GType
propertyType Maybe (IO ())
getter Maybe (IO ())
setter = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
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 CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
let propertyType' :: CGType
propertyType' = GType -> CGType
gtypeToCGType GType
propertyType
FunPtr (IO ())
maybeGetter <- case Maybe (IO ())
getter of
Maybe (IO ())
Nothing -> FunPtr (IO ()) -> IO (FunPtr (IO ()))
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr (IO ())
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just IO ()
jGetter -> do
Ptr (FunPtr (IO ()))
ptrgetter <- IO (Ptr (FunPtr (IO ())))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
FunPtr (IO ())
jGetter' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback (Ptr (FunPtr (IO ())) -> Maybe (Ptr (FunPtr (IO ())))
forall a. a -> Maybe a
Just Ptr (FunPtr (IO ()))
ptrgetter) IO ()
jGetter)
Ptr (FunPtr (IO ())) -> FunPtr (IO ()) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr (IO ()))
ptrgetter FunPtr (IO ())
jGetter'
FunPtr (IO ()) -> IO (FunPtr (IO ()))
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr (IO ())
jGetter'
FunPtr (IO ())
maybeSetter <- case Maybe (IO ())
setter of
Maybe (IO ())
Nothing -> FunPtr (IO ()) -> IO (FunPtr (IO ()))
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr (IO ())
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just IO ()
jSetter -> do
FunPtr (IO ())
jSetter' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback Maybe (Ptr (FunPtr (IO ())))
forall a. Maybe a
Nothing IO ()
jSetter)
FunPtr (IO ()) -> IO (FunPtr (IO ()))
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr (IO ())
jSetter'
let userData :: Ptr ()
userData = FunPtr (IO ()) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (IO ())
maybeSetter
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Class
-> Ptr CChar
-> CGType
-> FunPtr (IO ())
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
jsc_class_add_property Ptr Class
jscClass' Ptr CChar
name' CGType
propertyType' FunPtr (IO ())
maybeGetter FunPtr (IO ())
maybeSetter Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ClassAddPropertyMethodInfo
instance (signature ~ (T.Text -> GType -> Maybe (GObject.Callbacks.Callback) -> Maybe (GObject.Callbacks.Callback) -> m ()), MonadIO m, IsClass a) => O.OverloadedMethod ClassAddPropertyMethodInfo a signature where
overloadedMethod = classAddProperty
instance O.OverloadedMethodInfo ClassAddPropertyMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Class.classAddProperty",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Class.html#v:classAddProperty"
}
#endif
foreign import ccall "jsc_class_get_name" jsc_class_get_name ::
Ptr Class ->
IO CString
classGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsClass a) =>
a
-> m T.Text
classGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClass a) =>
a -> m Text
classGetName a
jscClass = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m 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 CChar
result <- Ptr Class -> IO (Ptr CChar)
jsc_class_get_name Ptr Class
jscClass'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"classGetName" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ClassGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsClass a) => O.OverloadedMethod ClassGetNameMethodInfo a signature where
overloadedMethod = classGetName
instance O.OverloadedMethodInfo ClassGetNameMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Class.classGetName",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Class.html#v:classGetName"
}
#endif
foreign import ccall "jsc_class_get_parent" jsc_class_get_parent ::
Ptr Class ->
IO (Ptr Class)
classGetParent ::
(B.CallStack.HasCallStack, MonadIO m, IsClass a) =>
a
-> m Class
classGetParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClass a) =>
a -> m Class
classGetParent a
jscClass = IO Class -> m Class
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Class -> m Class) -> IO Class -> m Class
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 Class
result <- Ptr Class -> IO (Ptr Class)
jsc_class_get_parent Ptr Class
jscClass'
Text -> Ptr Class -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"classGetParent" Ptr Class
result
Class
result' <- ((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
Class) Ptr Class
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
jscClass
Class -> IO Class
forall (m :: * -> *) a. Monad m => a -> m a
return Class
result'
#if defined(ENABLE_OVERLOADING)
data ClassGetParentMethodInfo
instance (signature ~ (m Class), MonadIO m, IsClass a) => O.OverloadedMethod ClassGetParentMethodInfo a signature where
overloadedMethod = classGetParent
instance O.OverloadedMethodInfo ClassGetParentMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Class.classGetParent",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Class.html#v:classGetParent"
}
#endif