{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.JavaScriptCore.Objects.WeakValue
    ( 

-- * Exported types
    WeakValue(..)                           ,
    IsWeakValue                             ,
    toWeakValue                             ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveWeakValueMethod                  ,
#endif


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    WeakValueGetValueMethodInfo             ,
#endif
    weakValueGetValue                       ,


-- ** new #method:new#

    weakValueNew                            ,




 -- * Properties
-- ** value #attr:value#
-- | The t'GI.JavaScriptCore.Objects.Value.Value' referencing the JavaScript value.

#if defined(ENABLE_OVERLOADING)
    WeakValueValuePropertyInfo              ,
#endif
    constructWeakValueValue                 ,
#if defined(ENABLE_OVERLOADING)
    weakValueValue                          ,
#endif




 -- * Signals
-- ** cleared #signal:cleared#

    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

-- | Memory-managed wrapper type.
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

-- | Convert 'WeakValue' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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
        
    

-- | Type class for types which can be safely cast to `WeakValue`, for instance with `toWeakValue`.
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]

-- | Cast to `WeakValue`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- signal WeakValue::cleared
-- | This signal is emitted when the JavaScript value is destroyed.
type WeakValueClearedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WeakValueClearedCallback`@.
noWeakValueClearedCallback :: Maybe WeakValueClearedCallback
noWeakValueClearedCallback :: Maybe (IO ())
noWeakValueClearedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WeakValueClearedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_WeakValueClearedCallback`.
foreign import ccall "wrapper"
    mk_WeakValueClearedCallback :: C_WeakValueClearedCallback -> IO (FunPtr C_WeakValueClearedCallback)

-- | Wrap the callback into a `GClosure`.
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 a `WeakValueClearedCallback` into a `C_WeakValueClearedCallback`.
wrap_WeakValueClearedCallback ::
    WeakValueClearedCallback ->
    C_WeakValueClearedCallback
wrap_WeakValueClearedCallback :: IO () -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [cleared](#signal:cleared) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' weakValue #cleared callback
-- @
-- 
-- 
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

-- | Connect a signal handler for the [cleared](#signal:cleared) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' weakValue #cleared callback
-- @
-- 
-- 
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

-- VVV Prop "value"
   -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Value"})
   -- Flags: [PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Construct a `GValueConstruct` with valid value for the “@value@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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

-- method WeakValue::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType =
--               TInterface Name { namespace = "JavaScriptCore" , name = "Value" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #JSCValue" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "JavaScriptCore" , name = "WeakValue" })
-- throws : False
-- Skip return : False

foreign import ccall "jsc_weak_value_new" jsc_weak_value_new :: 
    Ptr JavaScriptCore.Value.Value ->       -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})
    IO (Ptr WeakValue)

-- | Create a new t'GI.JavaScriptCore.Objects.WeakValue.WeakValue' for the JavaScript value referenced by /@value@/.
weakValueNew ::
    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Value.IsValue a) =>
    a
    -- ^ /@value@/: a t'GI.JavaScriptCore.Objects.Value.Value'
    -> m WeakValue
    -- ^ __Returns:__ a new t'GI.JavaScriptCore.Objects.WeakValue.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

-- method WeakValue::get_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "weak_value"
--           , argType =
--               TInterface
--                 Name { namespace = "JavaScriptCore" , name = "WeakValue" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #JSCWeakValue" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "JavaScriptCore" , name = "Value" })
-- throws : False
-- Skip return : False

foreign import ccall "jsc_weak_value_get_value" jsc_weak_value_get_value :: 
    Ptr WeakValue ->                        -- weak_value : TInterface (Name {namespace = "JavaScriptCore", name = "WeakValue"})
    IO (Ptr JavaScriptCore.Value.Value)

-- | Get a t'GI.JavaScriptCore.Objects.Value.Value' referencing the JavaScript value of /@weakValue@/.
weakValueGetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsWeakValue a) =>
    a
    -- ^ /@weakValue@/: a t'GI.JavaScriptCore.Objects.WeakValue.WeakValue'
    -> m JavaScriptCore.Value.Value
    -- ^ __Returns:__ a new t'GI.JavaScriptCore.Objects.Value.Value' or 'P.Nothing' if /@weakValue@/ was cleared.
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