class GLib::VariantDict

GLib::VariantDict
Reference
Object

Overview

#GVariantDict is a mutable interface to #GVariant dictionaries.

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

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

} ]|

Defined in:

lib/gi-crystal/src/auto/g_lib-2.0/variant_dict.cr
lib/gi-crystal/src/bindings/g_lib/variant_dict.cr

Constructors

.new(pointer : Pointer(Void), transfer : GICrystal::Transfer)
.new(from_asv : _?) : self

Class Method Summary

.g_type : UInt64
Returns the type id (GType) registered in GLib type system.

Instance Method Summary

#==(other : self) : Bool
Returns true if this reference is the same as other.
#clear : Nil
#contains(key : String) : Bool
#end : GLib::Variant
#finalize
#insert_value(key : String, value : _) : Nil
#lookup_value(key : String, expected_type : GLib::VariantType?) : GLib::Variant?
#ref : GLib::VariantDict
#remove(key : String) : Bool
#to_unsafe : Pointer(Void)
#unref : Nil

Constructor Detail

def self.new(pointer : Pointer(Void), transfer : GICrystal::Transfer) #

def self.new(from_asv : _?) : self #

Class Method Detail

def self.g_type : UInt64 #

Returns the type id (GType) registered in GLib type system.

Instance Method Detail

def ==(other : self) : Bool #

Description copied from class Reference

Returns true if this reference is the same as other. Invokes same?.

def clear : Nil #

def contains(key : String) : Bool #

def end : GLib::Variant #

def finalize #

def insert_value(key : String, value : _) : Nil #

def lookup_value(key : String, expected_type : GLib::VariantType?) : GLib::Variant? #

def ref : GLib::VariantDict #

def remove(key : String) : Bool #

def to_unsafe : Pointer(Void) #

def unref : Nil #

javascriptcore