{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.JavaScriptCore.Objects.Value
(
Value(..) ,
IsValue ,
toValue ,
#if defined(ENABLE_OVERLOADING)
ResolveValueMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ValueConstructorCallMethodInfo ,
#endif
valueConstructorCall ,
#if defined(ENABLE_OVERLOADING)
ValueFunctionCallMethodInfo ,
#endif
valueFunctionCall ,
#if defined(ENABLE_OVERLOADING)
ValueGetContextMethodInfo ,
#endif
valueGetContext ,
#if defined(ENABLE_OVERLOADING)
ValueIsArrayMethodInfo ,
#endif
valueIsArray ,
#if defined(ENABLE_OVERLOADING)
ValueIsBooleanMethodInfo ,
#endif
valueIsBoolean ,
#if defined(ENABLE_OVERLOADING)
ValueIsConstructorMethodInfo ,
#endif
valueIsConstructor ,
#if defined(ENABLE_OVERLOADING)
ValueIsFunctionMethodInfo ,
#endif
valueIsFunction ,
#if defined(ENABLE_OVERLOADING)
ValueIsNullMethodInfo ,
#endif
valueIsNull ,
#if defined(ENABLE_OVERLOADING)
ValueIsNumberMethodInfo ,
#endif
valueIsNumber ,
#if defined(ENABLE_OVERLOADING)
ValueIsObjectMethodInfo ,
#endif
valueIsObject ,
#if defined(ENABLE_OVERLOADING)
ValueIsStringMethodInfo ,
#endif
valueIsString ,
#if defined(ENABLE_OVERLOADING)
ValueIsUndefinedMethodInfo ,
#endif
valueIsUndefined ,
valueNewArrayFromGarray ,
valueNewArrayFromStrv ,
valueNewBoolean ,
valueNewFromJson ,
valueNewFunction ,
valueNewFunctionVariadic ,
valueNewNull ,
valueNewNumber ,
valueNewObject ,
valueNewString ,
valueNewStringFromBytes ,
valueNewUndefined ,
#if defined(ENABLE_OVERLOADING)
ValueObjectDefinePropertyAccessorMethodInfo,
#endif
valueObjectDefinePropertyAccessor ,
#if defined(ENABLE_OVERLOADING)
ValueObjectDefinePropertyDataMethodInfo ,
#endif
valueObjectDefinePropertyData ,
#if defined(ENABLE_OVERLOADING)
ValueObjectDeletePropertyMethodInfo ,
#endif
valueObjectDeleteProperty ,
#if defined(ENABLE_OVERLOADING)
ValueObjectEnumeratePropertiesMethodInfo,
#endif
valueObjectEnumerateProperties ,
#if defined(ENABLE_OVERLOADING)
ValueObjectGetPropertyMethodInfo ,
#endif
valueObjectGetProperty ,
#if defined(ENABLE_OVERLOADING)
ValueObjectGetPropertyAtIndexMethodInfo ,
#endif
valueObjectGetPropertyAtIndex ,
#if defined(ENABLE_OVERLOADING)
ValueObjectHasPropertyMethodInfo ,
#endif
valueObjectHasProperty ,
#if defined(ENABLE_OVERLOADING)
ValueObjectInvokeMethodMethodInfo ,
#endif
valueObjectInvokeMethod ,
#if defined(ENABLE_OVERLOADING)
ValueObjectIsInstanceOfMethodInfo ,
#endif
valueObjectIsInstanceOf ,
#if defined(ENABLE_OVERLOADING)
ValueObjectSetPropertyMethodInfo ,
#endif
valueObjectSetProperty ,
#if defined(ENABLE_OVERLOADING)
ValueObjectSetPropertyAtIndexMethodInfo ,
#endif
valueObjectSetPropertyAtIndex ,
#if defined(ENABLE_OVERLOADING)
ValueToBooleanMethodInfo ,
#endif
valueToBoolean ,
#if defined(ENABLE_OVERLOADING)
ValueToDoubleMethodInfo ,
#endif
valueToDouble ,
#if defined(ENABLE_OVERLOADING)
ValueToInt32MethodInfo ,
#endif
valueToInt32 ,
#if defined(ENABLE_OVERLOADING)
ValueToJsonMethodInfo ,
#endif
valueToJson ,
#if defined(ENABLE_OVERLOADING)
ValueToStringMethodInfo ,
#endif
valueToString ,
#if defined(ENABLE_OVERLOADING)
ValueToStringAsBytesMethodInfo ,
#endif
valueToStringAsBytes ,
#if defined(ENABLE_OVERLOADING)
ValueContextPropertyInfo ,
#endif
constructValueContext ,
getValueContext ,
#if defined(ENABLE_OVERLOADING)
valueContext ,
#endif
) 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.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.JavaScriptCore.Flags as JavaScriptCore.Flags
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context
newtype Value = Value (SP.ManagedPtr Value)
deriving (Value -> Value -> Bool
(Value -> Value -> Bool) -> (Value -> Value -> Bool) -> Eq Value
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value -> Value -> Bool
$c/= :: Value -> Value -> Bool
== :: Value -> Value -> Bool
$c== :: Value -> Value -> Bool
Eq)
instance SP.ManagedPtrNewtype Value where
toManagedPtr :: Value -> ManagedPtr Value
toManagedPtr (Value ManagedPtr Value
p) = ManagedPtr Value
p
foreign import ccall "jsc_value_get_type"
c_jsc_value_get_type :: IO B.Types.GType
instance B.Types.TypedObject Value where
glibType :: IO GType
glibType = IO GType
c_jsc_value_get_type
instance B.Types.GObject Value
class (SP.GObject o, O.IsDescendantOf Value o) => IsValue o
instance (SP.GObject o, O.IsDescendantOf Value o) => IsValue o
instance O.HasParentTypes Value
type instance O.ParentTypes Value = '[GObject.Object.Object]
toValue :: (MIO.MonadIO m, IsValue o) => o -> m Value
toValue :: forall (m :: * -> *) o. (MonadIO m, IsValue o) => o -> m Value
toValue = IO Value -> m Value
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Value -> m Value) -> (o -> IO Value) -> o -> m Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Value -> Value) -> o -> IO Value
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Value -> Value
Value
instance B.GValue.IsGValue (Maybe Value) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_jsc_value_get_type
gvalueSet_ :: Ptr GValue -> Maybe Value -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Value
P.Nothing = Ptr GValue -> Ptr Value -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Value
forall a. Ptr a
FP.nullPtr :: FP.Ptr Value)
gvalueSet_ Ptr GValue
gv (P.Just Value
obj) = Value -> (Ptr Value -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Value
obj (Ptr GValue -> Ptr Value -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Value)
gvalueGet_ Ptr GValue
gv = do
Ptr Value
ptr <- Ptr GValue -> IO (Ptr Value)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Value)
if Ptr Value
ptr Ptr Value -> Ptr Value -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Value
forall a. Ptr a
FP.nullPtr
then Value -> Maybe Value
forall a. a -> Maybe a
P.Just (Value -> Maybe Value) -> IO Value -> IO (Maybe Value)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Value -> Value) -> Ptr Value -> IO Value
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Value -> Value
Value Ptr Value
ptr
else Maybe Value -> IO (Maybe Value)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Value
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveValueMethod (t :: Symbol) (o :: *) :: * where
ResolveValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveValueMethod "constructorCall" o = ValueConstructorCallMethodInfo
ResolveValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveValueMethod "functionCall" o = ValueFunctionCallMethodInfo
ResolveValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveValueMethod "isArray" o = ValueIsArrayMethodInfo
ResolveValueMethod "isBoolean" o = ValueIsBooleanMethodInfo
ResolveValueMethod "isConstructor" o = ValueIsConstructorMethodInfo
ResolveValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveValueMethod "isFunction" o = ValueIsFunctionMethodInfo
ResolveValueMethod "isNull" o = ValueIsNullMethodInfo
ResolveValueMethod "isNumber" o = ValueIsNumberMethodInfo
ResolveValueMethod "isObject" o = ValueIsObjectMethodInfo
ResolveValueMethod "isString" o = ValueIsStringMethodInfo
ResolveValueMethod "isUndefined" o = ValueIsUndefinedMethodInfo
ResolveValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveValueMethod "objectDefinePropertyAccessor" o = ValueObjectDefinePropertyAccessorMethodInfo
ResolveValueMethod "objectDefinePropertyData" o = ValueObjectDefinePropertyDataMethodInfo
ResolveValueMethod "objectDeleteProperty" o = ValueObjectDeletePropertyMethodInfo
ResolveValueMethod "objectEnumerateProperties" o = ValueObjectEnumeratePropertiesMethodInfo
ResolveValueMethod "objectGetProperty" o = ValueObjectGetPropertyMethodInfo
ResolveValueMethod "objectGetPropertyAtIndex" o = ValueObjectGetPropertyAtIndexMethodInfo
ResolveValueMethod "objectHasProperty" o = ValueObjectHasPropertyMethodInfo
ResolveValueMethod "objectInvokeMethod" o = ValueObjectInvokeMethodMethodInfo
ResolveValueMethod "objectIsInstanceOf" o = ValueObjectIsInstanceOfMethodInfo
ResolveValueMethod "objectSetProperty" o = ValueObjectSetPropertyMethodInfo
ResolveValueMethod "objectSetPropertyAtIndex" o = ValueObjectSetPropertyAtIndexMethodInfo
ResolveValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveValueMethod "toBoolean" o = ValueToBooleanMethodInfo
ResolveValueMethod "toDouble" o = ValueToDoubleMethodInfo
ResolveValueMethod "toInt32" o = ValueToInt32MethodInfo
ResolveValueMethod "toJson" o = ValueToJsonMethodInfo
ResolveValueMethod "toString" o = ValueToStringMethodInfo
ResolveValueMethod "toStringAsBytes" o = ValueToStringAsBytesMethodInfo
ResolveValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveValueMethod "getContext" o = ValueGetContextMethodInfo
ResolveValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveValueMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveValueMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveValueMethod t Value, O.OverloadedMethod info Value p) => OL.IsLabel t (Value -> 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 ~ ResolveValueMethod t Value, O.OverloadedMethod info Value p, R.HasField t Value p) => R.HasField t Value p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveValueMethod t Value, O.OverloadedMethodInfo info Value) => OL.IsLabel t (O.MethodProxy info Value) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getValueContext :: (MonadIO m, IsValue o) => o -> m JavaScriptCore.Context.Context
getValueContext :: forall (m :: * -> *) o. (MonadIO m, IsValue o) => o -> m Context
getValueContext o
obj = IO Context -> m Context
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Context -> m Context) -> IO Context -> m Context
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Context) -> IO Context
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getValueContext" (IO (Maybe Context) -> IO Context)
-> IO (Maybe Context) -> IO Context
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Context -> Context) -> IO (Maybe Context)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"context" ManagedPtr Context -> Context
JavaScriptCore.Context.Context
constructValueContext :: (IsValue o, MIO.MonadIO m, JavaScriptCore.Context.IsContext a) => a -> m (GValueConstruct o)
constructValueContext :: forall o (m :: * -> *) a.
(IsValue o, MonadIO m, IsContext a) =>
a -> m (GValueConstruct o)
constructValueContext 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 ValueContextPropertyInfo
instance AttrInfo ValueContextPropertyInfo where
type AttrAllowedOps ValueContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint ValueContextPropertyInfo = IsValue
type AttrSetTypeConstraint ValueContextPropertyInfo = JavaScriptCore.Context.IsContext
type AttrTransferTypeConstraint ValueContextPropertyInfo = JavaScriptCore.Context.IsContext
type AttrTransferType ValueContextPropertyInfo = JavaScriptCore.Context.Context
type AttrGetType ValueContextPropertyInfo = JavaScriptCore.Context.Context
type AttrLabel ValueContextPropertyInfo = "context"
type AttrOrigin ValueContextPropertyInfo = Value
attrGet = getValueContext
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo JavaScriptCore.Context.Context v
attrConstruct = constructValueContext
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Value
type instance O.AttributeList Value = ValueAttributeList
type ValueAttributeList = ('[ '("context", ValueContextPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
valueContext :: AttrLabelProxy "context"
valueContext = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Value = ValueSignalList
type ValueSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "jsc_value_new_array_from_garray" jsc_value_new_array_from_garray ::
Ptr JavaScriptCore.Context.Context ->
Ptr (GPtrArray (Ptr Value)) ->
IO (Ptr Value)
valueNewArrayFromGarray ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> Maybe ([Value])
-> m Value
valueNewArrayFromGarray :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Maybe [Value] -> m Value
valueNewArrayFromGarray a
context Maybe [Value]
array = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr (GPtrArray (Ptr Value))
maybeArray <- case Maybe [Value]
array of
Maybe [Value]
Nothing -> Ptr (GPtrArray (Ptr Value)) -> IO (Ptr (GPtrArray (Ptr Value)))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr Value))
forall a. Ptr a
nullPtr
Just [Value]
jArray -> do
[Ptr Value]
jArray' <- (Value -> IO (Ptr Value)) -> [Value] -> IO [Ptr Value]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [Value]
jArray
Ptr (GPtrArray (Ptr Value))
jArray'' <- [Ptr Value] -> IO (Ptr (GPtrArray (Ptr Value)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr Value]
jArray'
Ptr (GPtrArray (Ptr Value)) -> IO (Ptr (GPtrArray (Ptr Value)))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr Value))
jArray''
Ptr Value
result <- Ptr Context -> Ptr (GPtrArray (Ptr Value)) -> IO (Ptr Value)
jsc_value_new_array_from_garray Ptr Context
context' Ptr (GPtrArray (Ptr Value))
maybeArray
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewArrayFromGarray" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
Maybe [Value] -> ([Value] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [Value]
array ((Value -> IO ()) -> [Value] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Value -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
Ptr (GPtrArray (Ptr Value)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr Value))
maybeArray
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_array_from_strv" jsc_value_new_array_from_strv ::
Ptr JavaScriptCore.Context.Context ->
Ptr CString ->
IO (Ptr Value)
valueNewArrayFromStrv ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> [T.Text]
-> m Value
valueNewArrayFromStrv :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> [Text] -> m Value
valueNewArrayFromStrv a
context [Text]
strv = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr CString
strv' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
strv
Ptr Value
result <- Ptr Context -> Ptr CString -> IO (Ptr Value)
jsc_value_new_array_from_strv Ptr Context
context' Ptr CString
strv'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewArrayFromStrv" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
(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
strv'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
strv'
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_boolean" jsc_value_new_boolean ::
Ptr JavaScriptCore.Context.Context ->
CInt ->
IO (Ptr Value)
valueNewBoolean ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> Bool
-> m Value
valueNewBoolean :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Bool -> m Value
valueNewBoolean a
context Bool
value = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
let value' :: CInt
value' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
value
Ptr Value
result <- Ptr Context -> CInt -> IO (Ptr Value)
jsc_value_new_boolean Ptr Context
context' CInt
value'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewBoolean" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_from_json" jsc_value_new_from_json ::
Ptr JavaScriptCore.Context.Context ->
CString ->
IO (Ptr Value)
valueNewFromJson ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> T.Text
-> m Value
valueNewFromJson :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Text -> m Value
valueNewFromJson a
context Text
json = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
CString
json' <- Text -> IO CString
textToCString Text
json
Ptr Value
result <- Ptr Context -> CString -> IO (Ptr Value)
jsc_value_new_from_json Ptr Context
context' CString
json'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewFromJson" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
json'
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_function_variadic" jsc_value_new_function_variadic ::
Ptr JavaScriptCore.Context.Context ->
CString ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
CGType ->
IO (Ptr Value)
valueNewFunctionVariadic ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> Maybe (T.Text)
-> GObject.Callbacks.Callback
-> GType
-> m Value
valueNewFunctionVariadic :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Maybe Text -> IO () -> GType -> m Value
valueNewFunctionVariadic a
context 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
CString
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jName -> do
CString
jName' <- Text -> IO CString
textToCString Text
jName
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
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 Context
-> CString
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> CGType
-> IO (Ptr Value)
jsc_value_new_function_variadic Ptr Context
context' CString
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
"valueNewFunctionVariadic" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeName
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_functionv" jsc_value_new_functionv ::
Ptr JavaScriptCore.Context.Context ->
CString ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
CGType ->
Word32 ->
Ptr CGType ->
IO (Ptr Value)
valueNewFunction ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> Maybe (T.Text)
-> GObject.Callbacks.Callback
-> GType
-> Maybe ([GType])
-> m Value
valueNewFunction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Maybe Text -> IO () -> GType -> Maybe [GType] -> m Value
valueNewFunction a
context 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
CString
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jName -> do
CString
jName' <- Text -> IO CString
textToCString Text
jName
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
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 Context
-> CString
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> CGType
-> Word32
-> Ptr CGType
-> IO (Ptr Value)
jsc_value_new_functionv Ptr Context
context' CString
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
"valueNewFunction" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
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)
#endif
foreign import ccall "jsc_value_new_null" jsc_value_new_null ::
Ptr JavaScriptCore.Context.Context ->
IO (Ptr Value)
valueNewNull ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> m Value
valueNewNull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> m Value
valueNewNull a
context = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr Value
result <- Ptr Context -> IO (Ptr Value)
jsc_value_new_null Ptr Context
context'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewNull" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_number" jsc_value_new_number ::
Ptr JavaScriptCore.Context.Context ->
CDouble ->
IO (Ptr Value)
valueNewNumber ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> Double
-> m Value
valueNewNumber :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Double -> m Value
valueNewNumber a
context Double
number = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
let number' :: CDouble
number' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
number
Ptr Value
result <- Ptr Context -> CDouble -> IO (Ptr Value)
jsc_value_new_number Ptr Context
context' CDouble
number'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewNumber" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_object" jsc_value_new_object ::
Ptr JavaScriptCore.Context.Context ->
Ptr () ->
Ptr JavaScriptCore.Class.Class ->
IO (Ptr Value)
valueNewObject ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a, JavaScriptCore.Class.IsClass b) =>
a
-> Ptr ()
-> Maybe (b)
-> m Value
valueNewObject :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsContext a, IsClass b) =>
a -> Ptr () -> Maybe b -> m Value
valueNewObject a
context Ptr ()
instance_ Maybe b
jscClass = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr Class
maybeJscClass <- case Maybe b
jscClass of
Maybe b
Nothing -> Ptr Class -> IO (Ptr Class)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Class
forall a. Ptr a
nullPtr
Just b
jJscClass -> do
Ptr Class
jJscClass' <- b -> IO (Ptr Class)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jJscClass
Ptr Class -> IO (Ptr Class)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Class
jJscClass'
Ptr Value
result <- Ptr Context -> Ptr () -> Ptr Class -> IO (Ptr Value)
jsc_value_new_object Ptr Context
context' Ptr ()
instance_ Ptr Class
maybeJscClass
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewObject" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
jscClass b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_string" jsc_value_new_string ::
Ptr JavaScriptCore.Context.Context ->
CString ->
IO (Ptr Value)
valueNewString ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> Maybe (T.Text)
-> m Value
valueNewString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Maybe Text -> m Value
valueNewString a
context Maybe Text
string = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
CString
maybeString <- case Maybe Text
string of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jString -> do
CString
jString' <- Text -> IO CString
textToCString Text
jString
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jString'
Ptr Value
result <- Ptr Context -> CString -> IO (Ptr Value)
jsc_value_new_string Ptr Context
context' CString
maybeString
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewString" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeString
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_string_from_bytes" jsc_value_new_string_from_bytes ::
Ptr JavaScriptCore.Context.Context ->
Ptr GLib.Bytes.Bytes ->
IO (Ptr Value)
valueNewStringFromBytes ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> Maybe (GLib.Bytes.Bytes)
-> m Value
valueNewStringFromBytes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> Maybe Bytes -> m Value
valueNewStringFromBytes a
context Maybe Bytes
bytes = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr Bytes
maybeBytes <- case Maybe Bytes
bytes of
Maybe Bytes
Nothing -> Ptr Bytes -> IO (Ptr Bytes)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Bytes
forall a. Ptr a
nullPtr
Just Bytes
jBytes -> do
Ptr Bytes
jBytes' <- Bytes -> IO (Ptr Bytes)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
jBytes
Ptr Bytes -> IO (Ptr Bytes)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Bytes
jBytes'
Ptr Value
result <- Ptr Context -> Ptr Bytes -> IO (Ptr Value)
jsc_value_new_string_from_bytes Ptr Context
context' Ptr Bytes
maybeBytes
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewStringFromBytes" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
Maybe Bytes -> (Bytes -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Bytes
bytes Bytes -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_new_undefined" jsc_value_new_undefined ::
Ptr JavaScriptCore.Context.Context ->
IO (Ptr Value)
valueNewUndefined ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>
a
-> m Value
valueNewUndefined :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContext a) =>
a -> m Value
valueNewUndefined a
context = 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 Context
context' <- a -> IO (Ptr Context)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr Value
result <- Ptr Context -> IO (Ptr Value)
jsc_value_new_undefined Ptr Context
context'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueNewUndefined" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_value_constructor_callv" jsc_value_constructor_callv ::
Ptr Value ->
Word32 ->
Ptr (Ptr Value) ->
IO (Ptr Value)
valueConstructorCall ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> Maybe ([Value])
-> m Value
valueConstructorCall :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Maybe [Value] -> m Value
valueConstructorCall a
value Maybe [Value]
parameters = 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 [Value]
parameters of
Maybe [Value]
Nothing -> Word32
0
Just [Value]
jParameters -> Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Value] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Value]
jParameters
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr (Ptr Value)
maybeParameters <- case Maybe [Value]
parameters of
Maybe [Value]
Nothing -> Ptr (Ptr Value) -> IO (Ptr (Ptr Value))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr Value)
forall a. Ptr a
nullPtr
Just [Value]
jParameters -> do
[Ptr Value]
jParameters' <- (Value -> IO (Ptr Value)) -> [Value] -> IO [Ptr Value]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [Value]
jParameters
Ptr (Ptr Value)
jParameters'' <- [Ptr Value] -> IO (Ptr (Ptr Value))
forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr Value]
jParameters'
Ptr (Ptr Value) -> IO (Ptr (Ptr Value))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr Value)
jParameters''
Ptr Value
result <- Ptr Value -> Word32 -> Ptr (Ptr Value) -> IO (Ptr Value)
jsc_value_constructor_callv Ptr Value
value' Word32
nParameters Ptr (Ptr Value)
maybeParameters
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueConstructorCall" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Maybe [Value] -> ([Value] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [Value]
parameters ((Value -> IO ()) -> [Value] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Value -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
Ptr (Ptr Value) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Value)
maybeParameters
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data ValueConstructorCallMethodInfo
instance (signature ~ (Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.OverloadedMethod ValueConstructorCallMethodInfo a signature where
overloadedMethod = valueConstructorCall
instance O.OverloadedMethodInfo ValueConstructorCallMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueConstructorCall",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueConstructorCall"
}
#endif
foreign import ccall "jsc_value_function_callv" jsc_value_function_callv ::
Ptr Value ->
Word32 ->
Ptr (Ptr Value) ->
IO (Ptr Value)
valueFunctionCall ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> Maybe ([Value])
-> m Value
valueFunctionCall :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Maybe [Value] -> m Value
valueFunctionCall a
value Maybe [Value]
parameters = 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 [Value]
parameters of
Maybe [Value]
Nothing -> Word32
0
Just [Value]
jParameters -> Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Value] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Value]
jParameters
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr (Ptr Value)
maybeParameters <- case Maybe [Value]
parameters of
Maybe [Value]
Nothing -> Ptr (Ptr Value) -> IO (Ptr (Ptr Value))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr Value)
forall a. Ptr a
nullPtr
Just [Value]
jParameters -> do
[Ptr Value]
jParameters' <- (Value -> IO (Ptr Value)) -> [Value] -> IO [Ptr Value]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [Value]
jParameters
Ptr (Ptr Value)
jParameters'' <- [Ptr Value] -> IO (Ptr (Ptr Value))
forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr Value]
jParameters'
Ptr (Ptr Value) -> IO (Ptr (Ptr Value))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr Value)
jParameters''
Ptr Value
result <- Ptr Value -> Word32 -> Ptr (Ptr Value) -> IO (Ptr Value)
jsc_value_function_callv Ptr Value
value' Word32
nParameters Ptr (Ptr Value)
maybeParameters
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueFunctionCall" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Maybe [Value] -> ([Value] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [Value]
parameters ((Value -> IO ()) -> [Value] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Value -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
Ptr (Ptr Value) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Value)
maybeParameters
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data ValueFunctionCallMethodInfo
instance (signature ~ (Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.OverloadedMethod ValueFunctionCallMethodInfo a signature where
overloadedMethod = valueFunctionCall
instance O.OverloadedMethodInfo ValueFunctionCallMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueFunctionCall",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueFunctionCall"
}
#endif
foreign import ccall "jsc_value_get_context" jsc_value_get_context ::
Ptr Value ->
IO (Ptr JavaScriptCore.Context.Context)
valueGetContext ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m JavaScriptCore.Context.Context
valueGetContext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Context
valueGetContext a
value = IO Context -> m Context
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Context -> m Context) -> IO Context -> m Context
forall a b. (a -> b) -> a -> b
$ do
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr Context
result <- Ptr Value -> IO (Ptr Context)
jsc_value_get_context Ptr Value
value'
Text -> Ptr Context -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueGetContext" Ptr Context
result
Context
result' <- ((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
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Context -> IO Context
forall (m :: * -> *) a. Monad m => a -> m a
return Context
result'
#if defined(ENABLE_OVERLOADING)
data ValueGetContextMethodInfo
instance (signature ~ (m JavaScriptCore.Context.Context), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetContextMethodInfo a signature where
overloadedMethod = valueGetContext
instance O.OverloadedMethodInfo ValueGetContextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueGetContext",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueGetContext"
}
#endif
foreign import ccall "jsc_value_is_array" jsc_value_is_array ::
Ptr Value ->
IO CInt
valueIsArray ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsArray :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsArray a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_array 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsArrayMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsArrayMethodInfo a signature where
overloadedMethod = valueIsArray
instance O.OverloadedMethodInfo ValueIsArrayMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsArray",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsArray"
}
#endif
foreign import ccall "jsc_value_is_boolean" jsc_value_is_boolean ::
Ptr Value ->
IO CInt
valueIsBoolean ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsBoolean :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsBoolean a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_boolean 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsBooleanMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsBooleanMethodInfo a signature where
overloadedMethod = valueIsBoolean
instance O.OverloadedMethodInfo ValueIsBooleanMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsBoolean",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsBoolean"
}
#endif
foreign import ccall "jsc_value_is_constructor" jsc_value_is_constructor ::
Ptr Value ->
IO CInt
valueIsConstructor ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsConstructor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsConstructor a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_constructor 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsConstructorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsConstructorMethodInfo a signature where
overloadedMethod = valueIsConstructor
instance O.OverloadedMethodInfo ValueIsConstructorMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsConstructor",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsConstructor"
}
#endif
foreign import ccall "jsc_value_is_function" jsc_value_is_function ::
Ptr Value ->
IO CInt
valueIsFunction ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsFunction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsFunction a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_function 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsFunctionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsFunctionMethodInfo a signature where
overloadedMethod = valueIsFunction
instance O.OverloadedMethodInfo ValueIsFunctionMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsFunction",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsFunction"
}
#endif
foreign import ccall "jsc_value_is_null" jsc_value_is_null ::
Ptr Value ->
IO CInt
valueIsNull ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsNull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsNull a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_null 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsNullMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsNullMethodInfo a signature where
overloadedMethod = valueIsNull
instance O.OverloadedMethodInfo ValueIsNullMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsNull",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsNull"
}
#endif
foreign import ccall "jsc_value_is_number" jsc_value_is_number ::
Ptr Value ->
IO CInt
valueIsNumber ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsNumber :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsNumber a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_number 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsNumberMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsNumberMethodInfo a signature where
overloadedMethod = valueIsNumber
instance O.OverloadedMethodInfo ValueIsNumberMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsNumber",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsNumber"
}
#endif
foreign import ccall "jsc_value_is_object" jsc_value_is_object ::
Ptr Value ->
IO CInt
valueIsObject ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsObject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsObject a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_object 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsObjectMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsObjectMethodInfo a signature where
overloadedMethod = valueIsObject
instance O.OverloadedMethodInfo ValueIsObjectMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsObject",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsObject"
}
#endif
foreign import ccall "jsc_value_is_string" jsc_value_is_string ::
Ptr Value ->
IO CInt
valueIsString ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsString a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_string 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsStringMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsStringMethodInfo a signature where
overloadedMethod = valueIsString
instance O.OverloadedMethodInfo ValueIsStringMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsString",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsString"
}
#endif
foreign import ccall "jsc_value_is_undefined" jsc_value_is_undefined ::
Ptr Value ->
IO CInt
valueIsUndefined ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueIsUndefined :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueIsUndefined a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_is_undefined 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueIsUndefinedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueIsUndefinedMethodInfo a signature where
overloadedMethod = valueIsUndefined
instance O.OverloadedMethodInfo ValueIsUndefinedMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueIsUndefined",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueIsUndefined"
}
#endif
foreign import ccall "jsc_value_object_define_property_accessor" jsc_value_object_define_property_accessor ::
Ptr Value ->
CString ->
CUInt ->
CGType ->
FunPtr GObject.Callbacks.C_Callback ->
FunPtr GObject.Callbacks.C_Callback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
valueObjectDefinePropertyAccessor ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> T.Text
-> [JavaScriptCore.Flags.ValuePropertyFlags]
-> GType
-> Maybe (GObject.Callbacks.Callback)
-> Maybe (GObject.Callbacks.Callback)
-> m ()
valueObjectDefinePropertyAccessor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a
-> Text
-> [ValuePropertyFlags]
-> GType
-> Maybe (IO ())
-> Maybe (IO ())
-> m ()
valueObjectDefinePropertyAccessor a
value Text
propertyName [ValuePropertyFlags]
flags 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
let flags' :: CUInt
flags' = [ValuePropertyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ValuePropertyFlags]
flags
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 Value
-> CString
-> CUInt
-> CGType
-> FunPtr (IO ())
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
jsc_value_object_define_property_accessor Ptr Value
value' CString
propertyName' CUInt
flags' 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
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ValueObjectDefinePropertyAccessorMethodInfo
instance (signature ~ (T.Text -> [JavaScriptCore.Flags.ValuePropertyFlags] -> GType -> Maybe (GObject.Callbacks.Callback) -> Maybe (GObject.Callbacks.Callback) -> m ()), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectDefinePropertyAccessorMethodInfo a signature where
overloadedMethod = valueObjectDefinePropertyAccessor
instance O.OverloadedMethodInfo ValueObjectDefinePropertyAccessorMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyAccessor",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectDefinePropertyAccessor"
}
#endif
foreign import ccall "jsc_value_object_define_property_data" jsc_value_object_define_property_data ::
Ptr Value ->
CString ->
CUInt ->
Ptr Value ->
IO ()
valueObjectDefinePropertyData ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) =>
a
-> T.Text
-> [JavaScriptCore.Flags.ValuePropertyFlags]
-> Maybe (b)
-> m ()
valueObjectDefinePropertyData :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsValue a, IsValue b) =>
a -> Text -> [ValuePropertyFlags] -> Maybe b -> m ()
valueObjectDefinePropertyData a
value Text
propertyName [ValuePropertyFlags]
flags Maybe b
propertyValue = 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
let flags' :: CUInt
flags' = [ValuePropertyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ValuePropertyFlags]
flags
Ptr Value
maybePropertyValue <- case Maybe b
propertyValue of
Maybe b
Nothing -> Ptr Value -> IO (Ptr Value)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Value
forall a. Ptr a
nullPtr
Just b
jPropertyValue -> do
Ptr Value
jPropertyValue' <- b -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jPropertyValue
Ptr Value -> IO (Ptr Value)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Value
jPropertyValue'
Ptr Value -> CString -> CUInt -> Ptr Value -> IO ()
jsc_value_object_define_property_data Ptr Value
value' CString
propertyName' CUInt
flags' Ptr Value
maybePropertyValue
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
propertyValue b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ValueObjectDefinePropertyDataMethodInfo
instance (signature ~ (T.Text -> [JavaScriptCore.Flags.ValuePropertyFlags] -> Maybe (b) -> m ()), MonadIO m, IsValue a, IsValue b) => O.OverloadedMethod ValueObjectDefinePropertyDataMethodInfo a signature where
overloadedMethod = valueObjectDefinePropertyData
instance O.OverloadedMethodInfo ValueObjectDefinePropertyDataMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyData",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectDefinePropertyData"
}
#endif
foreign import ccall "jsc_value_object_delete_property" jsc_value_object_delete_property ::
Ptr Value ->
CString ->
IO CInt
valueObjectDeleteProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> T.Text
-> m Bool
valueObjectDeleteProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Text -> m Bool
valueObjectDeleteProperty a
value Text
name = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- Ptr Value -> CString -> IO CInt
jsc_value_object_delete_property Ptr Value
value' 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
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueObjectDeletePropertyMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectDeletePropertyMethodInfo a signature where
overloadedMethod = valueObjectDeleteProperty
instance O.OverloadedMethodInfo ValueObjectDeletePropertyMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectDeleteProperty",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectDeleteProperty"
}
#endif
foreign import ccall "jsc_value_object_enumerate_properties" jsc_value_object_enumerate_properties ::
Ptr Value ->
IO (Ptr CString)
valueObjectEnumerateProperties ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m (Maybe [T.Text])
valueObjectEnumerateProperties :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m (Maybe [Text])
valueObjectEnumerateProperties a
value = IO (Maybe [Text]) -> m (Maybe [Text])
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr CString
result <- Ptr Value -> IO (Ptr CString)
jsc_value_object_enumerate_properties Ptr Value
value'
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 (m :: * -> *) a. Monad m => a -> m a
return [Text]
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Maybe [Text] -> IO (Maybe [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult
#if defined(ENABLE_OVERLOADING)
data ValueObjectEnumeratePropertiesMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectEnumeratePropertiesMethodInfo a signature where
overloadedMethod = valueObjectEnumerateProperties
instance O.OverloadedMethodInfo ValueObjectEnumeratePropertiesMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectEnumerateProperties",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectEnumerateProperties"
}
#endif
foreign import ccall "jsc_value_object_get_property" jsc_value_object_get_property ::
Ptr Value ->
CString ->
IO (Ptr Value)
valueObjectGetProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> T.Text
-> m Value
valueObjectGetProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Text -> m Value
valueObjectGetProperty a
value Text
name = 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Value
result <- Ptr Value -> CString -> IO (Ptr Value)
jsc_value_object_get_property Ptr Value
value' CString
name'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueObjectGetProperty" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data ValueObjectGetPropertyMethodInfo
instance (signature ~ (T.Text -> m Value), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectGetPropertyMethodInfo a signature where
overloadedMethod = valueObjectGetProperty
instance O.OverloadedMethodInfo ValueObjectGetPropertyMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectGetProperty",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectGetProperty"
}
#endif
foreign import ccall "jsc_value_object_get_property_at_index" jsc_value_object_get_property_at_index ::
Ptr Value ->
Word32 ->
IO (Ptr Value)
valueObjectGetPropertyAtIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> Word32
-> m Value
valueObjectGetPropertyAtIndex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Word32 -> m Value
valueObjectGetPropertyAtIndex a
value Word32
index = 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr Value
result <- Ptr Value -> Word32 -> IO (Ptr Value)
jsc_value_object_get_property_at_index Ptr Value
value' Word32
index
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueObjectGetPropertyAtIndex" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data ValueObjectGetPropertyAtIndexMethodInfo
instance (signature ~ (Word32 -> m Value), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectGetPropertyAtIndexMethodInfo a signature where
overloadedMethod = valueObjectGetPropertyAtIndex
instance O.OverloadedMethodInfo ValueObjectGetPropertyAtIndexMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectGetPropertyAtIndex",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectGetPropertyAtIndex"
}
#endif
foreign import ccall "jsc_value_object_has_property" jsc_value_object_has_property ::
Ptr Value ->
CString ->
IO CInt
valueObjectHasProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> T.Text
-> m Bool
valueObjectHasProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Text -> m Bool
valueObjectHasProperty a
value Text
name = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- Ptr Value -> CString -> IO CInt
jsc_value_object_has_property Ptr Value
value' 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
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueObjectHasPropertyMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectHasPropertyMethodInfo a signature where
overloadedMethod = valueObjectHasProperty
instance O.OverloadedMethodInfo ValueObjectHasPropertyMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectHasProperty",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectHasProperty"
}
#endif
foreign import ccall "jsc_value_object_invoke_methodv" jsc_value_object_invoke_methodv ::
Ptr Value ->
CString ->
Word32 ->
Ptr (Ptr Value) ->
IO (Ptr Value)
valueObjectInvokeMethod ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> T.Text
-> Maybe ([Value])
-> m Value
valueObjectInvokeMethod :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Text -> Maybe [Value] -> m Value
valueObjectInvokeMethod a
value Text
name Maybe [Value]
parameters = 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 [Value]
parameters of
Maybe [Value]
Nothing -> Word32
0
Just [Value]
jParameters -> Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Value] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Value]
jParameters
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr (Ptr Value)
maybeParameters <- case Maybe [Value]
parameters of
Maybe [Value]
Nothing -> Ptr (Ptr Value) -> IO (Ptr (Ptr Value))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr Value)
forall a. Ptr a
nullPtr
Just [Value]
jParameters -> do
[Ptr Value]
jParameters' <- (Value -> IO (Ptr Value)) -> [Value] -> IO [Ptr Value]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [Value]
jParameters
Ptr (Ptr Value)
jParameters'' <- [Ptr Value] -> IO (Ptr (Ptr Value))
forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr Value]
jParameters'
Ptr (Ptr Value) -> IO (Ptr (Ptr Value))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr Value)
jParameters''
Ptr Value
result <- Ptr Value -> CString -> Word32 -> Ptr (Ptr Value) -> IO (Ptr Value)
jsc_value_object_invoke_methodv Ptr Value
value' CString
name' Word32
nParameters Ptr (Ptr Value)
maybeParameters
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueObjectInvokeMethod" 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
Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Maybe [Value] -> ([Value] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [Value]
parameters ((Value -> IO ()) -> [Value] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Value -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Ptr (Ptr Value) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Value)
maybeParameters
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data ValueObjectInvokeMethodMethodInfo
instance (signature ~ (T.Text -> Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectInvokeMethodMethodInfo a signature where
overloadedMethod = valueObjectInvokeMethod
instance O.OverloadedMethodInfo ValueObjectInvokeMethodMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectInvokeMethod",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectInvokeMethod"
}
#endif
foreign import ccall "jsc_value_object_is_instance_of" jsc_value_object_is_instance_of ::
Ptr Value ->
CString ->
IO CInt
valueObjectIsInstanceOf ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> T.Text
-> m Bool
valueObjectIsInstanceOf :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Text -> m Bool
valueObjectIsInstanceOf a
value Text
name = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- Ptr Value -> CString -> IO CInt
jsc_value_object_is_instance_of Ptr Value
value' 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
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueObjectIsInstanceOfMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueObjectIsInstanceOfMethodInfo a signature where
overloadedMethod = valueObjectIsInstanceOf
instance O.OverloadedMethodInfo ValueObjectIsInstanceOfMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectIsInstanceOf",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectIsInstanceOf"
}
#endif
foreign import ccall "jsc_value_object_set_property" jsc_value_object_set_property ::
Ptr Value ->
CString ->
Ptr Value ->
IO ()
valueObjectSetProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) =>
a
-> T.Text
-> b
-> m ()
valueObjectSetProperty :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsValue a, IsValue b) =>
a -> Text -> b -> m ()
valueObjectSetProperty a
value Text
name b
property = 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Value
property' <- b -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
property
Ptr Value -> CString -> Ptr Value -> IO ()
jsc_value_object_set_property Ptr Value
value' CString
name' Ptr Value
property'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
property
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ValueObjectSetPropertyMethodInfo
instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsValue a, IsValue b) => O.OverloadedMethod ValueObjectSetPropertyMethodInfo a signature where
overloadedMethod = valueObjectSetProperty
instance O.OverloadedMethodInfo ValueObjectSetPropertyMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectSetProperty",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectSetProperty"
}
#endif
foreign import ccall "jsc_value_object_set_property_at_index" jsc_value_object_set_property_at_index ::
Ptr Value ->
Word32 ->
Ptr Value ->
IO ()
valueObjectSetPropertyAtIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) =>
a
-> Word32
-> b
-> m ()
valueObjectSetPropertyAtIndex :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsValue a, IsValue b) =>
a -> Word32 -> b -> m ()
valueObjectSetPropertyAtIndex a
value Word32
index b
property = 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr Value
property' <- b -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
property
Ptr Value -> Word32 -> Ptr Value -> IO ()
jsc_value_object_set_property_at_index Ptr Value
value' Word32
index Ptr Value
property'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
property
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ValueObjectSetPropertyAtIndexMethodInfo
instance (signature ~ (Word32 -> b -> m ()), MonadIO m, IsValue a, IsValue b) => O.OverloadedMethod ValueObjectSetPropertyAtIndexMethodInfo a signature where
overloadedMethod = valueObjectSetPropertyAtIndex
instance O.OverloadedMethodInfo ValueObjectSetPropertyAtIndexMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueObjectSetPropertyAtIndex",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueObjectSetPropertyAtIndex"
}
#endif
foreign import ccall "jsc_value_to_boolean" jsc_value_to_boolean ::
Ptr Value ->
IO CInt
valueToBoolean ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Bool
valueToBoolean :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bool
valueToBoolean a
value = IO Bool -> m Bool
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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CInt
result <- Ptr Value -> IO CInt
jsc_value_to_boolean 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
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ValueToBooleanMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueToBooleanMethodInfo a signature where
overloadedMethod = valueToBoolean
instance O.OverloadedMethodInfo ValueToBooleanMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueToBoolean",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueToBoolean"
}
#endif
foreign import ccall "jsc_value_to_double" jsc_value_to_double ::
Ptr Value ->
IO CDouble
valueToDouble ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Double
valueToDouble :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Double
valueToDouble a
value = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CDouble
result <- Ptr Value -> IO CDouble
jsc_value_to_double Ptr Value
value'
let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'
#if defined(ENABLE_OVERLOADING)
data ValueToDoubleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsValue a) => O.OverloadedMethod ValueToDoubleMethodInfo a signature where
overloadedMethod = valueToDouble
instance O.OverloadedMethodInfo ValueToDoubleMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueToDouble",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueToDouble"
}
#endif
foreign import ccall "jsc_value_to_int32" jsc_value_to_int32 ::
Ptr Value ->
IO Int32
valueToInt32 ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m Int32
valueToInt32 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Int32
valueToInt32 a
value = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Int32
result <- Ptr Value -> IO Int32
jsc_value_to_int32 Ptr Value
value'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data ValueToInt32MethodInfo
instance (signature ~ (m Int32), MonadIO m, IsValue a) => O.OverloadedMethod ValueToInt32MethodInfo a signature where
overloadedMethod = valueToInt32
instance O.OverloadedMethodInfo ValueToInt32MethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueToInt32",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueToInt32"
}
#endif
foreign import ccall "jsc_value_to_json" jsc_value_to_json ::
Ptr Value ->
Word32 ->
IO CString
valueToJson ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> Word32
-> m T.Text
valueToJson :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> Word32 -> m Text
valueToJson a
value Word32
indent = 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
result <- Ptr Value -> Word32 -> IO CString
jsc_value_to_json Ptr Value
value' Word32
indent
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueToJson" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ValueToJsonMethodInfo
instance (signature ~ (Word32 -> m T.Text), MonadIO m, IsValue a) => O.OverloadedMethod ValueToJsonMethodInfo a signature where
overloadedMethod = valueToJson
instance O.OverloadedMethodInfo ValueToJsonMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueToJson",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueToJson"
}
#endif
foreign import ccall "jsc_value_to_string" jsc_value_to_string ::
Ptr Value ->
IO CString
valueToString ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m T.Text
valueToString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Text
valueToString a
value = 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 Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
CString
result <- Ptr Value -> IO CString
jsc_value_to_string Ptr Value
value'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ValueToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsValue a) => O.OverloadedMethod ValueToStringMethodInfo a signature where
overloadedMethod = valueToString
instance O.OverloadedMethodInfo ValueToStringMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueToString",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueToString"
}
#endif
foreign import ccall "jsc_value_to_string_as_bytes" jsc_value_to_string_as_bytes ::
Ptr Value ->
IO (Ptr GLib.Bytes.Bytes)
valueToStringAsBytes ::
(B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
a
-> m GLib.Bytes.Bytes
valueToStringAsBytes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m Bytes
valueToStringAsBytes a
value = IO Bytes -> m Bytes
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bytes -> m Bytes) -> IO Bytes -> m Bytes
forall a b. (a -> b) -> a -> b
$ do
Ptr Value
value' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
value
Ptr Bytes
result <- Ptr Value -> IO (Ptr Bytes)
jsc_value_to_string_as_bytes Ptr Value
value'
Text -> Ptr Bytes -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueToStringAsBytes" Ptr Bytes
result
Bytes
result' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
Bytes -> IO Bytes
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result'
#if defined(ENABLE_OVERLOADING)
data ValueToStringAsBytesMethodInfo
instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m, IsValue a) => O.OverloadedMethod ValueToStringAsBytesMethodInfo a signature where
overloadedMethod = valueToStringAsBytes
instance O.OverloadedMethodInfo ValueToStringAsBytesMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.JavaScriptCore.Objects.Value.valueToStringAsBytes",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.23/docs/GI-JavaScriptCore-Objects-Value.html#v:valueToStringAsBytes"
}
#endif