// Code generated by cmd/cgo; DO NOT EDIT.

//line /home/josie/.cache/paru/clone/wiiudownloader/src/pkg/mod/github.com/gotk3/gotk3@v0.6.5-0.20240618185848-ff349ae13f56/glib/gvariant.go:1:1
//GVariant : GVariant — strongly typed value datatype
// https://developer.gnome.org/glib/2.26/glib-GVariant.html

package glib

// #include "gvariant.go.h"
// #include "glib.go.h"
import _ "unsafe"

import (
	"errors"
	"fmt"
	"runtime"
	"unsafe"
)

/*
 * GVariant
 */

// IVariant is an interface type implemented by Variant and all types which embed
// an Variant.  It is meant to be used as a type for function arguments which
// require GVariants or any subclasses thereof.
type IVariant interface {
	ToGVariant() * /*line :25:16*/_Ctype_GVariant /*line :25:26*/
	ToVariant() *Variant
}

// A Variant is a representation of GLib's GVariant.
type Variant struct {
	GVariant * /*line :31:12*/_Ctype_GVariant /*line :31:22*/
}

// ToGVariant exposes the underlying *C.GVariant type for this Variant,
// necessary to implement IVariant.
func (v *Variant) ToGVariant() * /*line :36:33*/_Ctype_GVariant /*line :36:43*/ {
	if v == nil {
		return nil
	}
	return v.native()
}

// ToVariant returns this Variant, necessary to implement IVariant.
func (v *Variant) ToVariant() *Variant {
	return v
}

// native returns a pointer to the underlying GVariant.
func (v *Variant) native() * /*line :49:29*/_Ctype_GVariant /*line :49:39*/ {
	if v == nil || v.GVariant == nil {
		return nil
	}
	return v.GVariant
}

// Native returns a pointer to the underlying GVariant.
func (v *Variant) Native() uintptr {
	return uintptr(unsafe.Pointer(v.native()))
}

// newVariant wraps a native GVariant.
// Does NOT handle reference counting! Use takeVariant() to take ownership of values.
func newVariant(p * /*line :63:20*/_Ctype_GVariant /*line :63:30*/) *Variant {
	if p == nil {
		return nil
	}
	return &Variant{GVariant: p}
}

// TakeVariant wraps a unsafe.Pointer as a glib.Variant, taking ownership of it.
// This function is exported for visibility in other gotk3 packages and
// is not meant to be used by applications.
func TakeVariant(ptr unsafe.Pointer) *Variant {
	return takeVariant(func() *_Ctype_struct__GVariant{ _cgo0 := /*line :74:34*/ptr; _cgoCheckPointer(_cgo0, nil); return /*line :74:38*/_Cfunc_toGVariant(_cgo0); }())
}

// takeVariant wraps a native GVariant,
// takes ownership and sets up a finalizer to free the instance during GC.
func takeVariant(p * /*line :79:21*/_Ctype_GVariant /*line :79:31*/) *Variant {
	if p == nil {
		return nil
	}
	obj := &Variant{GVariant: p}

	if obj.IsFloating() {
		obj.RefSink()
	} else {
		obj.Ref()
	}

	runtime.SetFinalizer(obj, func(v *Variant) { FinalizerStrategy(v.Unref) })
	return obj
}

// IsFloating returns true if the variant has a floating reference count.
// Reference counting is usually handled in the gotk layer,
// most applications should not call this.
func (v *Variant) IsFloating() bool {
	return gobool(func() _Ctype_gboolean{ _cgo0 := /*line :99:40*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :99:51*/_Cfunc_g_variant_is_floating(_cgo0); }())
}

// Ref is a wrapper around g_variant_ref.
// Reference counting is usually handled in the gotk layer,
// most applications should not need to call this.
func (v *Variant) Ref() {
	func() *_Ctype_struct__GVariant{ _cgo0 := /*line :106:18*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :106:29*/_Cfunc_g_variant_ref(_cgo0); }()
}

// RefSink is a wrapper around g_variant_ref_sink.
// Reference counting is usually handled in the gotk layer,
// most applications should not need to call this.
func (v *Variant) RefSink() {
	func() *_Ctype_struct__GVariant{ _cgo0 := /*line :113:23*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :113:34*/_Cfunc_g_variant_ref_sink(_cgo0); }()
}

// TakeRef is a wrapper around g_variant_take_ref.
// Reference counting is usually handled in the gotk layer,
// most applications should not need to call this.
func (v *Variant) TakeRef() {
	func() *_Ctype_struct__GVariant{ _cgo0 := /*line :120:23*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :120:34*/_Cfunc_g_variant_take_ref(_cgo0); }()
}

// Unref is a wrapper around g_variant_unref.
// Reference counting is usually handled in the gotk layer,
// most applications should not need to call this.
func (v *Variant) Unref() {
	func() { _cgo0 := /*line :127:20*/v.native(); _cgoCheckPointer(_cgo0, nil); /*line :127:31*/_Cfunc_g_variant_unref(_cgo0); }()
}

// VariantFromInt16 is a wrapper around g_variant_new_int16
func VariantFromInt16(value int16) *Variant {
	return takeVariant(( /*line :132:21*/_Cfunc_g_variant_new_int16 /*line :132:41*/)( /*line :132:43*/_Ctype_gint16 /*line :132:51*/(value)))
}

// VariantFromInt32 is a wrapper around g_variant_new_int32
func VariantFromInt32(value int32) *Variant {
	return takeVariant(( /*line :137:21*/_Cfunc_g_variant_new_int32 /*line :137:41*/)( /*line :137:43*/_Ctype_gint32 /*line :137:51*/(value)))
}

// VariantFromInt64 is a wrapper around g_variant_new_int64
func VariantFromInt64(value int64) *Variant {
	return takeVariant(( /*line :142:21*/_Cfunc_g_variant_new_int64 /*line :142:41*/)( /*line :142:43*/_Ctype_gint64 /*line :142:51*/(value)))
}

// VariantFromByte is a wrapper around g_variant_new_byte
func VariantFromByte(value uint8) *Variant {
	return takeVariant(( /*line :147:21*/_Cfunc_g_variant_new_byte /*line :147:40*/)( /*line :147:42*/_Ctype_guint8 /*line :147:50*/(value)))
}

// VariantFromUint16 is a wrapper around g_variant_new_uint16
func VariantFromUint16(value uint16) *Variant {
	return takeVariant(( /*line :152:21*/_Cfunc_g_variant_new_uint16 /*line :152:42*/)( /*line :152:44*/_Ctype_guint16 /*line :152:53*/(value)))
}

// VariantFromUint32 is a wrapper around g_variant_new_uint32
func VariantFromUint32(value uint32) *Variant {
	return takeVariant(( /*line :157:21*/_Cfunc_g_variant_new_uint32 /*line :157:42*/)( /*line :157:44*/_Ctype_guint32 /*line :157:53*/(value)))
}

// VariantFromUint64 is a wrapper around g_variant_new_uint64
func VariantFromUint64(value uint64) *Variant {
	return takeVariant(( /*line :162:21*/_Cfunc_g_variant_new_uint64 /*line :162:42*/)( /*line :162:44*/_Ctype_guint64 /*line :162:53*/(value)))
}

// VariantFromBoolean is a wrapper around g_variant_new_boolean
func VariantFromBoolean(value bool) *Variant {
	return takeVariant(( /*line :167:21*/_Cfunc_g_variant_new_boolean /*line :167:43*/)(gbool(value)))
}

// VariantFromFloat64 is a wrapper around g_variant_new_double().
// I chose to respect the Golang float64 nomenclature instead
// of 'double' 'C'. Corresponding VariantType is: 'VARIANT_TYPE_DOUBLE'
func VariantFromFloat64(value float64) *Variant {
	return takeVariant(( /*line :174:21*/_Cfunc_g_variant_new_double /*line :174:42*/)( /*line :174:44*/_Ctype_gdouble /*line :174:53*/(value)))
}

// VariantFromString is a wrapper around g_variant_new_string/g_variant_new_take_string.
// Uses g_variant_new_take_string to reduce memory allocations if possible.
func VariantFromString(value string) *Variant {
	cstr := (* /*line :180:12*/_Ctype_gchar /*line :180:19*/)(( /*line :180:21*/_Cfunc_CString /*line :180:29*/)(value))
	// g_variant_new_take_string takes owhership of the cstring and will call free() on it when done.
	// Do NOT free this string in this function!
	return takeVariant(( /*line :183:21*/_Cfunc_g_variant_new_take_string /*line :183:47*/)(cstr))
}

// VariantFromVariant is a wrapper around g_variant_new_variant.
func VariantFromVariant(value *Variant) *Variant {
	return takeVariant(func() *_Ctype_struct__GVariant{ _cgo0 := /*line :188:45*/value.native(); _cgoCheckPointer(_cgo0, nil); return /*line :188:60*/_Cfunc_g_variant_new_variant(_cgo0); }())
}

// TypeString returns the g variant type string for this variant.
func (v *Variant) TypeString() string {
	// the string returned from this belongs to GVariant and must not be freed.
	return ( /*line :194:9*/_Cfunc_GoString /*line :194:18*/)((* /*line :194:22*/_Ctype_char /*line :194:28*/)(func() *_Ctype_gchar{ _cgo0 := /*line :194:58*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :194:69*/_Cfunc_g_variant_get_type_string(_cgo0); }()))
}

// IsContainer returns true if the variant is a container and false otherwise.
func (v *Variant) IsContainer() bool {
	return gobool(func() _Ctype_gboolean{ _cgo0 := /*line :199:41*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :199:52*/_Cfunc_g_variant_is_container(_cgo0); }())
}

// GetBoolean returns the bool value of this variant.
func (v *Variant) GetBoolean() bool {
	return gobool(func() _Ctype_gboolean{ _cgo0 := /*line :204:40*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :204:51*/_Cfunc_g_variant_get_boolean(_cgo0); }())
}

// GetDouble is a wrapper around g_variant_get_double()
func (v *Variant) GetDouble() float64 {
	return float64(func() _Ctype_gdouble{ _cgo0 := /*line :209:40*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :209:51*/_Cfunc_g_variant_get_double(_cgo0); }())
}

// GetString is a wrapper around g_variant_get_string.
// It returns the string value of the variant.
func (v *Variant) GetString() string {

	// The string value remains valid as long as the GVariant exists, do NOT free the cstring in this function.
	var len  /*line :217:10*/_Ctype_gsize /*line :217:17*/
	gc := func() *_Ctype_gchar{ _cgo0 := /*line :218:31*/v.native(); var _cgo1 *_Ctype_gsize = /*line :218:43*/&len; _cgoCheckPointer(_cgo0, nil); return /*line :218:48*/_Cfunc_g_variant_get_string(_cgo0, _cgo1); }()

	// This is opposed to g_variant_dup_string, which copies the string.
	// g_variant_dup_string is not implemented,
	// as we copy the string value anyways when converting to a go string.

	return ( /*line :224:9*/_Cfunc_GoStringN /*line :224:19*/)((* /*line :224:23*/_Ctype_char /*line :224:29*/)(gc), ( /*line :224:37*/_Ctype_int /*line :224:42*/)(len))
}

// GetVariant is a wrapper around g_variant_get_variant.
// It unboxes a nested GVariant.
func (v *Variant) GetVariant() *Variant {
	c := func() *_Ctype_struct__GVariant{ _cgo0 := /*line :230:31*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :230:42*/_Cfunc_g_variant_get_variant(_cgo0); }()
	if c == nil {
		return nil
	}
	// The returned value is returned with full ownership transfer,
	// only Unref(), don't Ref().
	obj := newVariant(c)
	runtime.SetFinalizer(obj, func(v *Variant) { FinalizerStrategy(v.Unref) })
	return obj
}

// GetStrv returns a slice of strings from this variant.  It wraps
// g_variant_get_strv, but returns copies of the strings instead.
func (v *Variant) GetStrv() []string {
	gstrv := func() **_Ctype_gchar{ _cgo0 := /*line :244:32*/v.native(); var _cgo1 *_Ctype_gsize = /*line :244:44*/nil; _cgoCheckPointer(_cgo0, nil); return /*line :244:48*/_Cfunc_g_variant_get_strv(_cgo0, _cgo1); }()
	// we do not own the memory for these strings, so we must not use strfreev
	// but we must free the actual pointer we receive (transfer container).
	// We don't implement g_variant_dup_strv which copies the strings,
	// as we need to copy anyways when converting to go strings.
	c := gstrv
	defer func() func() { _cgo0 := _Ctype_gpointer /*line :250:27*/(gstrv); return func() { _cgoCheckPointer(_cgo0, nil); /*line :250:35*/_Cfunc_g_free(_cgo0); }}()()
	var strs []string

	for *c != nil {
		strs = append(strs, ( /*line :254:23*/_Cfunc_GoString /*line :254:32*/)((* /*line :254:36*/_Ctype_char /*line :254:42*/)(*c)))
		c = func() **_Ctype_gchar{ _cgo0 := /*line :255:23*/c; _cgoCheckPointer(_cgo0, nil); return /*line :255:25*/_Cfunc_next_gcharptr(_cgo0); }()
	}
	return strs
}

// GetObjv returns a slice of object paths from this variant.  It wraps
// g_variant_get_objv, but returns copies of the strings instead.
func (v *Variant) GetObjv() []string {
	gstrv := func() **_Ctype_gchar{ _cgo0 := /*line :263:32*/v.native(); var _cgo1 *_Ctype_gsize = /*line :263:44*/nil; _cgoCheckPointer(_cgo0, nil); return /*line :263:48*/_Cfunc_g_variant_get_objv(_cgo0, _cgo1); }()
	// we do not own the memory for these strings, so we must not use strfreev
	// but we must free the actual pointer we receive (transfer container).
	// We don't implement g_variant_dup_objv which copies the strings,
	// as we need to copy anyways when converting to go strings.
	c := gstrv
	defer func() func() { _cgo0 := _Ctype_gpointer /*line :269:27*/(gstrv); return func() { _cgoCheckPointer(_cgo0, nil); /*line :269:35*/_Cfunc_g_free(_cgo0); }}()()
	var strs []string

	for *c != nil {
		strs = append(strs, ( /*line :273:23*/_Cfunc_GoString /*line :273:32*/)((* /*line :273:36*/_Ctype_char /*line :273:42*/)(*c)))
		c = func() **_Ctype_gchar{ _cgo0 := /*line :274:23*/c; _cgoCheckPointer(_cgo0, nil); return /*line :274:25*/_Cfunc_next_gcharptr(_cgo0); }()
	}
	return strs
}

// GetInt returns the int64 value of the variant if it is an integer type, and
// an error otherwise.  It wraps variouns `g_variant_get_*` functions dealing
// with integers of different sizes.
func (v *Variant) GetInt() (int64, error) {
	t := v.TypeString()
	var i int64
	switch t {
	case "n":
		i = int64(func() _Ctype_gint16{ _cgo0 := /*line :287:35*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :287:46*/_Cfunc_g_variant_get_int16(_cgo0); }())
	case "i":
		i = int64(func() _Ctype_gint32{ _cgo0 := /*line :289:35*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :289:46*/_Cfunc_g_variant_get_int32(_cgo0); }())
	case "x":
		i = int64(func() _Ctype_gint64{ _cgo0 := /*line :291:35*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :291:46*/_Cfunc_g_variant_get_int64(_cgo0); }())
	default:
		return 0, fmt.Errorf("variant type %s not a signed integer type", t)
	}
	return i, nil
}

// GetUint returns the uint64 value of the variant if it is an integer type, and
// an error otherwise.  It wraps variouns `g_variant_get_*` functions dealing
// with integers of different sizes.
func (v *Variant) GetUint() (uint64, error) {
	t := v.TypeString()
	var i uint64
	switch t {
	case "y":
		i = uint64(func() _Ctype_guint8{ _cgo0 := /*line :306:35*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :306:46*/_Cfunc_g_variant_get_byte(_cgo0); }())
	case "q":
		i = uint64(func() _Ctype_guint16{ _cgo0 := /*line :308:37*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :308:48*/_Cfunc_g_variant_get_uint16(_cgo0); }())
	case "u":
		i = uint64(func() _Ctype_guint32{ _cgo0 := /*line :310:37*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :310:48*/_Cfunc_g_variant_get_uint32(_cgo0); }())
	case "t":
		i = uint64(func() _Ctype_guint64{ _cgo0 := /*line :312:37*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :312:48*/_Cfunc_g_variant_get_uint64(_cgo0); }())
	default:
		return 0, fmt.Errorf("variant type %s not an unsigned integer type", t)
	}
	return i, nil
}

// Type returns the VariantType for this variant.
func (v *Variant) Type() *VariantType {
	// The return value is valid for the lifetime of value and must not be freed.
	return newVariantType(func() *_Ctype_struct__GVariantType{ _cgo0 := /*line :322:45*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :322:56*/_Cfunc_g_variant_get_type(_cgo0); }())
}

// IsType returns true if the variant's type matches t.
func (v *Variant) IsType(t *VariantType) bool {
	return gobool(func() _Ctype_gboolean{ _cgo0 := /*line :327:39*/v.native(); _cgo1 := /*line :327:51*/t.native(); _cgoCheckPointer(_cgo0, nil); _cgoCheckPointer(_cgo1, nil); return /*line :327:62*/_Cfunc_g_variant_is_of_type(_cgo0, _cgo1); }())
}

// String wraps g_variant_print().  It returns a string understood
// by g_variant_parse().
func (v *Variant) String() string {
	gc := func() *_Ctype_gchar{ _cgo0 := /*line :333:26*/v.native(); var _cgo1 _Ctype_gboolean = /*line :333:38*/gbool(false); _cgoCheckPointer(_cgo0, nil); return /*line :333:51*/_Cfunc_g_variant_print(_cgo0, _cgo1); }()
	defer func() func() { _cgo0 := _Ctype_gpointer /*line :334:27*/(gc); return func() { _cgoCheckPointer(_cgo0, nil); /*line :334:32*/_Cfunc_g_free(_cgo0); }}()()
	return ( /*line :335:9*/_Cfunc_GoString /*line :335:18*/)((* /*line :335:22*/_Ctype_char /*line :335:28*/)(gc))
}

// AnnotatedString wraps g_variant_print(), but returns a type-annotated
// string.
func (v *Variant) AnnotatedString() string {
	gc := func() *_Ctype_gchar{ _cgo0 := /*line :341:26*/v.native(); var _cgo1 _Ctype_gboolean = /*line :341:38*/gbool(true); _cgoCheckPointer(_cgo0, nil); return /*line :341:50*/_Cfunc_g_variant_print(_cgo0, _cgo1); }()
	defer func() func() { _cgo0 := _Ctype_gpointer /*line :342:27*/(gc); return func() { _cgoCheckPointer(_cgo0, nil); /*line :342:32*/_Cfunc_g_free(_cgo0); }}()()
	return ( /*line :343:9*/_Cfunc_GoString /*line :343:18*/)((* /*line :343:22*/_Ctype_char /*line :343:28*/)(gc))
}

// TODO:
//gint	g_variant_compare ()
//GVariantClass	g_variant_classify ()
//gboolean	g_variant_check_format_string ()
//void	g_variant_get ()
//void	g_variant_get_va ()
//GVariant *	g_variant_new ()
//GVariant *	g_variant_new_va ()
//GVariant *	g_variant_new_handle ()
//GVariant *	g_variant_new_printf ()
//GVariant *	g_variant_new_object_path ()
//gboolean	g_variant_is_object_path ()
//GVariant *	g_variant_new_signature ()
//gboolean	g_variant_is_signature ()
//GVariant *	g_variant_new_strv ()
//GVariant *	g_variant_new_objv ()
//GVariant *	g_variant_new_bytestring ()
//GVariant *	g_variant_new_bytestring_array ()
//guchar	g_variant_get_byte ()
//gint16	g_variant_get_int16 ()
//guint16	g_variant_get_uint16 ()
//gint32	g_variant_get_int32 ()
//guint32	g_variant_get_uint32 ()
//gint64	g_variant_get_int64 ()
//guint64	g_variant_get_uint64 ()
//gint32	g_variant_get_handle ()
//gdouble	g_variant_get_double ()
//const gchar *	g_variant_get_bytestring ()
//gchar *	g_variant_dup_bytestring ()
//const gchar **	g_variant_get_bytestring_array ()
//gchar **	g_variant_dup_bytestring_array ()
//GVariant *	g_variant_new_maybe ()
//GVariant *	g_variant_new_array ()
//GVariant *	g_variant_new_tuple ()
//GVariant *	g_variant_new_dict_entry ()
//GVariant *	g_variant_new_fixed_array ()
//GVariant *	g_variant_get_maybe ()
//gsize	g_variant_n_children ()
//GVariant *	g_variant_get_child_value ()
//void	g_variant_get_child ()
//GVariant *	g_variant_lookup_value ()
//gboolean	g_variant_lookup ()
//gconstpointer	g_variant_get_fixed_array ()
//gsize	g_variant_get_size ()
//gconstpointer	g_variant_get_data ()
//GBytes *	g_variant_get_data_as_bytes ()
//void	g_variant_store ()
//GVariant *	g_variant_new_from_data ()
//GVariant *	g_variant_new_from_bytes ()
//GVariant *	g_variant_byteswap ()
//GVariant *	g_variant_get_normal_form ()
//gboolean	g_variant_is_normal_form ()
//guint	g_variant_hash ()
//gboolean	g_variant_equal ()
//gchar *	g_variant_print ()
//GString *	g_variant_print_string ()
//GVariantIter *	g_variant_iter_copy ()
//void	g_variant_iter_free ()
//gsize	g_variant_iter_init ()
//gsize	g_variant_iter_n_children ()
//GVariantIter *	g_variant_iter_new ()
//GVariant *	g_variant_iter_next_value ()
//gboolean	g_variant_iter_next ()
//gboolean	g_variant_iter_loop ()
//void	g_variant_builder_unref ()
//GVariantBuilder *	g_variant_builder_ref ()
//GVariantBuilder *	g_variant_builder_new ()
//void	g_variant_builder_init ()
//void	g_variant_builder_clear ()
//void	g_variant_builder_add_value ()
//void	g_variant_builder_add ()
//void	g_variant_builder_add_parsed ()
//GVariant *	g_variant_builder_end ()
//void	g_variant_builder_open ()
//void	g_variant_builder_close ()
//void	g_variant_dict_unref ()
//GVariantDict *	g_variant_dict_ref ()
//GVariantDict *	g_variant_dict_new ()
//void	g_variant_dict_init ()
//void	g_variant_dict_clear ()
//gboolean	g_variant_dict_contains ()
//gboolean	g_variant_dict_lookup ()
//GVariant *	g_variant_dict_lookup_value ()
//void	g_variant_dict_insert ()
//void	g_variant_dict_insert_value ()
//gboolean	g_variant_dict_remove ()
//GVariant *	g_variant_dict_end ()
//#define	G_VARIANT_PARSE_ERROR

// VariantParse is a wrapper around g_variant_parse()
func VariantParse(vType *VariantType, text string) (*Variant, error) {
	cstr := ( /*line :437:10*/_Cfunc_CString /*line :437:18*/)(text)
	defer func() func() { _cgo0 := /*line :438:15*/unsafe.Pointer(cstr); return func() { _cgoCheckPointer(_cgo0, nil); /*line :438:36*/_Cfunc_free(_cgo0); }}()()
	var gerr * /*line :439:12*/_Ctype_GError /*line :439:20*/
	c := func() *_Ctype_struct__GVariant{ _cgo0 := /*line :440:25*/vType.native(); var _cgo1 *_Ctype_gchar = /*line :440:41*/(*_Ctype_gchar /*line :440:50*/)(cstr); var _cgo2 *_Ctype_gchar = /*line :440:59*/nil; var _cgo3 **_Ctype_gchar = /*line :440:64*/nil; _cgoBase4 := /*line :440:69*/&gerr; _cgo4 := _cgoBase4; _cgoCheckPointer(_cgo0, nil); _cgoCheckPointer(_cgoBase4, 0 == 0); return /*line :440:75*/_Cfunc_g_variant_parse(_cgo0, _cgo1, _cgo2, _cgo3, _cgo4); }()
	if c == nil {
		defer func() func() { _cgo0 := /*line :442:24*/gerr; return func() { _cgoCheckPointer(_cgo0, nil); /*line :442:29*/_Cfunc_g_error_free(_cgo0); }}()()
		return nil, errors.New(goString(gerr.message))
	}
	// will be freed during GC
	return takeVariant(c), nil
}

//GVariant *	g_variant_new_parsed_va ()
//GVariant *	g_variant_new_parsed ()
//gchar *	g_variant_parse_error_print_context ()