{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.JavaScriptCore.Objects.WeakValue
(
WeakValue(..) ,
IsWeakValue ,
toWeakValue ,
#if defined(ENABLE_OVERLOADING)
ResolveWeakValueMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
WeakValueGetValueMethodInfo ,
#endif
weakValueGetValue ,
weakValueNew ,
#if defined(ENABLE_OVERLOADING)
WeakValueValuePropertyInfo ,
#endif
constructWeakValueValue ,
#if defined(ENABLE_OVERLOADING)
weakValueValue ,
#endif
C_WeakValueClearedCallback ,
WeakValueClearedCallback ,
#if defined(ENABLE_OVERLOADING)
WeakValueClearedSignalInfo ,
#endif
afterWeakValueCleared ,
genClosure_WeakValueCleared ,
mk_WeakValueClearedCallback ,
noWeakValueClearedCallback ,
onWeakValueCleared ,
wrap_WeakValueClearedCallback ,
) 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.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value
newtype WeakValue = WeakValue (SP.ManagedPtr WeakValue)
deriving (WeakValue -> WeakValue -> Bool
(WeakValue -> WeakValue -> Bool)
-> (WeakValue -> WeakValue -> Bool) -> Eq WeakValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WeakValue -> WeakValue -> Bool
$c/= :: WeakValue -> WeakValue -> Bool
== :: WeakValue -> WeakValue -> Bool
$c== :: WeakValue -> WeakValue -> Bool
Eq)
instance SP.ManagedPtrNewtype WeakValue where
toManagedPtr :: WeakValue -> ManagedPtr WeakValue
toManagedPtr (WeakValue ManagedPtr WeakValue
p) = ManagedPtr WeakValue
p
foreign import ccall "jsc_weak_value_get_type"
c_jsc_weak_value_get_type :: IO B.Types.GType
instance B.Types.TypedObject WeakValue where
glibType :: IO GType
glibType = IO GType
c_jsc_weak_value_get_type
instance B.Types.GObject WeakValue
instance B.GValue.IsGValue WeakValue where
toGValue :: WeakValue -> IO GValue
toGValue WeakValue
o = do
GType
gtype <- IO GType
c_jsc_weak_value_get_type
WeakValue -> (Ptr WeakValue -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WeakValue
o (GType
-> (GValue -> Ptr WeakValue -> IO ()) -> Ptr WeakValue -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr WeakValue -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO WeakValue
fromGValue GValue
gv = do
Ptr WeakValue
ptr <- GValue -> IO (Ptr WeakValue)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr WeakValue)
(ManagedPtr WeakValue -> WeakValue)
-> Ptr WeakValue -> IO WeakValue
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr WeakValue -> WeakValue
WeakValue Ptr WeakValue
ptr
class (SP.GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o
instance (SP.GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o
instance O.HasParentTypes WeakValue
type instance O.ParentTypes WeakValue = '[GObject.Object.Object]
toWeakValue :: (MonadIO m, IsWeakValue o) => o -> m WeakValue
toWeakValue :: o -> m WeakValue
toWeakValue = IO WeakValue -> m WeakValue
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WeakValue -> m WeakValue)
-> (o -> IO WeakValue) -> o -> m WeakValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr WeakValue -> WeakValue) -> o -> IO WeakValue
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr WeakValue -> WeakValue
WeakValue
#if defined(ENABLE_OVERLOADING)
type family ResolveWeakValueMethod (t :: Symbol) (o :: *) :: * where
ResolveWeakValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveWeakValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveWeakValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveWeakValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveWeakValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveWeakValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveWeakValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveWeakValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveWeakValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveWeakValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveWeakValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveWeakValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveWeakValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveWeakValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveWeakValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveWeakValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveWeakValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveWeakValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveWeakValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveWeakValueMethod "getValue" o = WeakValueGetValueMethodInfo
ResolveWeakValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveWeakValueMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveWeakValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveWeakValueMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveWeakValueMethod t WeakValue, O.MethodInfo info WeakValue p) => OL.IsLabel t (WeakValue -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type WeakValueClearedCallback =
IO ()
noWeakValueClearedCallback :: Maybe WeakValueClearedCallback
noWeakValueClearedCallback :: Maybe (IO ())
noWeakValueClearedCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_WeakValueClearedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_WeakValueClearedCallback :: C_WeakValueClearedCallback -> IO (FunPtr C_WeakValueClearedCallback)
genClosure_WeakValueCleared :: MonadIO m => WeakValueClearedCallback -> m (GClosure C_WeakValueClearedCallback)
genClosure_WeakValueCleared :: IO () -> m (GClosure C_WeakValueClearedCallback)
genClosure_WeakValueCleared IO ()
cb = IO (GClosure C_WeakValueClearedCallback)
-> m (GClosure C_WeakValueClearedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WeakValueClearedCallback)
-> m (GClosure C_WeakValueClearedCallback))
-> IO (GClosure C_WeakValueClearedCallback)
-> m (GClosure C_WeakValueClearedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_WeakValueClearedCallback
cb' = IO () -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback IO ()
cb
C_WeakValueClearedCallback
-> IO (FunPtr C_WeakValueClearedCallback)
mk_WeakValueClearedCallback C_WeakValueClearedCallback
cb' IO (FunPtr C_WeakValueClearedCallback)
-> (FunPtr C_WeakValueClearedCallback
-> IO (GClosure C_WeakValueClearedCallback))
-> IO (GClosure C_WeakValueClearedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WeakValueClearedCallback
-> IO (GClosure C_WeakValueClearedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_WeakValueClearedCallback ::
WeakValueClearedCallback ->
C_WeakValueClearedCallback
wrap_WeakValueClearedCallback :: IO () -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> WeakValueClearedCallback -> m SignalHandlerId
onWeakValueCleared :: a -> IO () -> m SignalHandlerId
onWeakValueCleared a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_WeakValueClearedCallback
cb' = IO () -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback IO ()
cb
FunPtr C_WeakValueClearedCallback
cb'' <- C_WeakValueClearedCallback
-> IO (FunPtr C_WeakValueClearedCallback)
mk_WeakValueClearedCallback C_WeakValueClearedCallback
cb'
a
-> Text
-> FunPtr C_WeakValueClearedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cleared" FunPtr C_WeakValueClearedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> WeakValueClearedCallback -> m SignalHandlerId
afterWeakValueCleared :: a -> IO () -> m SignalHandlerId
afterWeakValueCleared a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_WeakValueClearedCallback
cb' = IO () -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback IO ()
cb
FunPtr C_WeakValueClearedCallback
cb'' <- C_WeakValueClearedCallback
-> IO (FunPtr C_WeakValueClearedCallback)
mk_WeakValueClearedCallback C_WeakValueClearedCallback
cb'
a
-> Text
-> FunPtr C_WeakValueClearedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cleared" FunPtr C_WeakValueClearedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data WeakValueClearedSignalInfo
instance SignalInfo WeakValueClearedSignalInfo where
type HaskellCallbackType WeakValueClearedSignalInfo = WeakValueClearedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_WeakValueClearedCallback cb
cb'' <- mk_WeakValueClearedCallback cb'
connectSignalFunPtr obj "cleared" cb'' connectMode detail
#endif
constructWeakValueValue :: (IsWeakValue o, MIO.MonadIO m, JavaScriptCore.Value.IsValue a) => a -> m (GValueConstruct o)
constructWeakValueValue :: a -> m (GValueConstruct o)
constructWeakValueValue 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
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"value" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data WeakValueValuePropertyInfo
instance AttrInfo WeakValueValuePropertyInfo where
type AttrAllowedOps WeakValueValuePropertyInfo = '[ 'AttrConstruct, 'AttrClear]
type AttrBaseTypeConstraint WeakValueValuePropertyInfo = IsWeakValue
type AttrSetTypeConstraint WeakValueValuePropertyInfo = JavaScriptCore.Value.IsValue
type AttrTransferTypeConstraint WeakValueValuePropertyInfo = JavaScriptCore.Value.IsValue
type AttrTransferType WeakValueValuePropertyInfo = JavaScriptCore.Value.Value
type AttrGetType WeakValueValuePropertyInfo = ()
type AttrLabel WeakValueValuePropertyInfo = "value"
type AttrOrigin WeakValueValuePropertyInfo = WeakValue
attrGet = undefined
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo JavaScriptCore.Value.Value v
attrConstruct = constructWeakValueValue
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WeakValue
type instance O.AttributeList WeakValue = WeakValueAttributeList
type WeakValueAttributeList = ('[ '("value", WeakValueValuePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
weakValueValue :: AttrLabelProxy "value"
weakValueValue = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList WeakValue = WeakValueSignalList
type WeakValueSignalList = ('[ '("cleared", WeakValueClearedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "jsc_weak_value_new" jsc_weak_value_new ::
Ptr JavaScriptCore.Value.Value ->
IO (Ptr WeakValue)
weakValueNew ::
(B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Value.IsValue a) =>
a
-> m WeakValue
weakValueNew :: a -> m WeakValue
weakValueNew a
value = IO WeakValue -> m WeakValue
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WeakValue -> m WeakValue) -> IO WeakValue -> m WeakValue
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 WeakValue
result <- Ptr Value -> IO (Ptr WeakValue)
jsc_weak_value_new Ptr Value
value'
Text -> Ptr WeakValue -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"weakValueNew" Ptr WeakValue
result
WeakValue
result' <- ((ManagedPtr WeakValue -> WeakValue)
-> Ptr WeakValue -> IO WeakValue
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr WeakValue -> WeakValue
WeakValue) Ptr WeakValue
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
value
WeakValue -> IO WeakValue
forall (m :: * -> *) a. Monad m => a -> m a
return WeakValue
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "jsc_weak_value_get_value" jsc_weak_value_get_value ::
Ptr WeakValue ->
IO (Ptr JavaScriptCore.Value.Value)
weakValueGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsWeakValue a) =>
a
-> m JavaScriptCore.Value.Value
weakValueGetValue :: a -> m Value
weakValueGetValue a
weakValue = 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 WeakValue
weakValue' <- a -> IO (Ptr WeakValue)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
weakValue
Ptr Value
result <- Ptr WeakValue -> IO (Ptr Value)
jsc_weak_value_get_value Ptr WeakValue
weakValue'
Text -> Ptr Value -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"weakValueGetValue" Ptr Value
result
Value
result' <- ((ManagedPtr Value -> Value) -> Ptr Value -> IO Value
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Value -> Value
JavaScriptCore.Value.Value) Ptr Value
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
weakValue
Value -> IO Value
forall (m :: * -> *) a. Monad m => a -> m a
return Value
result'
#if defined(ENABLE_OVERLOADING)
data WeakValueGetValueMethodInfo
instance (signature ~ (m JavaScriptCore.Value.Value), MonadIO m, IsWeakValue a) => O.MethodInfo WeakValueGetValueMethodInfo a signature where
overloadedMethod = weakValueGetValue
#endif