=head1 NAME
Glib::Variant - strongly typed value datatype
=cut
=for position SYNOPSIS
=head1 SYNOPSIS
my $v = Glib::Variant->new ('as', ['GTK+', 'Perl']);
my $aref = $v->get ('as');
=for position DESCRIPTION
=head1 DESCRIPTION
There are two sets of APIs for creating and dealing with C<Glib::Variant>s: the
low-level API described below under L</METHODS>, and the convenience API
described in this section.
=head2 CONVENIENCE API
=over
=item variant = Glib::Variant->new ($format_string, $value)
=item (variant1, ...) = Glib::Variant->new ($format_string, $value1, ...)
Constructs a variant from C<$format_string> and C<$value>. Also supports
constructing multiple variants when the format string is a concatenation of
multiple types.
=item value = $variant->get ($format_string)
Deconstructs C<$variant> according to C<$format_string>.
=back
The following symbols are currently supported in format strings:
+------------------------------+---------------------------------+
| Symbol | Meaning |
+------------------------------+---------------------------------+
| b, y, n, q, i, u, x, t, h, d | Boolean, byte and numeric types |
| s, o, g | String types |
| v | Variant types |
| a | Arrays |
| m | Maybe types |
| () | Tuples |
| {} | Dictionary entries |
+------------------------------+---------------------------------+
Note that if a format string specifies an array, a tuple or a dictionary entry
("a", "()" or "{}"), then array references are expected by C<new> and produced
by C<get>. For arrays of dictionary entries ("a{}"), hash references are also
supported by C<new> and handled as you would expect.
For a complete specification, see the documentation at
=over
=item L<https://developer.gnome.org/glib/stable/glib-GVariantType.html>
=item L<https://developer.gnome.org/glib/stable/glib-GVariant.html>
=item L<https://developer.gnome.org/glib/stable/gvariant-format-strings.html>
=item L<https://developer.gnome.org/glib/stable/gvariant-text.html>
=back
=cut
=head1 HIERARCHY
Glib::Variant
=cut
=for object Glib::Variant strongly typed value datatype
=cut
=head1 METHODS
=head2 variant = Glib::Variant-E<gt>B<new_array> ($child_type, $children)
=over
=item * $child_type (Glib::VariantType)
=item * $children (scalar)
=back
=head2 variant = Glib::Variant-E<gt>B<new_boolean> ($value)
=over
=item * $value (boolean)
=back
=head2 variant = Glib::Variant-E<gt>B<new_byte> ($value)
=over
=item * $value (Glib::UChar)
=back
=head2 variant = Glib::Variant-E<gt>B<new_bytestring> ($string)
=over
=item * $string (byte string)
=back
Since: glib 2.26
=head2 variant = Glib::Variant-E<gt>B<new_dict_entry> ($key, $value)
=over
=item * $key (Glib::Variant)
=item * $value (Glib::Variant)
=back
=head2 variant = Glib::Variant-E<gt>B<new_double> ($value)
=over
=item * $value (double)
=back
=head2 variant = Glib::Variant-E<gt>B<new_handle> ($value)
=over
=item * $value (integer)
=back
=head2 variant = Glib::Variant-E<gt>B<new_int16> ($value)
=over
=item * $value (integer)
=back
=head2 variant = Glib::Variant-E<gt>B<new_int32> ($value)
=over
=item * $value (integer)
=back
=head2 variant = Glib::Variant-E<gt>B<new_int64> ($value)
=over
=item * $value (64 bit integer)
=back
=head2 variant = Glib::Variant-E<gt>B<new_maybe> ($child_type, $child)
=over
=item * $child_type (Glib::VariantType)
=item * $child (Glib::Variant)
=back
=head2 variant = Glib::Variant-E<gt>B<new_object_path> ($object_path)
=over
=item * $object_path (string)
=back
=head2 variant = Glib::Variant-E<gt>B<new_signature> ($signature)
=over
=item * $signature (string)
=back
=head2 variant = Glib::Variant-E<gt>B<new_string> ($string)
=over
=item * $string (string)
=back
=head2 variant = Glib::Variant-E<gt>B<new_tuple> ($children)
=over
=item * $children (scalar)
=back
=head2 variant = Glib::Variant-E<gt>B<new_uint16> ($value)
=over
=item * $value (unsigned)
=back
=head2 variant = Glib::Variant-E<gt>B<new_uint32> ($value)
=over
=item * $value (unsigned)
=back
=head2 variant = Glib::Variant-E<gt>B<new_uint64> ($value)
=over
=item * $value (64 bit unsigned)
=back
=head2 variant = Glib::Variant-E<gt>B<new_variant> ($value)
=over
=item * $value (Glib::Variant)
=back
=head2 boolean = $value-E<gt>B<get_boolean>
=head2 uchar = $value-E<gt>B<get_byte>
=head2 string = $value-E<gt>B<get_bytestring>
Since: glib 2.26
=head2 variant = $value-E<gt>B<byteswap>
=head2 variant = $value-E<gt>B<get_child_value> ($index_)
=over
=item * $index_ (unsigned)
=back
=head2 string = $value-E<gt>B<classify>
=head2 integer = $one-E<gt>B<compare> ($two)
=over
=item * $two (Glib::Variant)
=back
Since: glib 2.26
=head2 double = $value-E<gt>B<get_double>
=head2 boolean = $one-E<gt>B<equal> ($two)
=over
=item * $two (Glib::Variant)
=back
=head2 integer = $value-E<gt>B<get_handle>
=head2 integer = $value-E<gt>B<hash>
=head2 integer = $value-E<gt>B<get_int16>
=head2 integer = $value-E<gt>B<get_int32>
=head2 64 bit integer = $value-E<gt>B<get_int64>
=head2 boolean = $value-E<gt>B<is_container>
=head2 boolean = $value-E<gt>B<is_normal_form>
=head2 boolean = $string-E<gt>B<is_object_path>
=head2 boolean = $value-E<gt>B<is_of_type> ($type)
=over
=item * $type (Glib::VariantType)
=back
=head2 boolean = $string-E<gt>B<is_signature>
=head2 variant = $dictionary-E<gt>B<lookup_value> ($key, $expected_type)
=over
=item * $key (string)
=item * $expected_type (Glib::VariantType)
=back
Since: glib 2.28
=head2 variant = $value-E<gt>B<get_maybe>
=head2 unsigned = $value-E<gt>B<n_children>
=head2 variant = $value-E<gt>B<get_normal_form>
=head2 variant = Glib::Variant::parse ($type, $text)
=over
=item * $type (Glib::VariantType)
=item * $text (string)
=back
May croak with a L<Glib::Error> in $@ on failure.
=head2 string = $value-E<gt>B<print> ($type_annotate)
=over
=item * $type_annotate (boolean)
=back
=head2 unsigned = $value-E<gt>B<get_size>
=head2 string = $value-E<gt>B<get_string>
=head2 varianttype = $value-E<gt>B<get_type>
=head2 string = $value-E<gt>B<get_type_string>
=head2 unsigned = $value-E<gt>B<get_uint16>
=head2 unsigned = $value-E<gt>B<get_uint32>
=head2 64 bit unsigned = $value-E<gt>B<get_uint64>
=head2 variant = $value-E<gt>B<get_variant>
=cut
=head1 SEE ALSO
L<Glib>, L<Glib::VariantType>, L<Glib::VariantDict>
=cut
=head1 COPYRIGHT
Copyright (C) 2003-2011 by the gtk2-perl team.
This software is licensed under the LGPL. See L<Glib> for a full notice.
=cut