#include <glib/gvariant-core.h>
#include <glib/gtestutils.h>
#include <glib/gstrfuncs.h>
+#include <glib/gslice.h>
#include <glib/ghash.h>
#include <glib/gmem.h>
*
* #GVariant is largely compatible with D-Bus. Almost all types of
* #GVariant instances can be sent over D-Bus. See #GVariantType for
- * exceptions.
+ * exceptions. (However, #GVariant's serialisation format is not the same
+ * as the serialisation format of a D-Bus message body: use #GDBusMessage,
+ * in the gio library, for those.)
+ *
+ * For space-efficiency, the #GVariant serialisation format does not
+ * automatically include the variant's type or endianness, which must
+ * either be implied from context (such as knowledge that a particular
+ * file format always contains a little-endian %G_VARIANT_TYPE_VARIANT)
+ * or supplied out-of-band (for instance, a type and/or endianness
+ * indicator could be placed at the beginning of a file, network message
+ * or network stream).
+ *
+ * A #GVariant's size is limited mainly by any lower level operating
+ * system constraints, such as the number of bits in #gsize. For
+ * example, it is reasonable to have a 2GB file mapped into memory
+ * with #GMappedFile, and call g_variant_new_from_data() on it.
*
* For convenience to C programmers, #GVariant features powerful
* varargs-based value construction and destruction. This feature is
* information cache, buffer management memory and memory for the
* #GVariant structure itself.
* </para>
- * <refsect3>
+ * <refsect3 id="gvariant-serialised-data-memory">
* <title>Serialised Data Memory</title>
* <para>
* This is the memory that is used for storing GVariant data in
* then although there are 9 individual values that comprise the
* entire dictionary (two keys, two values, two variants containing
* the values, two dictionary entries, plus the dictionary itself),
- * only 1 #GVariant instance exists -- the one refering to the
+ * only 1 #GVariant instance exists -- the one referring to the
* dictionary.
* </para>
* <para>
* @type: the #GVariantType
* @data: the data to use
* @size: the size of @data
- * @returns: a new floating #GVariant
*
* Constructs a new trusted #GVariant instance from the provided data.
* This is used to implement g_variant_new_* for all the basic types.
+ *
+ * Returns: a new floating #GVariant
*/
static GVariant *
g_variant_new_from_trusted (const GVariantType *type,
gsize size)
{
GVariant *value;
- GBuffer *buffer;
+ GBytes *bytes;
- buffer = g_buffer_new_from_data (data, size);
- value = g_variant_new_from_buffer (type, buffer, TRUE);
- g_buffer_unref (buffer);
+ bytes = g_bytes_new (data, size);
+ value = g_variant_new_from_bytes (type, bytes, TRUE);
+ g_bytes_unref (bytes);
return value;
}
/**
* g_variant_new_boolean:
* @value: a #gboolean value
- * @returns: (transfer none): a floating reference to a new boolean #GVariant instance
*
* Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.
*
+ * Returns: (transfer none): a floating reference to a new boolean #GVariant instance
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_get_boolean:
* @value: a boolean #GVariant instance
- * @returns: %TRUE or %FALSE
*
* Returns the boolean value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_BOOLEAN.
*
+ * Returns: %TRUE or %FALSE
+ *
* Since: 2.24
**/
gboolean
/**
* g_variant_new_byte:
* @value: a #guint8 value
- * @returns: (transfer none): a floating reference to a new byte #GVariant instance
*
* Creates a new byte #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new byte #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_byte:
* @value: a byte #GVariant instance
- * @returns: a #guchar
*
* Returns the byte value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_BYTE.
*
+ * Returns: a #guchar
+ *
* Since: 2.24
**/
NUMERIC_TYPE (BYTE, byte, guchar)
/**
* g_variant_new_int16:
* @value: a #gint16 value
- * @returns: (transfer none): a floating reference to a new int16 #GVariant instance
*
* Creates a new int16 #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new int16 #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_int16:
* @value: a int16 #GVariant instance
- * @returns: a #gint16
*
* Returns the 16-bit signed integer value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_INT16.
*
+ * Returns: a #gint16
+ *
* Since: 2.24
**/
NUMERIC_TYPE (INT16, int16, gint16)
/**
* g_variant_new_uint16:
* @value: a #guint16 value
- * @returns: (transfer none): a floating reference to a new uint16 #GVariant instance
*
* Creates a new uint16 #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new uint16 #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_uint16:
* @value: a uint16 #GVariant instance
- * @returns: a #guint16
*
* Returns the 16-bit unsigned integer value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_UINT16.
*
+ * Returns: a #guint16
+ *
* Since: 2.24
**/
NUMERIC_TYPE (UINT16, uint16, guint16)
/**
* g_variant_new_int32:
* @value: a #gint32 value
- * @returns: (transfer none): a floating reference to a new int32 #GVariant instance
*
* Creates a new int32 #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new int32 #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_int32:
* @value: a int32 #GVariant instance
- * @returns: a #gint32
*
* Returns the 32-bit signed integer value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_INT32.
*
+ * Returns: a #gint32
+ *
* Since: 2.24
**/
NUMERIC_TYPE (INT32, int32, gint32)
/**
* g_variant_new_uint32:
* @value: a #guint32 value
- * @returns: (transfer none): a floating reference to a new uint32 #GVariant instance
*
* Creates a new uint32 #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new uint32 #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_uint32:
* @value: a uint32 #GVariant instance
- * @returns: a #guint32
*
* Returns the 32-bit unsigned integer value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_UINT32.
*
+ * Returns: a #guint32
+ *
* Since: 2.24
**/
NUMERIC_TYPE (UINT32, uint32, guint32)
/**
* g_variant_new_int64:
* @value: a #gint64 value
- * @returns: (transfer none): a floating reference to a new int64 #GVariant instance
*
* Creates a new int64 #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new int64 #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_int64:
* @value: a int64 #GVariant instance
- * @returns: a #gint64
*
* Returns the 64-bit signed integer value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_INT64.
*
+ * Returns: a #gint64
+ *
* Since: 2.24
**/
NUMERIC_TYPE (INT64, int64, gint64)
/**
* g_variant_new_uint64:
* @value: a #guint64 value
- * @returns: (transfer none): a floating reference to a new uint64 #GVariant instance
*
* Creates a new uint64 #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new uint64 #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_uint64:
* @value: a uint64 #GVariant instance
- * @returns: a #guint64
*
* Returns the 64-bit unsigned integer value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_UINT64.
*
+ * Returns: a #guint64
+ *
* Since: 2.24
**/
NUMERIC_TYPE (UINT64, uint64, guint64)
/**
* g_variant_new_handle:
* @value: a #gint32 value
- * @returns: (transfer none): a floating reference to a new handle #GVariant instance
*
* Creates a new handle #GVariant instance.
*
* that are sent alongside a D-Bus message. If you're not interacting
* with D-Bus, you probably don't need them.
*
+ * Returns: (transfer none): a floating reference to a new handle #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_handle:
* @value: a handle #GVariant instance
- * @returns: a #gint32
*
* Returns the 32-bit signed integer value of @value.
*
* that are sent alongside a D-Bus message. If you're not interacting
* with D-Bus, you probably don't need them.
*
+ * Returns: a #gint32
+ *
* Since: 2.24
**/
NUMERIC_TYPE (HANDLE, handle, gint32)
/**
* g_variant_new_double:
* @value: a #gdouble floating point value
- * @returns: (transfer none): a floating reference to a new double #GVariant instance
*
* Creates a new double #GVariant instance.
*
+ * Returns: (transfer none): a floating reference to a new double #GVariant instance
+ *
* Since: 2.24
**/
/**
* g_variant_get_double:
* @value: a double #GVariant instance
- * @returns: a #gdouble
*
* Returns the double precision floating point value of @value.
*
* It is an error to call this function with a @value of any type
* other than %G_VARIANT_TYPE_DOUBLE.
*
+ * Returns: a #gdouble
+ *
* Since: 2.24
**/
NUMERIC_TYPE (DOUBLE, double, gdouble)
* g_variant_new_maybe:
* @child_type: (allow-none): the #GVariantType of the child, or %NULL
* @child: (allow-none): the child value, or %NULL
- * @returns: (transfer none): a floating reference to a new #GVariant maybe instance
*
* Depending on if @child is %NULL, either wraps @child inside of a
* maybe container or creates a Nothing instance for the given @type.
* If @child is a floating reference (see g_variant_ref_sink()), the new
* instance takes ownership of @child.
*
+ * Returns: (transfer none): a floating reference to a new #GVariant maybe instance
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_get_maybe:
* @value: a maybe-typed value
- * @returns: (allow-none) (transfer full): the contents of @value, or %NULL
*
* Given a maybe-typed #GVariant instance, extract its value. If the
* value is Nothing, then this function returns %NULL.
*
+ * Returns: (allow-none) (transfer full): the contents of @value, or %NULL
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_new_variant: (constructor)
* @value: a #GVariant instance
- * @returns: (transfer none): a floating reference to a new variant #GVariant instance
*
* Boxes @value. The result is a #GVariant instance representing a
* variant containing the original value.
* If @child is a floating reference (see g_variant_ref_sink()), the new
* instance takes ownership of @child.
*
+ * Returns: (transfer none): a floating reference to a new variant #GVariant instance
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_get_variant:
* @value: a variant #GVariant instance
- * @returns: (transfer full): the item contained in the variant
*
* Unboxes @value. The result is the #GVariant instance that was
* contained in @value.
*
+ * Returns: (transfer full): the item contained in the variant
+ *
* Since: 2.24
**/
GVariant *
* @children: (allow-none) (array length=n_children): an array of
* #GVariant pointers, the children
* @n_children: the length of @children
- * @returns: (transfer none): a floating reference to a new #GVariant array
*
* Creates a new #GVariant array from @children.
*
* If the @children are floating references (see g_variant_ref_sink()), the
* new instance takes ownership of them as if via g_variant_ref_sink().
*
+ * Returns: (transfer none): a floating reference to a new #GVariant array
+ *
* Since: 2.24
**/
GVariant *
* g_variant_new_tuple:
* @children: (array length=n_children): the items to make the tuple out of
* @n_children: the length of @children
- * @returns: (transfer none): a floating reference to a new #GVariant tuple
*
* Creates a new tuple #GVariant out of the items in @children. The
* type is determined from the types of @children. No entry in the
* If the @children are floating references (see g_variant_ref_sink()), the
* new instance takes ownership of them as if via g_variant_ref_sink().
*
+ * Returns: (transfer none): a floating reference to a new #GVariant tuple
+ *
* Since: 2.24
**/
GVariant *
* g_variant_new_dict_entry: (constructor)
* @key: a basic #GVariant, the key
* @value: a #GVariant, the value
- * @returns: (transfer none): a floating reference to a new dictionary entry #GVariant
*
* Creates a new dictionary entry #GVariant. @key and @value must be
* non-%NULL. @key must be a value of a basic type (ie: not a container).
* If the @key or @value are floating references (see g_variant_ref_sink()),
* the new instance takes ownership of them as if via g_variant_ref_sink().
*
+ * Returns: (transfer none): a floating reference to a new dictionary entry #GVariant
+ *
* Since: 2.24
**/
GVariant *
* this function returns %FALSE. Otherwise, it unpacks the returned
* value and returns %TRUE.
*
- * See g_variant_get() for information about @format_string.
+ * @format_string determines the C types that are used for unpacking
+ * the values and also determines if the values are copied or borrowed,
+ * see the section on
+ * <link linkend='gvariant-format-strings-pointers'>GVariant Format Strings</link>.
*
* Returns: %TRUE if a value was unpacked
*
* @value: a #GVariant array with fixed-sized elements
* @n_elements: (out): a pointer to the location to store the number of items
* @element_size: the size of each element
- * @returns: (array length=n_elements) (transfer none): a pointer to
- * the fixed array
*
* Provides access to the serialised data for an array of fixed-sized
* items.
*
* @value must be an array with fixed-sized elements. Numeric types are
- * fixed-size as are tuples containing only other fixed-sized types.
- *
- * @element_size must be the size of a single element in the array. For
- * example, if calling this function for an array of 32 bit integers,
+ * fixed-size, as are tuples containing only other fixed-sized types.
+ *
+ * @element_size must be the size of a single element in the array,
+ * as given by the section on
+ * <link linkend='gvariant-serialised-data-memory'>Serialised Data
+ * Memory</link>.
+ *
+ * In particular, arrays of these fixed-sized types can be interpreted
+ * as an array of the given C type, with @element_size set to
+ * <code>sizeof</code> the appropriate type:
+ *
+ * <informaltable>
+ * <tgroup cols='2'>
+ * <thead><row><entry>element type</entry> <entry>C type</entry></row></thead>
+ * <tbody>
+ * <row><entry>%G_VARIANT_TYPE_INT16 (etc.)</entry>
+ * <entry>#gint16 (etc.)</entry></row>
+ * <row><entry>%G_VARIANT_TYPE_BOOLEAN</entry>
+ * <entry>#guchar (not #gboolean!)</entry></row>
+ * <row><entry>%G_VARIANT_TYPE_BYTE</entry> <entry>#guchar</entry></row>
+ * <row><entry>%G_VARIANT_TYPE_HANDLE</entry> <entry>#guint32</entry></row>
+ * <row><entry>%G_VARIANT_TYPE_DOUBLE</entry> <entry>#gdouble</entry></row>
+ * </tbody>
+ * </tgroup>
+ * </informaltable>
+ *
+ * For example, if calling this function for an array of 32 bit integers,
* you might say <code>sizeof (gint32)</code>. This value isn't used
* except for the purpose of a double-check that the form of the
- * seralised data matches the caller's expectation.
+ * serialised data matches the caller's expectation.
*
* @n_elements, which must be non-%NULL is set equal to the number of
* items in the array.
*
+ * Returns: (array length=n_elements) (transfer none): a pointer to
+ * the fixed array
+ *
* Since: 2.24
**/
gconstpointer
return NULL;
}
+/**
+ * g_variant_new_fixed_array:
+ * @element_type: the #GVariantType of each element
+ * @elements: a pointer to the fixed array of contiguous elements
+ * @n_elements: the number of elements
+ * @element_size: the size of each element
+ *
+ * Provides access to the serialised data for an array of fixed-sized
+ * items.
+ *
+ * @value must be an array with fixed-sized elements. Numeric types are
+ * fixed-size as are tuples containing only other fixed-sized types.
+ *
+ * @element_size must be the size of a single element in the array. For
+ * example, if calling this function for an array of 32 bit integers,
+ * you might say <code>sizeof (gint32)</code>. This value isn't used
+ * except for the purpose of a double-check that the form of the
+ * serialised data matches the caller's expectation.
+ *
+ * @n_elements, which must be non-%NULL is set equal to the number of
+ * items in the array.
+ *
+ * Returns: (transfer none): a floating reference to a new array #GVariant instance
+ *
+ * Since: 2.32
+ **/
+GVariant *
+g_variant_new_fixed_array (const GVariantType *element_type,
+ gconstpointer elements,
+ gsize n_elements,
+ gsize element_size)
+{
+ GVariantType *array_type;
+ gsize array_element_size;
+ GVariantTypeInfo *array_info;
+ GVariant *value;
+ gpointer data;
+
+ g_return_val_if_fail (g_variant_type_is_definite (element_type), NULL);
+ g_return_val_if_fail (element_size > 0, NULL);
+
+ array_type = g_variant_type_new_array (element_type);
+ array_info = g_variant_type_info_get (array_type);
+ g_variant_type_info_query_element (array_info, NULL, &array_element_size);
+ if G_UNLIKELY (array_element_size != element_size)
+ {
+ if (array_element_size)
+ g_critical ("g_variant_new_fixed_array: array size %" G_GSIZE_FORMAT
+ " does not match given element_size %" G_GSIZE_FORMAT ".",
+ array_element_size, element_size);
+ else
+ g_critical ("g_variant_get_fixed_array: array does not have fixed size.");
+ return NULL;
+ }
+
+ data = g_memdup (elements, n_elements * element_size);
+ value = g_variant_new_from_data (array_type, data,
+ n_elements * element_size,
+ FALSE, g_free, data);
+
+ g_variant_type_free (array_type);
+ g_variant_type_info_unref (array_info);
+
+ return value;
+}
+
/* String type constructor/getters/validation {{{1 */
/**
* g_variant_new_string:
* @string: a normal utf8 nul-terminated string
- * @returns: (transfer none): a floating reference to a new string #GVariant instance
*
* Creates a string #GVariant with the contents of @string.
*
* @string must be valid utf8.
*
+ * Returns: (transfer none): a floating reference to a new string #GVariant instance
+ *
* Since: 2.24
**/
GVariant *
}
/**
+ * g_variant_new_take_string: (skip)
+ * @string: a normal utf8 nul-terminated string
+ *
+ * Creates a string #GVariant with the contents of @string.
+ *
+ * @string must be valid utf8.
+ *
+ * This function consumes @string. g_free() will be called on @string
+ * when it is no longer required.
+ *
+ * You must not modify or access @string in any other way after passing
+ * it to this function. It is even possible that @string is immediately
+ * freed.
+ *
+ * Returns: (transfer none): a floating reference to a new string
+ * #GVariant instance
+ *
+ * Since: 2.38
+ **/
+GVariant *
+g_variant_new_take_string (gchar *string)
+{
+ GVariant *value;
+ GBytes *bytes;
+
+ g_return_val_if_fail (string != NULL, NULL);
+ g_return_val_if_fail (g_utf8_validate (string, -1, NULL), NULL);
+
+ bytes = g_bytes_new_take (string, strlen (string) + 1);
+ value = g_variant_new_from_bytes (G_VARIANT_TYPE_STRING, bytes, TRUE);
+ g_bytes_unref (bytes);
+
+ return value;
+}
+
+/**
* g_variant_new_object_path:
* @object_path: a normal C nul-terminated string
- * @returns: (transfer none): a floating reference to a new object path #GVariant instance
*
* Creates a D-Bus object path #GVariant with the contents of @string.
* @string must be a valid D-Bus object path. Use
* g_variant_is_object_path() if you're not sure.
*
+ * Returns: (transfer none): a floating reference to a new object path #GVariant instance
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_is_object_path:
* @string: a normal C nul-terminated string
- * @returns: %TRUE if @string is a D-Bus object path
*
* Determines if a given string is a valid D-Bus object path. You
* should ensure that a string is a valid D-Bus object path before
* must contain only the characters "[A-Z][a-z][0-9]_". No sequence
* (including the one following the final '/' character) may be empty.
*
+ * Returns: %TRUE if @string is a D-Bus object path
+ *
* Since: 2.24
**/
gboolean
/**
* g_variant_new_signature:
* @signature: a normal C nul-terminated string
- * @returns: (transfer none): a floating reference to a new signature #GVariant instance
*
* Creates a D-Bus type signature #GVariant with the contents of
* @string. @string must be a valid D-Bus type signature. Use
* g_variant_is_signature() if you're not sure.
*
+ * Returns: (transfer none): a floating reference to a new signature #GVariant instance
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_is_signature:
* @string: a normal C nul-terminated string
- * @returns: %TRUE if @string is a D-Bus type signature
*
* Determines if a given string is a valid D-Bus type signature. You
* should ensure that a string is a valid D-Bus type signature before
* D-Bus type signatures consist of zero or more definite #GVariantType
* strings in sequence.
*
+ * Returns: %TRUE if @string is a D-Bus type signature
+ *
* Since: 2.24
**/
gboolean
* @value: a string #GVariant instance
* @length: (allow-none) (default 0) (out): a pointer to a #gsize,
* to store the length
- * @returns: (transfer none): the constant string, utf8 encoded
*
* Returns the string value of a #GVariant instance with a string
* type. This includes the types %G_VARIANT_TYPE_STRING,
*
* The return value remains valid as long as @value exists.
*
+ * Returns: (transfer none): the constant string, utf8 encoded
+ *
* Since: 2.24
**/
const gchar *
* g_variant_dup_string:
* @value: a string #GVariant instance
* @length: (out): a pointer to a #gsize, to store the length
- * @returns: (transfer full): a newly allocated string, utf8 encoded
*
* Similar to g_variant_get_string() except that instead of returning
* a constant string, the string is duplicated.
*
* The return value must be freed using g_free().
*
+ * Returns: (transfer full): a newly allocated string, utf8 encoded
+ *
* Since: 2.24
**/
gchar *
* g_variant_new_strv:
* @strv: (array length=length) (element-type utf8): an array of strings
* @length: the length of @strv, or -1
- * @returns: (transfer none): a new floating #GVariant instance
*
* Constructs an array of strings #GVariant from the given array of
* strings.
*
* If @length is -1 then @strv is %NULL-terminated.
*
+ * Returns: (transfer none): a new floating #GVariant instance
+ *
* Since: 2.24
**/
GVariant *
* g_variant_get_strv:
* @value: an array of strings #GVariant
* @length: (out) (allow-none): the length of the result, or %NULL
- * @returns: (array length=length zero-terminated=1) (transfer container): an array of constant
- * strings
*
* Gets the contents of an array of strings #GVariant. This call
* makes a shallow copy; the return result should be released with
* For an empty array, @length will be set to 0 and a pointer to a
* %NULL pointer will be returned.
*
+ * Returns: (array length=length zero-terminated=1) (transfer container): an array of constant strings
+ *
* Since: 2.24
**/
const gchar **
* g_variant_dup_strv:
* @value: an array of strings #GVariant
* @length: (out) (allow-none): the length of the result, or %NULL
- * @returns: (array length=length zero-terminated=1) (transfer full): an array of strings
*
* Gets the contents of an array of strings #GVariant. This call
* makes a deep copy; the return result should be released with
* For an empty array, @length will be set to 0 and a pointer to a
* %NULL pointer will be returned.
*
+ * Returns: (array length=length zero-terminated=1) (transfer full): an array of strings
+ *
* Since: 2.24
**/
gchar **
* g_variant_new_objv:
* @strv: (array length=length) (element-type utf8): an array of strings
* @length: the length of @strv, or -1
- * @returns: (transfer none): a new floating #GVariant instance
*
* Constructs an array of object paths #GVariant from the given array of
* strings.
*
* If @length is -1 then @strv is %NULL-terminated.
*
+ * Returns: (transfer none): a new floating #GVariant instance
+ *
* Since: 2.30
**/
GVariant *
* g_variant_get_objv:
* @value: an array of object paths #GVariant
* @length: (out) (allow-none): the length of the result, or %NULL
- * @returns: (array length=length zero-terminated=1) (transfer container): an array of constant
- * strings
*
* Gets the contents of an array of object paths #GVariant. This call
* makes a shallow copy; the return result should be released with
* For an empty array, @length will be set to 0 and a pointer to a
* %NULL pointer will be returned.
*
+ * Returns: (array length=length zero-terminated=1) (transfer container): an array of constant strings
+ *
* Since: 2.30
**/
const gchar **
* g_variant_dup_objv:
* @value: an array of object paths #GVariant
* @length: (out) (allow-none): the length of the result, or %NULL
- * @returns: (array length=length zero-terminated=1) (transfer full): an array of strings
*
* Gets the contents of an array of object paths #GVariant. This call
* makes a deep copy; the return result should be released with
* For an empty array, @length will be set to 0 and a pointer to a
* %NULL pointer will be returned.
*
+ * Returns: (array length=length zero-terminated=1) (transfer full): an array of strings
+ *
* Since: 2.30
**/
gchar **
* g_variant_new_bytestring:
* @string: (array zero-terminated=1) (element-type guint8): a normal
* nul-terminated string in no particular encoding
- * @returns: (transfer none): a floating reference to a new bytestring #GVariant instance
*
* Creates an array-of-bytes #GVariant with the contents of @string.
* This function is just like g_variant_new_string() except that the
* The nul terminator character at the end of the string is stored in
* the array.
*
+ * Returns: (transfer none): a floating reference to a new bytestring #GVariant instance
+ *
* Since: 2.26
**/
GVariant *
/**
* g_variant_get_bytestring:
* @value: an array-of-bytes #GVariant instance
- * @returns: (transfer none) (array zero-terminated=1) (element-type guint8):
- * the constant string
*
* Returns the string value of a #GVariant instance with an
* array-of-bytes type. The string has no particular encoding.
*
* The return value remains valid as long as @value exists.
*
+ * Returns: (transfer none) (array zero-terminated=1) (element-type guint8):
+ * the constant string
+ *
* Since: 2.26
**/
const gchar *
* @value: an array-of-bytes #GVariant instance
* @length: (out) (allow-none) (default NULL): a pointer to a #gsize, to store
* the length (not including the nul terminator)
- * @returns: (transfer full) (array zero-terminated=1 length=length)
- * (element-type guint8): a newly allocated string
*
* Similar to g_variant_get_bytestring() except that instead of
* returning a constant string, the string is duplicated.
*
* The return value must be freed using g_free().
*
+ * Returns: (transfer full) (array zero-terminated=1 length=length) (element-type guint8):
+ * a newly allocated string
+ *
* Since: 2.26
**/
gchar *
* g_variant_new_bytestring_array:
* @strv: (array length=length): an array of strings
* @length: the length of @strv, or -1
- * @returns: (transfer none): a new floating #GVariant instance
*
* Constructs an array of bytestring #GVariant from the given array of
* strings.
*
* If @length is -1 then @strv is %NULL-terminated.
*
+ * Returns: (transfer none): a new floating #GVariant instance
+ *
* Since: 2.26
**/
GVariant *
* g_variant_get_bytestring_array:
* @value: an array of array of bytes #GVariant ('aay')
* @length: (out) (allow-none): the length of the result, or %NULL
- * @returns: (array length=length) (transfer container): an array of constant strings
*
* Gets the contents of an array of array of bytes #GVariant. This call
* makes a shallow copy; the return result should be released with
* For an empty array, @length will be set to 0 and a pointer to a
* %NULL pointer will be returned.
*
+ * Returns: (array length=length) (transfer container): an array of constant strings
+ *
* Since: 2.26
**/
const gchar **
* g_variant_dup_bytestring_array:
* @value: an array of array of bytes #GVariant ('aay')
* @length: (out) (allow-none): the length of the result, or %NULL
- * @returns: (array length=length) (transfer full): an array of strings
*
* Gets the contents of an array of array of bytes #GVariant. This call
* makes a deep copy; the return result should be released with
* For an empty array, @length will be set to 0 and a pointer to a
* %NULL pointer will be returned.
*
+ * Returns: (array length=length) (transfer full): an array of strings
+ *
* Since: 2.26
**/
gchar **
/**
* g_variant_get_type:
* @value: a #GVariant
- * @returns: a #GVariantType
*
* Determines the type of @value.
*
* The return value is valid for the lifetime of @value and must not
* be freed.
*
+ * Returns: a #GVariantType
+ *
* Since: 2.24
**/
const GVariantType *
/**
* g_variant_get_type_string:
* @value: a #GVariant
- * @returns: the type string for the type of @value
*
* Returns the type string of @value. Unlike the result of calling
* g_variant_type_peek_string(), this string is nul-terminated. This
* string belongs to #GVariant and must not be freed.
*
+ * Returns: the type string for the type of @value
+ *
* Since: 2.24
**/
const gchar *
* g_variant_is_of_type:
* @value: a #GVariant instance
* @type: a #GVariantType
- * @returns: %TRUE if the type of @value matches @type
*
* Checks if a value has a type matching the provided type.
*
+ * Returns: %TRUE if the type of @value matches @type
+ *
* Since: 2.24
**/
gboolean
/**
* g_variant_is_container:
* @value: a #GVariant instance
- * @returns: %TRUE if @value is a container
*
* Checks if @value is a container.
+ *
+ * Returns: %TRUE if @value is a container
+ *
+ * Since: 2.24
*/
gboolean
g_variant_is_container (GVariant *value)
/**
* g_variant_classify:
* @value: a #GVariant
- * @returns: the #GVariantClass of @value
*
* Classifies @value according to its top-level type.
*
+ * Returns: the #GVariantClass of @value
+ *
* Since: 2.24
**/
/**
}
/* Pretty printer {{{1 */
-/* This function is not introspectable because if @string is NULL,
+/* This function is not introspectable because if @string is NULL,
@returns is (transfer full), otherwise it is (transfer none), which
is not supported by GObjectIntrospection */
/**
* @string: (allow-none) (default NULL): a #GString, or %NULL
* @type_annotate: %TRUE if type information should be included in
* the output
- * @returns: a #GString containing the string
*
* Behaves as g_variant_print(), but operates on a #GString.
*
* If @string is non-%NULL then it is appended to and returned. Else,
* a new empty #GString is allocated and it is returned.
*
+ * Returns: a #GString containing the string
+ *
* Since: 2.24
**/
GString *
* @value: a #GVariant
* @type_annotate: %TRUE if type information should be included in
* the output
- * @returns: (transfer full): a newly-allocated string holding the result.
*
* Pretty-prints @value in the format understood by g_variant_parse().
*
*
* If @type_annotate is %TRUE, then type information is included in
* the output.
+ *
+ * Returns: (transfer full): a newly-allocated string holding the result.
+ *
+ * Since: 2.24
*/
gchar *
g_variant_print (GVariant *value,
/**
* g_variant_hash:
* @value: (type GVariant): a basic #GVariant value as a #gconstpointer
- * @returns: a hash value corresponding to @value
*
* Generates a hash value for a #GVariant instance.
*
* The type of @value is #gconstpointer only to allow use of this
* function with #GHashTable. @value must be a #GVariant.
*
+ * Returns: a hash value corresponding to @value
+ *
* Since: 2.24
**/
guint
* g_variant_equal:
* @one: (type GVariant): a #GVariant instance
* @two: (type GVariant): a #GVariant instance
- * @returns: %TRUE if @one and @two are equal
*
* Checks if @one and @two have the same type and value.
*
* The types of @one and @two are #gconstpointer only to allow use of
* this function with #GHashTable. They must each be a #GVariant.
*
+ * Returns: %TRUE if @one and @two are equal
+ *
* Since: 2.24
**/
gboolean
* g_variant_compare:
* @one: (type GVariant): a basic-typed #GVariant instance
* @two: (type GVariant): a #GVariant instance of the same type
- * @returns: negative value if a < b;
- * zero if a = b;
- * positive value if a > b.
*
* Compares @one and @two.
*
* If you only require an equality comparison, g_variant_equal() is more
* general.
*
+ * Returns: negative value if a < b;
+ * zero if a = b;
+ * positive value if a > b.
+ *
* Since: 2.26
**/
gint
switch (g_variant_classify (a))
{
+ case G_VARIANT_CLASS_BOOLEAN:
+ return g_variant_get_boolean (a) -
+ g_variant_get_boolean (b);
+
case G_VARIANT_CLASS_BYTE:
return ((gint) g_variant_get_byte (a)) -
((gint) g_variant_get_byte (b));
/**
* g_variant_iter_new:
* @value: a container #GVariant
- * @returns: (transfer full): a new heap-allocated #GVariantIter
*
* Creates a heap-allocated #GVariantIter for iterating over the items
* in @value.
* A reference is taken to @value and will be released only when
* g_variant_iter_free() is called.
*
+ * Returns: (transfer full): a new heap-allocated #GVariantIter
+ *
* Since: 2.24
**/
GVariantIter *
* g_variant_iter_init: (skip)
* @iter: a pointer to a #GVariantIter
* @value: a container #GVariant
- * @returns: the number of items in @value
*
* Initialises (without allocating) a #GVariantIter. @iter may be
* completely uninitialised prior to this call; its old value is
* The iterator remains valid for as long as @value exists, and need not
* be freed in any way.
*
+ * Returns: the number of items in @value
+ *
* Since: 2.24
**/
gsize
/**
* g_variant_iter_copy:
* @iter: a #GVariantIter
- * @returns: (transfer full): a new heap-allocated #GVariantIter
*
* Creates a new heap-allocated #GVariantIter to iterate over the
* container that was being iterated over by @iter. Iteration begins on
* A reference is taken to the container that @iter is iterating over
* and will be releated only when g_variant_iter_free() is called.
*
+ * Returns: (transfer full): a new heap-allocated #GVariantIter
+ *
* Since: 2.24
**/
GVariantIter *
/**
* g_variant_iter_n_children:
* @iter: a #GVariantIter
- * @returns: the number of children in the container
*
* Queries the number of child items in the container that we are
* iterating over. This is the total number of items -- not the number
*
* This function might be useful for preallocation of arrays.
*
+ * Returns: the number of children in the container
+ *
* Since: 2.24
**/
gsize
/**
* g_variant_iter_next_value:
* @iter: a #GVariantIter
- * @returns: (allow-none) (transfer full): a #GVariant, or %NULL
*
* Gets the next item in the container. If no more items remain then
* %NULL is returned.
* </programlisting>
* </example>
*
+ * Returns: (allow-none) (transfer full): a #GVariant, or %NULL
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_builder_new:
* @type: a container type
- * @returns: (transfer full): a #GVariantBuilder
*
* Allocates and initialises a new #GVariantBuilder.
*
* the stack of the calling function and initialise it with
* g_variant_builder_init().
*
+ * Returns: (transfer full): a #GVariantBuilder
+ *
* Since: 2.24
**/
GVariantBuilder *
/**
* g_variant_builder_ref:
* @builder: a #GVariantBuilder allocated by g_variant_builder_new()
- * @returns: (transfer full): a new reference to @builder
*
* Increases the reference count on @builder.
*
* Don't call this on stack-allocated #GVariantBuilder instances or bad
* things will happen.
*
+ * Returns: (transfer full): a new reference to @builder
+ *
* Since: 2.24
**/
GVariantBuilder *
/**
* g_variant_builder_end:
* @builder: a #GVariantBuilder
- * @returns: (transfer none): a new, floating, #GVariant
*
* Ends the builder process and returns the constructed value.
*
* have been added; in this case it is impossible to infer the type of
* the empty array.
*
+ * Returns: (transfer none): a new, floating, #GVariant
+ *
* Since: 2.24
**/
GVariant *
* or %NULL
* @endptr: (allow-none) (default NULL): location to store the end pointer,
* or %NULL
- * @returns: %TRUE if there was a valid format string
*
* Checks the string pointed to by @string for starting with a properly
* formed #GVariant varargs format string. If no valid format string is
* See the section on <link linkend='gvariant-format-strings'>GVariant
* Format Strings</link>.
*
+ * Returns: %TRUE if there was a valid format string
+ *
* Since: 2.24
*/
gboolean
return TRUE;
}
+/**
+ * g_variant_check_format_string:
+ * @value: a #GVariant
+ * @format_string: a valid #GVariant format string
+ * @copy_only: %TRUE to ensure the format string makes deep copies
+ *
+ * Checks if calling g_variant_get() with @format_string on @value would
+ * be valid from a type-compatibility standpoint. @format_string is
+ * assumed to be a valid format string (from a syntactic standpoint).
+ *
+ * If @copy_only is %TRUE then this function additionally checks that it
+ * would be safe to call g_variant_unref() on @value immediately after
+ * the call to g_variant_get() without invalidating the result. This is
+ * only possible if deep copies are made (ie: there are no pointers to
+ * the data inside of the soon-to-be-freed #GVariant instance). If this
+ * check fails then a g_critical() is printed and %FALSE is returned.
+ *
+ * This function is meant to be used by functions that wish to provide
+ * varargs accessors to #GVariant values of uncertain values (eg:
+ * g_variant_lookup() or g_menu_model_get_item_attribute()).
+ *
+ * Returns: %TRUE if @format_string is safe to use
+ *
+ * Since: 2.34
+ */
+gboolean
+g_variant_check_format_string (GVariant *value,
+ const gchar *format_string,
+ gboolean copy_only)
+{
+ const gchar *original_format = format_string;
+ const gchar *type_string;
+
+ /* Interesting factoid: assuming a format string is valid, it can be
+ * converted to a type string by removing all '@' '&' and '^'
+ * characters.
+ *
+ * Instead of doing that, we can just skip those characters when
+ * comparing it to the type string of @value.
+ *
+ * For the copy-only case we can just drop the '&' from the list of
+ * characters to skip over. A '&' will never appear in a type string
+ * so we know that it won't be possible to return %TRUE if it is in a
+ * format string.
+ */
+ type_string = g_variant_get_type_string (value);
+
+ while (*type_string || *format_string)
+ {
+ gchar format = *format_string++;
+
+ switch (format)
+ {
+ case '&':
+ if G_UNLIKELY (copy_only)
+ {
+ /* for the love of all that is good, please don't mark this string for translation... */
+ g_critical ("g_variant_check_format_string() is being called by a function with a GVariant varargs "
+ "interface to validate the passed format string for type safety. The passed format "
+ "(%s) contains a '&' character which would result in a pointer being returned to the "
+ "data inside of a GVariant instance that may no longer exist by the time the function "
+ "returns. Modify your code to use a format string without '&'.", original_format);
+ return FALSE;
+ }
+
+ /* fall through */
+ case '^':
+ case '@':
+ /* ignore these 2 (or 3) */
+ continue;
+
+ case '?':
+ /* attempt to consume one of 'bynqiuxthdsog' */
+ {
+ char s = *type_string++;
+
+ if (s == '\0' || strchr ("bynqiuxthdsog", s) == NULL)
+ return FALSE;
+ }
+ continue;
+
+ case 'r':
+ /* ensure it's a tuple */
+ if (*type_string != '(')
+ return FALSE;
+
+ /* fall through */
+ case '*':
+ /* consume a full type string for the '*' or 'r' */
+ if (!g_variant_type_string_scan (type_string, NULL, &type_string))
+ return FALSE;
+
+ continue;
+
+ default:
+ /* attempt to consume exactly one character equal to the format */
+ if (format != *type_string++)
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
/*< private >
* g_variant_format_string_scan_type:
* @string: a string that may be prefixed with a format string
* or %NULL
* @endptr: (allow-none) (default NULL): location to store the end pointer,
* or %NULL
- * @returns: (allow-none): a #GVariantType if there was a valid format string
*
* If @string starts with a valid format string then this function will
* return the type that the format string corresponds to. Otherwise
* This function is otherwise exactly like
* g_variant_format_string_scan().
*
+ * Returns: (allow-none): a #GVariantType if there was a valid format string
+ *
* Since: 2.24
*/
GVariantType *
* g_variant_new: (skip)
* @format_string: a #GVariant format string
* @...: arguments, as per @format_string
- * @returns: a new floating #GVariant instance
*
* Creates a new #GVariant instance.
*
* 'r'; in essence, a new #GVariant must always be constructed by this
* function (and not merely passed through it unmodified).
*
+ * Returns: a new floating #GVariant instance
+ *
* Since: 2.24
**/
GVariant *
* @endptr: (allow-none) (default NULL): location to store the end pointer,
* or %NULL
* @app: a pointer to a #va_list
- * @returns: a new, usually floating, #GVariant
*
* This function is intended to be used by libraries based on
* #GVariant that want to provide g_variant_new()-like functionality
* result. This can also be done by adding the result to a container,
* or by passing it to another g_variant_new() call.
*
+ * Returns: a new, usually floating, #GVariant
+ *
* Since: 2.24
**/
GVariant *
* Please note that the syntax of the format string is very likely to be
* extended in the future.
*
+ * @format_string determines the C types that are used for unpacking
+ * the values and also determines if the values are copied or borrowed,
+ * see the section on
+ * <link linkend='gvariant-format-strings-pointers'>GVariant Format Strings</link>.
+ *
* Since: 2.24
**/
void
* g_variant_new_va() and g_variant_get_va() within a single actual
* varargs call by the user.
*
+ * @format_string determines the C types that are used for unpacking
+ * the values and also determines if the values are copied or borrowed,
+ * see the section on
+ * <link linkend='gvariant-format-strings-pointers'>GVariant Format Strings</link>.
+ *
* Since: 2.24
**/
void
* essentially a combination of g_variant_get_child_value() and
* g_variant_get().
*
+ * @format_string determines the C types that are used for unpacking
+ * the values and also determines if the values are copied or borrowed,
+ * see the section on
+ * <link linkend='gvariant-format-strings-pointers'>GVariant Format Strings</link>.
+ *
* Since: 2.24
**/
void
* @iter: a #GVariantIter
* @format_string: a GVariant format string
* @...: the arguments to unpack the value into
- * @returns: %TRUE if a value was unpacked, or %FALSE if there as no
- * value
*
* Gets the next item in the container and unpacks it into the variable
* argument list according to @format_string, returning %TRUE.
* For a solution that is likely to be more convenient to C programmers
* when dealing with loops, see g_variant_iter_loop().
*
+ * @format_string determines the C types that are used for unpacking
+ * the values and also determines if the values are copied or borrowed,
+ * see the section on
+ * <link linkend='gvariant-format-strings-pointers'>GVariant Format Strings</link>.
+ *
+ * Returns: %TRUE if a value was unpacked, or %FALSE if there as no value
+ *
* Since: 2.24
**/
gboolean
* @iter: a #GVariantIter
* @format_string: a GVariant format string
* @...: the arguments to unpack the value into
- * @returns: %TRUE if a value was unpacked, or %FALSE if there as no
- * value
*
* Gets the next item in the container and unpacks it into the variable
* argument list according to @format_string, returning %TRUE.
* function with a string constant for the format string and the same
* string constant must be used each time. Mixing calls to this
* function and g_variant_iter_next() or g_variant_iter_next_value() on
- * the same iterator is not recommended.
+ * the same iterator causes undefined behavior.
+ *
+ * If you break out of a such a while loop using g_variant_iter_loop() then
+ * you must free or unreference all the unpacked values as you would with
+ * g_variant_get(). Failure to do so will cause a memory leak.
*
* See the section on <link linkend='gvariant-format-strings'>GVariant
* Format Strings</link>.
* g_variant_get_type_string (value));
*
* /<!-- -->* no need to free 'key' and 'value' here *<!-- -->/
+ * /<!-- -->* unless breaking out of this loop *<!-- -->/
* }
* }
* </programlisting>
* types, use the '&' prefix to avoid allocating any memory at all (and
* thereby avoiding the need to free anything as well).
*
+ * @format_string determines the C types that are used for unpacking
+ * the values and also determines if the values are copied or borrowed,
+ * see the section on
+ * <link linkend='gvariant-format-strings-pointers'>GVariant Format Strings</link>.
+ *
+ * Returns: %TRUE if a value was unpacked, or %FALSE if there was no
+ * value
+ *
* Since: 2.24
**/
gboolean
/**
* g_variant_get_normal_form:
* @value: a #GVariant
- * @returns: (transfer full): a trusted #GVariant
*
* Gets a #GVariant instance that has the same value as @value and is
* trusted to be in normal form.
* data from untrusted sources and you want to ensure your serialised
* output is definitely in normal form.
*
+ * Returns: (transfer full): a trusted #GVariant
+ *
* Since: 2.24
**/
GVariant *
/**
* g_variant_byteswap:
* @value: a #GVariant
- * @returns: (transfer full): the byteswapped form of @value
*
* Performs a byteswapping operation on the contents of @value. The
* result is that all multi-byte numeric data contained in @value is
*
* The returned value is always in normal form and is marked as trusted.
*
+ * Returns: (transfer full): the byteswapped form of @value
+ *
* Since: 2.24
**/
GVariant *
{
GVariantSerialised serialised;
GVariant *trusted;
- GBuffer *buffer;
+ GBytes *bytes;
trusted = g_variant_get_normal_form (value);
serialised.type_info = g_variant_get_type_info (trusted);
g_variant_serialised_byteswap (serialised);
- buffer = g_buffer_new_take_data (serialised.data, serialised.size);
- new = g_variant_new_from_buffer (g_variant_get_type (value), buffer, TRUE);
- g_buffer_unref (buffer);
+ bytes = g_bytes_new_take (serialised.data, serialised.size);
+ new = g_variant_new_from_bytes (g_variant_get_type (value), bytes, TRUE);
+ g_bytes_unref (bytes);
}
else
/* contains no multi-byte data */
* @trusted: %TRUE if @data is definitely in normal form
* @notify: (scope async): function to call when @data is no longer needed
* @user_data: data for @notify
- * @returns: (transfer none): a new floating #GVariant of type @type
*
* Creates a new #GVariant instance from serialised data.
*
* should set trusted to %FALSE if @data is read from the network, a
* file in the user's home directory, etc.
*
+ * If @data was not stored in this machine's native endianness, any multi-byte
+ * numeric values in the returned variant will also be in non-native
+ * endianness. g_variant_byteswap() can be used to recover the original values.
+ *
* @notify will be called with @user_data when @data is no longer
* needed. The exact time of this call is unspecified and might even be
* before this function returns.
*
+ * Returns: (transfer none): a new floating #GVariant of type @type
+ *
* Since: 2.24
**/
GVariant *
gpointer user_data)
{
GVariant *value;
- GBuffer *buffer;
+ GBytes *bytes;
g_return_val_if_fail (g_variant_type_is_definite (type), NULL);
g_return_val_if_fail (data != NULL || size == 0, NULL);
if (notify)
- buffer = g_buffer_new_from_pointer (data, size, notify, user_data);
+ bytes = g_bytes_new_with_free_func (data, size, notify, user_data);
else
- buffer = g_buffer_new_from_static_data (data, size);
+ bytes = g_bytes_new_static (data, size);
- value = g_variant_new_from_buffer (type, buffer, trusted);
- g_buffer_unref (buffer);
+ value = g_variant_new_from_bytes (type, bytes, trusted);
+ g_bytes_unref (bytes);
return value;
}