{-# 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 ,
noWeakValue ,
#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value
newtype WeakValue = WeakValue (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)
foreign import ccall "jsc_weak_value_get_type"
c_jsc_weak_value_get_type :: IO GType
instance GObject WeakValue where
gobjectType :: IO GType
gobjectType = IO GType
c_jsc_weak_value_get_type
instance B.GValue.IsGValue WeakValue where
toGValue :: WeakValue -> IO GValue
toGValue o :: 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 gv :: 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 (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o
instance (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, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr WeakValue -> WeakValue
WeakValue
noWeakValue :: Maybe WeakValue
noWeakValue :: Maybe WeakValue
noWeakValue = Maybe WeakValue
forall a. Maybe a
Nothing
#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 cb :: 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 _cb :: IO ()
_cb _ _ = do
IO ()
_cb
onWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> WeakValueClearedCallback -> m SignalHandlerId
onWeakValueCleared :: a -> IO () -> m SignalHandlerId
onWeakValueCleared obj :: a
obj cb :: 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 "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 obj :: a
obj cb :: 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 "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, JavaScriptCore.Value.IsValue a) => a -> IO (GValueConstruct o)
constructWeakValueValue :: a -> IO (GValueConstruct o)
constructWeakValueValue val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "value" (a -> Maybe a
forall a. a -> Maybe a
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 value :: 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 "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 weakValue :: 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 "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