{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.VariantDict
(
VariantDict(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveVariantDictMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
VariantDictClearMethodInfo ,
#endif
variantDictClear ,
#if defined(ENABLE_OVERLOADING)
VariantDictContainsMethodInfo ,
#endif
variantDictContains ,
#if defined(ENABLE_OVERLOADING)
VariantDictEndMethodInfo ,
#endif
variantDictEnd ,
#if defined(ENABLE_OVERLOADING)
VariantDictInsertValueMethodInfo ,
#endif
variantDictInsertValue ,
#if defined(ENABLE_OVERLOADING)
VariantDictLookupValueMethodInfo ,
#endif
variantDictLookupValue ,
variantDictNew ,
#if defined(ENABLE_OVERLOADING)
VariantDictRefMethodInfo ,
#endif
variantDictRef ,
#if defined(ENABLE_OVERLOADING)
VariantDictRemoveMethodInfo ,
#endif
variantDictRemove ,
#if defined(ENABLE_OVERLOADING)
VariantDictUnrefMethodInfo ,
#endif
variantDictUnref ,
) 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 {-# SOURCE #-} qualified GI.GLib.Structs.VariantType as GLib.VariantType
newtype VariantDict = VariantDict (SP.ManagedPtr VariantDict)
deriving (VariantDict -> VariantDict -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VariantDict -> VariantDict -> Bool
$c/= :: VariantDict -> VariantDict -> Bool
== :: VariantDict -> VariantDict -> Bool
$c== :: VariantDict -> VariantDict -> Bool
Eq)
instance SP.ManagedPtrNewtype VariantDict where
toManagedPtr :: VariantDict -> ManagedPtr VariantDict
toManagedPtr (VariantDict ManagedPtr VariantDict
p) = ManagedPtr VariantDict
p
foreign import ccall "g_variant_dict_get_type" c_g_variant_dict_get_type ::
IO GType
type instance O.ParentTypes VariantDict = '[]
instance O.HasParentTypes VariantDict
instance B.Types.TypedObject VariantDict where
glibType :: IO GType
glibType = IO GType
c_g_variant_dict_get_type
instance B.Types.GBoxed VariantDict
instance B.GValue.IsGValue (Maybe VariantDict) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_variant_dict_get_type
gvalueSet_ :: Ptr GValue -> Maybe VariantDict -> IO ()
gvalueSet_ Ptr GValue
gv Maybe VariantDict
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr VariantDict)
gvalueSet_ Ptr GValue
gv (P.Just VariantDict
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VariantDict
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe VariantDict)
gvalueGet_ Ptr GValue
gv = do
Ptr VariantDict
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr VariantDict)
if Ptr VariantDict
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VariantDict -> VariantDict
VariantDict Ptr VariantDict
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VariantDict
type instance O.AttributeList VariantDict = VariantDictAttributeList
type VariantDictAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "g_variant_dict_new" g_variant_dict_new ::
Ptr GVariant ->
IO (Ptr VariantDict)
variantDictNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (GVariant)
-> m VariantDict
variantDictNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe GVariant -> m VariantDict
variantDictNew Maybe GVariant
fromAsv = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
maybeFromAsv <- case Maybe GVariant
fromAsv of
Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just GVariant
jFromAsv -> do
Ptr GVariant
jFromAsv' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jFromAsv
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jFromAsv'
Ptr VariantDict
result <- Ptr GVariant -> IO (Ptr VariantDict)
g_variant_dict_new Ptr GVariant
maybeFromAsv
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"variantDictNew" Ptr VariantDict
result
VariantDict
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VariantDict -> VariantDict
VariantDict) Ptr VariantDict
result
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
fromAsv forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return VariantDict
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_dict_clear" g_variant_dict_clear ::
Ptr VariantDict ->
IO ()
variantDictClear ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> m ()
variantDictClear :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> m ()
variantDictClear VariantDict
dict = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
Ptr VariantDict -> IO ()
g_variant_dict_clear Ptr VariantDict
dict'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data VariantDictClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VariantDictClearMethodInfo VariantDict signature where
overloadedMethod = variantDictClear
instance O.OverloadedMethodInfo VariantDictClearMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictClear",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictClear"
})
#endif
foreign import ccall "g_variant_dict_contains" g_variant_dict_contains ::
Ptr VariantDict ->
CString ->
IO CInt
variantDictContains ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> T.Text
-> m Bool
variantDictContains :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> Text -> m Bool
variantDictContains VariantDict
dict Text
key = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
CString
key' <- Text -> IO CString
textToCString Text
key
CInt
result <- Ptr VariantDict -> CString -> IO CInt
g_variant_dict_contains Ptr VariantDict
dict' CString
key'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data VariantDictContainsMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod VariantDictContainsMethodInfo VariantDict signature where
overloadedMethod = variantDictContains
instance O.OverloadedMethodInfo VariantDictContainsMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictContains",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictContains"
})
#endif
foreign import ccall "g_variant_dict_end" g_variant_dict_end ::
Ptr VariantDict ->
IO (Ptr GVariant)
variantDictEnd ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> m GVariant
variantDictEnd :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> m GVariant
variantDictEnd VariantDict
dict = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
Ptr GVariant
result <- Ptr VariantDict -> IO (Ptr GVariant)
g_variant_dict_end Ptr VariantDict
dict'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"variantDictEnd" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
#if defined(ENABLE_OVERLOADING)
data VariantDictEndMethodInfo
instance (signature ~ (m GVariant), MonadIO m) => O.OverloadedMethod VariantDictEndMethodInfo VariantDict signature where
overloadedMethod = variantDictEnd
instance O.OverloadedMethodInfo VariantDictEndMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictEnd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictEnd"
})
#endif
foreign import ccall "g_variant_dict_insert_value" g_variant_dict_insert_value ::
Ptr VariantDict ->
CString ->
Ptr GVariant ->
IO ()
variantDictInsertValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> T.Text
-> GVariant
-> m ()
variantDictInsertValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> Text -> GVariant -> m ()
variantDictInsertValue VariantDict
dict Text
key GVariant
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr GVariant
value' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
Ptr VariantDict -> CString -> Ptr GVariant -> IO ()
g_variant_dict_insert_value Ptr VariantDict
dict' CString
key' Ptr GVariant
value'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data VariantDictInsertValueMethodInfo
instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m) => O.OverloadedMethod VariantDictInsertValueMethodInfo VariantDict signature where
overloadedMethod = variantDictInsertValue
instance O.OverloadedMethodInfo VariantDictInsertValueMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictInsertValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictInsertValue"
})
#endif
foreign import ccall "g_variant_dict_lookup_value" g_variant_dict_lookup_value ::
Ptr VariantDict ->
CString ->
Ptr GLib.VariantType.VariantType ->
IO (Ptr GVariant)
variantDictLookupValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> T.Text
-> Maybe (GLib.VariantType.VariantType)
-> m (Maybe GVariant)
variantDictLookupValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> Text -> Maybe VariantType -> m (Maybe GVariant)
variantDictLookupValue VariantDict
dict Text
key Maybe VariantType
expectedType = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr VariantType
maybeExpectedType <- case Maybe VariantType
expectedType of
Maybe VariantType
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just VariantType
jExpectedType -> do
Ptr VariantType
jExpectedType' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jExpectedType
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
jExpectedType'
Ptr GVariant
result <- Ptr VariantDict -> CString -> Ptr VariantType -> IO (Ptr GVariant)
g_variant_dict_lookup_value Ptr VariantDict
dict' CString
key' Ptr VariantType
maybeExpectedType
Maybe GVariant
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result'
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VariantType
expectedType forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeResult
#if defined(ENABLE_OVERLOADING)
data VariantDictLookupValueMethodInfo
instance (signature ~ (T.Text -> Maybe (GLib.VariantType.VariantType) -> m (Maybe GVariant)), MonadIO m) => O.OverloadedMethod VariantDictLookupValueMethodInfo VariantDict signature where
overloadedMethod = variantDictLookupValue
instance O.OverloadedMethodInfo VariantDictLookupValueMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictLookupValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictLookupValue"
})
#endif
foreign import ccall "g_variant_dict_ref" g_variant_dict_ref ::
Ptr VariantDict ->
IO (Ptr VariantDict)
variantDictRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> m VariantDict
variantDictRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> m VariantDict
variantDictRef VariantDict
dict = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
Ptr VariantDict
result <- Ptr VariantDict -> IO (Ptr VariantDict)
g_variant_dict_ref Ptr VariantDict
dict'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"variantDictRef" Ptr VariantDict
result
VariantDict
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VariantDict -> VariantDict
VariantDict) Ptr VariantDict
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall (m :: * -> *) a. Monad m => a -> m a
return VariantDict
result'
#if defined(ENABLE_OVERLOADING)
data VariantDictRefMethodInfo
instance (signature ~ (m VariantDict), MonadIO m) => O.OverloadedMethod VariantDictRefMethodInfo VariantDict signature where
overloadedMethod = variantDictRef
instance O.OverloadedMethodInfo VariantDictRefMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictRef"
})
#endif
foreign import ccall "g_variant_dict_remove" g_variant_dict_remove ::
Ptr VariantDict ->
CString ->
IO CInt
variantDictRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> T.Text
-> m Bool
variantDictRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> Text -> m Bool
variantDictRemove VariantDict
dict Text
key = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
CString
key' <- Text -> IO CString
textToCString Text
key
CInt
result <- Ptr VariantDict -> CString -> IO CInt
g_variant_dict_remove Ptr VariantDict
dict' CString
key'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall a. Ptr a -> IO ()
freeMem CString
key'
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data VariantDictRemoveMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod VariantDictRemoveMethodInfo VariantDict signature where
overloadedMethod = variantDictRemove
instance O.OverloadedMethodInfo VariantDictRemoveMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictRemove"
})
#endif
foreign import ccall "g_variant_dict_unref" g_variant_dict_unref ::
Ptr VariantDict ->
IO ()
variantDictUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantDict
-> m ()
variantDictUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantDict -> m ()
variantDictUnref VariantDict
dict = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed VariantDict
dict
Ptr VariantDict -> IO ()
g_variant_dict_unref Ptr VariantDict
dict'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data VariantDictUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VariantDictUnrefMethodInfo VariantDict signature where
overloadedMethod = variantDictUnref
instance O.OverloadedMethodInfo VariantDictUnrefMethodInfo VariantDict where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.VariantDict.variantDictUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-VariantDict.html#v:variantDictUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveVariantDictMethod (t :: Symbol) (o :: *) :: * where
ResolveVariantDictMethod "clear" o = VariantDictClearMethodInfo
ResolveVariantDictMethod "contains" o = VariantDictContainsMethodInfo
ResolveVariantDictMethod "end" o = VariantDictEndMethodInfo
ResolveVariantDictMethod "insertValue" o = VariantDictInsertValueMethodInfo
ResolveVariantDictMethod "lookupValue" o = VariantDictLookupValueMethodInfo
ResolveVariantDictMethod "ref" o = VariantDictRefMethodInfo
ResolveVariantDictMethod "remove" o = VariantDictRemoveMethodInfo
ResolveVariantDictMethod "unref" o = VariantDictUnrefMethodInfo
ResolveVariantDictMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveVariantDictMethod t VariantDict, O.OverloadedMethod info VariantDict p) => OL.IsLabel t (VariantDict -> 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 ~ ResolveVariantDictMethod t VariantDict, O.OverloadedMethod info VariantDict p, R.HasField t VariantDict p) => R.HasField t VariantDict p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveVariantDictMethod t VariantDict, O.OverloadedMethodInfo info VariantDict) => OL.IsLabel t (O.MethodProxy info VariantDict) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif