Copyright | Will Thompson, Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria (garetxe@gmail.com) |
Safe Haskell | None |
Language | Haskell2010 |
It can be used for doing a sequence of dictionary lookups in an efficient way on an existing #GVariant dictionary or it can be used to construct new dictionaries with a hashtable-like interface. It can also be used for taking existing dictionaries and modifying them in order to create new ones.
#GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT dictionaries.
It is possible to use #GVariantDict allocated on the stack or on the heap. When using a stack-allocated #GVariantDict, you begin with a call to g_variant_dict_init() and free the resources with a call to g_variant_dict_clear().
Heap-allocated #GVariantDict follows normal refcounting rules: you allocate it with g_variant_dict_new() and use g_variant_dict_ref() and g_variant_dict_unref().
g_variant_dict_end() is used to convert the #GVariantDict back into a dictionary-type #GVariant. When used with stack-allocated instances, this also implicitly frees all associated memory, but for heap-allocated instances, you must still call g_variant_dict_unref() afterwards.
You will typically want to use a heap-allocated #GVariantDict when you expose it as part of an API. For most other uses, the stack-allocated form will be more convenient.
Consider the following two examples that do the same thing in each style: take an existing dictionary and look up the "count" uint32 key, adding 1 to it if it is found, or returning an error if the key is not found. Each returns the new dictionary as a floating #GVariant.
## Using a stack-allocated GVariantDict
|[language="C" -- GVariant * add_to_count (GVariant *orig, GError **error) { GVariantDict dict; guint32 count;
g_variant_dict_init (&dict, orig); if (!g_variant_dict_lookup (&dict, "count", "u", &count)) { g_set_error (...); g_variant_dict_clear (&dict); return NULL; }
g_variant_dict_insert (&dict, "count", "u", count + 1);
return g_variant_dict_end (&dict); } ]|
## Using heap-allocated GVariantDict
|[language="C" -- GVariant * add_to_count (GVariant *orig, GError **error) { GVariantDict *dict; GVariant *result; guint32 count;
dict = g_variant_dict_new (orig);
if (g_variant_dict_lookup (dict, "count", "u", &count)) { g_variant_dict_insert (dict, "count", "u", count + 1); result = g_variant_dict_end (dict); } else { g_set_error (...); result = NULL; }
g_variant_dict_unref (dict);
return result; } ]|
- newtype VariantDict = VariantDict (ForeignPtr VariantDict)
- newZeroVariantDict :: MonadIO m => m VariantDict
- noVariantDict :: Maybe VariantDict
- data VariantDictClearMethodInfo
- variantDictClear :: MonadIO m => VariantDict -> m ()
- data VariantDictContainsMethodInfo
- variantDictContains :: MonadIO m => VariantDict -> Text -> m Bool
- data VariantDictEndMethodInfo
- variantDictEnd :: MonadIO m => VariantDict -> m GVariant
- data VariantDictInsertValueMethodInfo
- variantDictInsertValue :: MonadIO m => VariantDict -> Text -> GVariant -> m ()
- data VariantDictLookupValueMethodInfo
- variantDictLookupValue :: MonadIO m => VariantDict -> Text -> Maybe VariantType -> m GVariant
- variantDictNew :: MonadIO m => Maybe GVariant -> m VariantDict
- data VariantDictRefMethodInfo
- variantDictRef :: MonadIO m => VariantDict -> m VariantDict
- data VariantDictRemoveMethodInfo
- variantDictRemove :: MonadIO m => VariantDict -> Text -> m Bool
- data VariantDictUnrefMethodInfo
- variantDictUnref :: MonadIO m => VariantDict -> m ()
Exported types
newtype VariantDict Source
newZeroVariantDict :: MonadIO m => m VariantDict Source
Construct a VariantDict
struct initialized to zero.
Methods
variantDictClear
data VariantDictClearMethodInfo Source
((~) * signature (m ()), MonadIO m) => MethodInfo * VariantDictClearMethodInfo VariantDict signature |
variantDictClear :: MonadIO m => VariantDict -> m () Source
variantDictContains
data VariantDictContainsMethodInfo Source
((~) * signature (Text -> m Bool), MonadIO m) => MethodInfo * VariantDictContainsMethodInfo VariantDict signature |
variantDictContains :: MonadIO m => VariantDict -> Text -> m Bool Source
variantDictEnd
data VariantDictEndMethodInfo Source
((~) * signature (m GVariant), MonadIO m) => MethodInfo * VariantDictEndMethodInfo VariantDict signature |
variantDictEnd :: MonadIO m => VariantDict -> m GVariant Source
variantDictInsertValue
data VariantDictInsertValueMethodInfo Source
((~) * signature (Text -> GVariant -> m ()), MonadIO m) => MethodInfo * VariantDictInsertValueMethodInfo VariantDict signature |
variantDictInsertValue :: MonadIO m => VariantDict -> Text -> GVariant -> m () Source
variantDictLookupValue
data VariantDictLookupValueMethodInfo Source
((~) * signature (Text -> Maybe VariantType -> m GVariant), MonadIO m) => MethodInfo * VariantDictLookupValueMethodInfo VariantDict signature |
variantDictLookupValue :: MonadIO m => VariantDict -> Text -> Maybe VariantType -> m GVariant Source
variantDictNew
variantDictNew :: MonadIO m => Maybe GVariant -> m VariantDict Source
variantDictRef
data VariantDictRefMethodInfo Source
((~) * signature (m VariantDict), MonadIO m) => MethodInfo * VariantDictRefMethodInfo VariantDict signature |
variantDictRef :: MonadIO m => VariantDict -> m VariantDict Source
variantDictRemove
data VariantDictRemoveMethodInfo Source
((~) * signature (Text -> m Bool), MonadIO m) => MethodInfo * VariantDictRemoveMethodInfo VariantDict signature |
variantDictRemove :: MonadIO m => VariantDict -> Text -> m Bool Source
variantDictUnref
data VariantDictUnrefMethodInfo Source
((~) * signature (m ()), MonadIO m) => MethodInfo * VariantDictUnrefMethodInfo VariantDict signature |
variantDictUnref :: MonadIO m => VariantDict -> m () Source