{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- JSCWeakValue represents a weak reference to a value in a t'GI.JavaScriptCore.Objects.Context.Context'. It can be used
-- to keep a reference to a JavaScript value without protecting it from being garbage
-- collected and without referencing the t'GI.JavaScriptCore.Objects.Context.Context' either.

#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
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getValue]("GI.JavaScriptCore.Objects.WeakValue#g:method:getValue").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#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#

    WeakValueClearedCallback                ,
#if defined(ENABLE_OVERLOADING)
    WeakValueClearedSignalInfo              ,
#endif
    afterWeakValueCleared                   ,
    onWeakValueCleared                      ,




    ) 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.GHashTable as B.GHT
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.Coerce as Coerce
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.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
$c== :: WeakValue -> WeakValue -> Bool
== :: WeakValue -> WeakValue -> Bool
$c/= :: WeakValue -> WeakValue -> Bool
/= :: 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

-- | 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 :: (MIO.MonadIO m, IsWeakValue o) => o -> m WeakValue
toWeakValue :: forall (m :: * -> *) o.
(MonadIO m, IsWeakValue o) =>
o -> m WeakValue
toWeakValue = IO WeakValue -> m WeakValue
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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'
B.ManagedPtr.unsafeCastTo ManagedPtr WeakValue -> WeakValue
WeakValue

-- | Convert 'WeakValue' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe WeakValue) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_jsc_weak_value_get_type
    gvalueSet_ :: Ptr GValue -> Maybe WeakValue -> IO ()
gvalueSet_ Ptr GValue
gv Maybe WeakValue
P.Nothing = Ptr GValue -> Ptr WeakValue -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr WeakValue
forall a. Ptr a
FP.nullPtr :: FP.Ptr WeakValue)
    gvalueSet_ Ptr GValue
gv (P.Just WeakValue
obj) = WeakValue -> (Ptr WeakValue -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WeakValue
obj (Ptr GValue -> Ptr WeakValue -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe WeakValue)
gvalueGet_ Ptr GValue
gv = do
        Ptr WeakValue
ptr <- Ptr GValue -> IO (Ptr WeakValue)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr WeakValue)
        if Ptr WeakValue
ptr Ptr WeakValue -> Ptr WeakValue -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr WeakValue
forall a. Ptr a
FP.nullPtr
        then WeakValue -> Maybe WeakValue
forall a. a -> Maybe a
P.Just (WeakValue -> Maybe WeakValue)
-> IO WeakValue -> IO (Maybe WeakValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe WeakValue -> IO (Maybe WeakValue)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WeakValue
forall a. Maybe a
P.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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveWeakValueMethod t WeakValue, O.OverloadedMethod info WeakValue p, R.HasField t WeakValue p) => R.HasField t WeakValue p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveWeakValueMethod t WeakValue, O.OverloadedMethodInfo info WeakValue) => OL.IsLabel t (O.MethodProxy info WeakValue) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

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

type C_WeakValueClearedCallback =
    Ptr WeakValue ->                        -- 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_WeakValueClearedCallback :: 
    GObject a => (a -> WeakValueClearedCallback) ->
    C_WeakValueClearedCallback
wrap_WeakValueClearedCallback :: forall a. GObject a => (a -> IO ()) -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback a -> IO ()
gi'cb Ptr WeakValue
gi'selfPtr Ptr ()
_ = do
    Ptr WeakValue -> (WeakValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr WeakValue
gi'selfPtr ((WeakValue -> IO ()) -> IO ()) -> (WeakValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \WeakValue
gi'self -> a -> IO ()
gi'cb (WeakValue -> a
forall a b. Coercible a b => a -> b
Coerce.coerce WeakValue
gi'self) 


-- | 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 -> ((?self :: a) => WeakValueClearedCallback) -> m SignalHandlerId
onWeakValueCleared :: forall a (m :: * -> *).
(IsWeakValue a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onWeakValueCleared a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WeakValueClearedCallback
wrapped' = (a -> IO ()) -> C_WeakValueClearedCallback
forall a. GObject a => (a -> IO ()) -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback a -> IO ()
wrapped
    FunPtr C_WeakValueClearedCallback
wrapped'' <- C_WeakValueClearedCallback
-> IO (FunPtr C_WeakValueClearedCallback)
mk_WeakValueClearedCallback C_WeakValueClearedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> ((?self :: a) => WeakValueClearedCallback) -> m SignalHandlerId
afterWeakValueCleared :: forall a (m :: * -> *).
(IsWeakValue a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterWeakValueCleared a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WeakValueClearedCallback
wrapped' = (a -> IO ()) -> C_WeakValueClearedCallback
forall a. GObject a => (a -> IO ()) -> C_WeakValueClearedCallback
wrap_WeakValueClearedCallback a -> IO ()
wrapped
    FunPtr C_WeakValueClearedCallback
wrapped'' <- C_WeakValueClearedCallback
-> IO (FunPtr C_WeakValueClearedCallback)
mk_WeakValueClearedCallback C_WeakValueClearedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.JavaScriptCore.Objects.WeakValue::cleared"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.25/docs/GI-JavaScriptCore-Objects-WeakValue.html#g:signal:cleared"})

#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 :: forall o (m :: * -> *) a.
(IsWeakValue o, MonadIO m, IsValue a) =>
a -> m (GValueConstruct o)
constructWeakValueValue a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.JavaScriptCore.Objects.WeakValue.value"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.25/docs/GI-JavaScriptCore-Objects-WeakValue.html#g:attr:value"
        })
#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
a -> m WeakValue
weakValueNew a
value = IO WeakValue -> m WeakValue
forall a. IO a -> m a
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 a. a -> IO a
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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWeakValue a) =>
a -> m Value
weakValueGetValue a
weakValue = IO Value -> m Value
forall a. IO a -> m a
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 a. a -> IO a
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.OverloadedMethod WeakValueGetValueMethodInfo a signature where
    overloadedMethod = weakValueGetValue

instance O.OverloadedMethodInfo WeakValueGetValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.JavaScriptCore.Objects.WeakValue.weakValueGetValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-javascriptcore-4.0.25/docs/GI-JavaScriptCore-Objects-WeakValue.html#v:weakValueGetValue"
        })


#endif