{-# 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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.GLib.Structs.VariantType as GLib.VariantType
#else
import {-# SOURCE #-} qualified GI.GLib.Structs.VariantType as GLib.VariantType
#endif
newtype VariantDict = VariantDict (SP.ManagedPtr VariantDict)
deriving (VariantDict -> VariantDict -> Bool
(VariantDict -> VariantDict -> Bool)
-> (VariantDict -> VariantDict -> Bool) -> Eq VariantDict
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariantDict -> VariantDict -> Bool
== :: VariantDict -> VariantDict -> Bool
$c/= :: VariantDict -> VariantDict -> Bool
/= :: 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 = Ptr GValue -> Ptr VariantDict -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr VariantDict
forall a. Ptr a
FP.nullPtr :: FP.Ptr VariantDict)
gvalueSet_ Ptr GValue
gv (P.Just VariantDict
obj) = VariantDict -> (Ptr VariantDict -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VariantDict
obj (Ptr GValue -> Ptr VariantDict -> IO ()
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 <- Ptr GValue -> IO (Ptr VariantDict)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr VariantDict)
if Ptr VariantDict
ptr Ptr VariantDict -> Ptr VariantDict -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr VariantDict
forall a. Ptr a
FP.nullPtr
then VariantDict -> Maybe VariantDict
forall a. a -> Maybe a
P.Just (VariantDict -> Maybe VariantDict)
-> IO VariantDict -> IO (Maybe VariantDict)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr VariantDict -> VariantDict)
-> Ptr VariantDict -> IO VariantDict
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VariantDict -> VariantDict
VariantDict Ptr VariantDict
ptr
else Maybe VariantDict -> IO (Maybe VariantDict)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VariantDict
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VariantDict
type instance O.AttributeList VariantDict = VariantDictAttributeList
type VariantDictAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#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 = IO VariantDict -> m VariantDict
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantDict -> m VariantDict)
-> IO VariantDict -> m VariantDict
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
maybeFromAsv <- case Maybe GVariant
fromAsv of
Maybe GVariant
Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
nullPtr
Just GVariant
jFromAsv -> do
Ptr GVariant
jFromAsv' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jFromAsv
Ptr GVariant -> IO (Ptr GVariant)
forall a. a -> IO a
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
Text -> Ptr VariantDict -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"variantDictNew" Ptr VariantDict
result
VariantDict
result' <- ((ManagedPtr VariantDict -> VariantDict)
-> Ptr VariantDict -> IO VariantDict
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VariantDict -> VariantDict
VariantDict) Ptr VariantDict
result
Maybe GVariant -> (GVariant -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
fromAsv GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
VariantDict -> IO VariantDict
forall a. a -> IO a
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
Ptr VariantDict -> IO ()
g_variant_dict_clear Ptr VariantDict
dict'
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
() -> IO ()
forall a. a -> IO a
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.30/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 = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
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' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Bool -> IO Bool
forall a. a -> IO a
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.30/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 = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
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'
Text -> Ptr GVariant -> IO ()
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
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
GVariant -> IO GVariant
forall a. a -> IO a
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.30/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantDict
dict
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
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'
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
() -> IO ()
forall a. a -> IO a
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.30/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 = IO (Maybe GVariant) -> m (Maybe GVariant)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
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 -> Ptr VariantType -> IO (Ptr VariantType)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
nullPtr
Just VariantType
jExpectedType -> do
Ptr VariantType
jExpectedType' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jExpectedType
Ptr VariantType -> IO (Ptr VariantType)
forall a. a -> IO a
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 <- Ptr GVariant
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
result ((Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant))
-> (Ptr GVariant -> IO GVariant) -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
result' -> do
GVariant
result'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result'
GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result''
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
Maybe VariantType -> (VariantType -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VariantType
expectedType VariantType -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Maybe GVariant -> IO (Maybe GVariant)
forall a. a -> IO a
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.30/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 = IO VariantDict -> m VariantDict
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantDict -> m VariantDict)
-> IO VariantDict -> m VariantDict
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
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'
Text -> Ptr VariantDict -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"variantDictRef" Ptr VariantDict
result
VariantDict
result' <- ((ManagedPtr VariantDict -> VariantDict)
-> Ptr VariantDict -> IO VariantDict
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VariantDict -> VariantDict
VariantDict) Ptr VariantDict
result
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
VariantDict -> IO VariantDict
forall a. a -> IO a
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.30/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 = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
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' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Bool -> IO Bool
forall a. a -> IO a
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.30/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr VariantDict
dict' <- VariantDict -> IO (Ptr VariantDict)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed VariantDict
dict
Ptr VariantDict -> IO ()
g_variant_dict_unref Ptr VariantDict
dict'
VariantDict -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VariantDict
dict
() -> IO ()
forall a. a -> IO a
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.30/docs/GI-GLib-Structs-VariantDict.html#v:variantDictUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveVariantDictMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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