* @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,
/**
* 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 *
* @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.
* @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
* @elements: a pointer to the fixed array of contiguous elements
* @n_elements: the number of elements
* @element_size: the size of each element
- * @returns: (transfer none): a floating reference to a new array #GVariant instance
*
* Provides access to the serialised data for an array of fixed-sized
* items.
* @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_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_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
/**
* 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 *
* 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
* 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 *
* @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().
*
+ * 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 was no
- * value
*
* Gets the next item in the container and unpacks it into the variable
* argument list according to @format_string, returning %TRUE.
* types, use the '&' prefix to avoid allocating any memory at all (and
* thereby avoiding the need to free anything as well).
*
+ * 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 *
* @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.
*
* 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 *
* @string: a pointer to any string
* @limit: (allow-none): the end of @string, or %NULL
* @endptr: (out) (allow-none): location to store the end pointer, or %NULL
- * @returns: %TRUE if a valid type string was found
*
* Scan for a single complete and valid GVariant type string in @string.
* The memory pointed to by @limit (or bytes beyond it) is never
* For the simple case of checking if a string is a valid type string,
* see g_variant_type_string_is_valid().
*
+ * Returns: %TRUE if a valid type string was found
+ *
* Since: 2.24
**/
gboolean
/**
* g_variant_type_string_is_valid:
* @type_string: a pointer to any string
- * @returns: %TRUE if @type_string is exactly one valid type string
*
* Checks if @type_string is a valid GVariant type string. This call is
* equivalent to calling g_variant_type_string_scan() and confirming
* that the following character is a nul terminator.
*
+ * Returns: %TRUE if @type_string is exactly one valid type string
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_copy:
* @type: a #GVariantType
- * @returns: (transfer full): a new #GVariantType
*
* Makes a copy of a #GVariantType. It is appropriate to call
* g_variant_type_free() on the return value. @type may not be %NULL.
*
+ * Returns: (transfer full): a new #GVariantType
+ *
* Since 2.24
**/
GVariantType *
/**
* g_variant_type_new:
* @type_string: a valid GVariant type string
- * @returns: (transfer full): a new #GVariantType
*
* Creates a new #GVariantType corresponding to the type string given
* by @type_string. It is appropriate to call g_variant_type_free() on
* It is a programmer error to call this function with an invalid type
* string. Use g_variant_type_string_is_valid() if you are unsure.
*
+ * Returns: (transfer full): a new #GVariantType
+ *
* Since: 2.24
*/
GVariantType *
/**
* g_variant_type_get_string_length:
* @type: a #GVariantType
- * @returns: the length of the corresponding type string
*
* Returns the length of the type string corresponding to the given
* @type. This function must be used to determine the valid extent of
* the memory region returned by g_variant_type_peek_string().
*
+ * Returns: the length of the corresponding type string
+ *
* Since 2.24
**/
gsize
/**
* g_variant_type_peek_string: (skip)
* @type: a #GVariantType
- * @returns: the corresponding type string (not nul-terminated)
*
* Returns the type string corresponding to the given @type. The
* result is not nul-terminated; in order to determine its length you
*
* To get a nul-terminated string, see g_variant_type_dup_string().
*
+ * Returns: the corresponding type string (not nul-terminated)
+ *
* Since 2.24
**/
const gchar *
/**
* g_variant_type_dup_string:
* @type: a #GVariantType
- * @returns: (transfer full): the corresponding type string
*
* Returns a newly-allocated copy of the type string corresponding to
* @type. The returned string is nul-terminated. It is appropriate to
* call g_free() on the return value.
*
+ * Returns: (transfer full): the corresponding type string
+ *
* Since 2.24
**/
gchar *
/**
* g_variant_type_is_definite:
* @type: a #GVariantType
- * @returns: %TRUE if @type is definite
*
* Determines if the given @type is definite (ie: not indefinite).
*
* indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in
* %FALSE being returned.
*
+ * Returns: %TRUE if @type is definite
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_is_container:
* @type: a #GVariantType
- * @returns: %TRUE if @type is a container type
*
* Determines if the given @type is a container type.
*
* definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for
* example.
*
+ * Returns: %TRUE if @type is a container type
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_is_basic:
* @type: a #GVariantType
- * @returns: %TRUE if @type is a basic type
*
* Determines if the given @type is a basic type.
*
* This function returns %FALSE for all indefinite types except
* %G_VARIANT_TYPE_BASIC.
*
+ * Returns: %TRUE if @type is a basic type
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_is_maybe:
* @type: a #GVariantType
- * @returns: %TRUE if @type is a maybe type
*
* Determines if the given @type is a maybe type. This is true if the
* type string for @type starts with an 'm'.
* definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for
* example.
*
+ * Returns: %TRUE if @type is a maybe type
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_is_array:
* @type: a #GVariantType
- * @returns: %TRUE if @type is an array type
*
* Determines if the given @type is an array type. This is true if the
* type string for @type starts with an 'a'.
* definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for
* example.
*
+ * Returns: %TRUE if @type is an array type
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_is_tuple:
* @type: a #GVariantType
- * @returns: %TRUE if @type is a tuple type
*
* Determines if the given @type is a tuple type. This is true if the
* type string for @type starts with a '(' or if @type is
* definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for
* example.
*
+ * Returns: %TRUE if @type is a tuple type
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_is_dict_entry:
* @type: a #GVariantType
- * @returns: %TRUE if @type is a dictionary entry type
*
* Determines if the given @type is a dictionary entry type. This is
* true if the type string for @type starts with a '{'.
* definite subtype is a dictionary entry type --
* %G_VARIANT_TYPE_DICT_ENTRY, for example.
*
+ * Returns: %TRUE if @type is a dictionary entry type
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_is_variant:
* @type: a #GVariantType
- * @returns: %TRUE if @type is the variant type
*
* Determines if the given @type is the variant type.
*
+ * Returns: %TRUE if @type is the variant type
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_hash:
* @type: (type GVariantType): a #GVariantType
- * @returns: the hash value
*
* Hashes @type.
*
* #GHashTable without function pointer casting. A valid
* #GVariantType must be provided.
*
+ * Returns: the hash value
+ *
* Since 2.24
**/
guint
* g_variant_type_equal:
* @type1: (type GVariantType): a #GVariantType
* @type2: (type GVariantType): a #GVariantType
- * @returns: %TRUE if @type1 and @type2 are exactly equal
*
* Compares @type1 and @type2 for equality.
*
* allow use with #GHashTable without function pointer casting. For
* both arguments, a valid #GVariantType must be provided.
*
+ * Returns: %TRUE if @type1 and @type2 are exactly equal
+ *
* Since 2.24
**/
gboolean
* g_variant_type_is_subtype_of:
* @type: a #GVariantType
* @supertype: a #GVariantType
- * @returns: %TRUE if @type is a subtype of @supertype
*
* Checks if @type is a subtype of @supertype.
*
* types are considered to be subtypes of themselves. Aside from that,
* only indefinite types can have subtypes.
*
+ * Returns: %TRUE if @type is a subtype of @supertype
+ *
* Since 2.24
**/
gboolean
/**
* g_variant_type_element:
* @type: an array or maybe #GVariantType
- * @returns: (transfer none): the element type of @type
*
* Determines the element type of an array or maybe type.
*
* This function may only be used with array or maybe types.
*
+ * Returns: (transfer none): the element type of @type
+ *
* Since 2.24
**/
const GVariantType *
/**
* g_variant_type_first:
* @type: a tuple or dictionary entry #GVariantType
- * @returns: (transfer none): the first item type of @type, or %NULL
*
* Determines the first item type of a tuple or dictionary entry
* type.
* This call, together with g_variant_type_next() provides an iterator
* interface over tuple and dictionary entry types.
*
+ * Returns: (transfer none): the first item type of @type, or %NULL
+ *
* Since 2.24
**/
const GVariantType *
/**
* g_variant_type_next:
* @type: a #GVariantType from a previous call
- * @returns: (transfer none): the next #GVariantType after @type, or %NULL
*
* Determines the next item type of a tuple or dictionary entry
* type.
*
* For tuples, %NULL is returned when @type is the last item in a tuple.
*
+ * Returns: (transfer none): the next #GVariantType after @type, or %NULL
+ *
* Since 2.24
**/
const GVariantType *
/**
* g_variant_type_n_items:
* @type: a tuple or dictionary entry #GVariantType
- * @returns: the number of items in @type
*
* Determines the number of items contained in a tuple or
* dictionary entry type.
* In the case of a dictionary entry type, this function will always
* return 2.
*
+ * Returns: the number of items in @type
+ *
* Since 2.24
**/
gsize
/**
* g_variant_type_key:
* @type: a dictionary entry #GVariantType
- * @returns: (transfer none): the key type of the dictionary entry
*
* Determines the key type of a dictionary entry type.
*
* than the additional restriction, this call is equivalent to
* g_variant_type_first().
*
+ * Returns: (transfer none): the key type of the dictionary entry
+ *
* Since 2.24
**/
const GVariantType *
/**
* g_variant_type_value:
* @type: a dictionary entry #GVariantType
- * @returns: (transfer none): the value type of the dictionary entry
*
* Determines the value type of a dictionary entry type.
*
* This function may only be used with a dictionary entry type.
*
+ * Returns: (transfer none): the value type of the dictionary entry
+ *
* Since 2.24
**/
const GVariantType *
* g_variant_type_new_tuple:
* @items: (array length=length): an array of #GVariantTypes, one for each item
* @length: the length of @items, or -1
- * @returns: (transfer full): a new tuple #GVariantType
*
* Constructs a new tuple type, from @items.
*
*
* It is appropriate to call g_variant_type_free() on the return value.
*
+ * Returns: (transfer full): a new tuple #GVariantType
+ *
* Since 2.24
**/
static GVariantType *
/**
* g_variant_type_new_array:
* @element: a #GVariantType
- * @returns: (transfer full): a new array #GVariantType
*
* Constructs the type corresponding to an array of elements of the
* type @type.
*
* It is appropriate to call g_variant_type_free() on the return value.
*
+ * Returns: (transfer full): a new array #GVariantType
+ *
* Since 2.24
**/
GVariantType *
/**
* g_variant_type_new_maybe:
* @element: a #GVariantType
- * @returns: (transfer full): a new maybe #GVariantType
*
* Constructs the type corresponding to a maybe instance containing
* type @type or Nothing.
*
* It is appropriate to call g_variant_type_free() on the return value.
*
+ * Returns: (transfer full): a new maybe #GVariantType
+ *
* Since 2.24
**/
GVariantType *
* g_variant_type_new_dict_entry:
* @key: a basic #GVariantType
* @value: a #GVariantType
- * @returns: (transfer full): a new dictionary entry #GVariantType
*
* Constructs the type corresponding to a dictionary entry with a key
* of type @key and a value of type @value.
*
* It is appropriate to call g_variant_type_free() on the return value.
*
+ * Returns: (transfer full): a new dictionary entry #GVariantType
+ *
* Since 2.24
**/
GVariantType *