Skip to content

GLib.VariantDict

record (struct)

VariantDict is a mutable interface to Variant dictionaries.

It can be used for doing a sequence of dictionary lookups in an efficient way on an existing Variant 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.

VariantDict can only be used with G_VARIANT_TYPE_VARDICT dictionaries.

It is possible to use VariantDict allocated on the stack or on the heap. When using a stack-allocated VariantDict, you begin with a call to g_variant_dict_init() and free the resources with a call to VariantDict.clear.

Heap-allocated VariantDict follows normal refcounting rules: you allocate it with VariantDict.new and use VariantDict.ref and VariantDict.unref.

VariantDict.end is used to convert the VariantDict back into a dictionary-type Variant. When used with stack-allocated instances, this also implicitly frees all associated memory, but for heap-allocated instances, you must still call VariantDict.unref afterwards.

You will typically want to use a heap-allocated VariantDict 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 Variant.

Using a stack-allocated GVariantDict

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

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;
  }

Constructors

new

@classmethod
def new(cls, from_asv: Variant | None = ...) -> VariantDict

Allocates and initialises a new VariantDict.

You should call VariantDict.unref on the return value when it is no longer needed. The memory will not be automatically freed by any other call.

In some cases it may be easier to place a VariantDict directly on the stack of the calling function and initialise it with g_variant_dict_init(). This is particularly useful when you are using VariantDict to construct a Variant.

Parameters:

  • from_asv — the Variant with which to initialise the dictionary

Methods

clear

def clear(self) -> None

Releases all memory associated with a VariantDict without freeing the VariantDict structure itself.

It typically only makes sense to do this on a stack-allocated VariantDict if you want to abort building the value part-way through. This function need not be called if you call VariantDict.end and it also doesn't need to be called on dicts allocated with VariantDict.new (see VariantDict.unref for that).

It is valid to call this function on either an initialised VariantDict or one that was previously cleared by an earlier call to VariantDict.clear but it is not valid to call this function on uninitialised memory.

contains

def contains(self, key: str) -> bool

Checks if key exists in dict.

Parameters:

  • key — the key to look up in the dictionary

end

def end(self) -> Variant

Returns the current value of dict as a Variant of type G_VARIANT_TYPE_VARDICT, clearing it in the process.

It is not permissible to use dict in any way after this call except for reference counting operations (in the case of a heap-allocated VariantDict) or by reinitialising it with g_variant_dict_init() (in the case of stack-allocated).

insert_value

def insert_value(self, key: str, value: Variant) -> None

Inserts (or replaces) a key in a VariantDict.

value is consumed if it is floating.

Parameters:

  • key — the key to insert a value for
  • value — the value to insert

lookup_value

def lookup_value(self, key: str, expected_type: VariantType | None = ...) -> Variant | None

Looks up a value in a VariantDict.

If key is not found in dictionary, None is returned.

The expected_type string specifies what type of value is expected. If the value associated with key has a different type then None is returned.

If the key is found and the value has the correct type, it is returned. If expected_type was specified then any non-None return value will have this type.

Parameters:

  • key — the key to look up in the dictionary
  • expected_type — a VariantType, or None

ref

def ref(self) -> VariantDict

Increases the reference count on dict.

Don't call this on stack-allocated VariantDict instances or bad things will happen.

remove

def remove(self, key: str) -> bool

Removes a key and its associated value from a VariantDict.

Parameters:

  • key — the key to remove

unref

def unref(self) -> None

Decreases the reference count on dict.

In the event that there are no more references, releases all memory associated with the VariantDict.

Don't call this on stack-allocated VariantDict instances or bad things will happen.