// 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/gvarianttype.go:1:1
// Same copyright and license as the rest of the files in this project

//GVariant : GVariant — strongly typed value datatype
// https://developer.gnome.org/glib/2.26/glib-GVariant.html

package glib

// #include <stdlib.h>
// #include <glib.h>
// #include "gvarianttype.go.h"
import _ "unsafe"

import (
	"runtime"
	"unsafe"
)

// A VariantType is a wrapper for the GVariantType, which encodes type
// information for GVariants.
type VariantType struct {
	GVariantType * /*line :21:16*/_Ctype_GVariantType /*line :21:30*/
}

func (v *VariantType) native() * /*line :24:33*/_Ctype_GVariantType /*line :24:47*/ {
	if v == nil {
		return nil
	}
	return v.GVariantType
}

// String returns a copy of this VariantType's type string.
func (v *VariantType) String() string {
	ch := func() *_Ctype_gchar{ _cgo0 := /*line :33:36*/v.native(); _cgoCheckPointer(_cgo0, nil); return /*line :33:47*/_Cfunc_g_variant_type_dup_string(_cgo0); }()
	defer func() func() { _cgo0 := _Ctype_gpointer /*line :34:27*/(ch); return func() { _cgoCheckPointer(_cgo0, nil); /*line :34:32*/_Cfunc_g_free(_cgo0); }}()()
	return ( /*line :35:9*/_Cfunc_GoString /*line :35:18*/)((* /*line :35:22*/_Ctype_char /*line :35:28*/)(ch))
}

// newVariantType wraps a native GVariantType.
// Does not create a finalizer.
// Use takeVariantType for instances which need to be freed after use.
func newVariantType(v * /*line :41:24*/_Ctype_GVariantType /*line :41:38*/) *VariantType {
	if v == nil {
		return nil
	}
	return &VariantType{v}
}

// takeVariantType wraps a native GVariantType
// and sets up a finalizer to free the instance during GC.
func takeVariantType(v * /*line :50:25*/_Ctype_GVariantType /*line :50:39*/) *VariantType {
	if v == nil {
		return nil
	}
	obj := &VariantType{v}
	runtime.SetFinalizer(obj, func(v *VariantType) { FinalizerStrategy(v.Free) })
	return obj
}

// Variant types for comparing between them.  Cannot be const because
// they are pointers.
// Note that variant types cannot be compared by value, use VariantTypeEqual() instead.
var (
	VARIANT_TYPE_BOOLEAN           = newVariantType(( /*line :63:50*/*_Cvar__G_VARIANT_TYPE_BOOLEAN /*line :63:74*/))
	VARIANT_TYPE_BYTE              = newVariantType(( /*line :64:50*/*_Cvar__G_VARIANT_TYPE_BYTE /*line :64:71*/))
	VARIANT_TYPE_INT16             = newVariantType(( /*line :65:50*/*_Cvar__G_VARIANT_TYPE_INT16 /*line :65:72*/))
	VARIANT_TYPE_UINT16            = newVariantType(( /*line :66:50*/*_Cvar__G_VARIANT_TYPE_UINT16 /*line :66:73*/))
	VARIANT_TYPE_INT32             = newVariantType(( /*line :67:50*/*_Cvar__G_VARIANT_TYPE_INT32 /*line :67:72*/))
	VARIANT_TYPE_UINT32            = newVariantType(( /*line :68:50*/*_Cvar__G_VARIANT_TYPE_UINT32 /*line :68:73*/))
	VARIANT_TYPE_INT64             = newVariantType(( /*line :69:50*/*_Cvar__G_VARIANT_TYPE_INT64 /*line :69:72*/))
	VARIANT_TYPE_UINT64            = newVariantType(( /*line :70:50*/*_Cvar__G_VARIANT_TYPE_UINT64 /*line :70:73*/))
	VARIANT_TYPE_HANDLE            = newVariantType(( /*line :71:50*/*_Cvar__G_VARIANT_TYPE_HANDLE /*line :71:73*/))
	VARIANT_TYPE_DOUBLE            = newVariantType(( /*line :72:50*/*_Cvar__G_VARIANT_TYPE_DOUBLE /*line :72:73*/))
	VARIANT_TYPE_STRING            = newVariantType(( /*line :73:50*/*_Cvar__G_VARIANT_TYPE_STRING /*line :73:73*/))
	VARIANT_TYPE_OBJECT_PATH       = newVariantType(( /*line :74:50*/*_Cvar__G_VARIANT_TYPE_OBJECT_PATH /*line :74:78*/))
	VARIANT_TYPE_SIGNATURE         = newVariantType(( /*line :75:50*/*_Cvar__G_VARIANT_TYPE_SIGNATURE /*line :75:76*/))
	VARIANT_TYPE_VARIANT           = newVariantType(( /*line :76:50*/*_Cvar__G_VARIANT_TYPE_VARIANT /*line :76:74*/))
	VARIANT_TYPE_ANY               = newVariantType(( /*line :77:50*/*_Cvar__G_VARIANT_TYPE_ANY /*line :77:70*/))
	VARIANT_TYPE_BASIC             = newVariantType(( /*line :78:50*/*_Cvar__G_VARIANT_TYPE_BASIC /*line :78:72*/))
	VARIANT_TYPE_MAYBE             = newVariantType(( /*line :79:50*/*_Cvar__G_VARIANT_TYPE_MAYBE /*line :79:72*/))
	VARIANT_TYPE_ARRAY             = newVariantType(( /*line :80:50*/*_Cvar__G_VARIANT_TYPE_ARRAY /*line :80:72*/))
	VARIANT_TYPE_TUPLE             = newVariantType(( /*line :81:50*/*_Cvar__G_VARIANT_TYPE_TUPLE /*line :81:72*/))
	VARIANT_TYPE_UNIT              = newVariantType(( /*line :82:50*/*_Cvar__G_VARIANT_TYPE_UNIT /*line :82:71*/))
	VARIANT_TYPE_DICT_ENTRY        = newVariantType(( /*line :83:50*/*_Cvar__G_VARIANT_TYPE_DICT_ENTRY /*line :83:77*/))
	VARIANT_TYPE_DICTIONARY        = newVariantType(( /*line :84:50*/*_Cvar__G_VARIANT_TYPE_DICTIONARY /*line :84:77*/))
	VARIANT_TYPE_STRING_ARRAY      = newVariantType(( /*line :85:50*/*_Cvar__G_VARIANT_TYPE_STRING_ARRAY /*line :85:79*/))
	VARIANT_TYPE_OBJECT_PATH_ARRAY = newVariantType(( /*line :86:50*/*_Cvar__G_VARIANT_TYPE_OBJECT_PATH_ARRAY /*line :86:84*/))
	VARIANT_TYPE_BYTESTRING        = newVariantType(( /*line :87:50*/*_Cvar__G_VARIANT_TYPE_BYTESTRING /*line :87:77*/))
	VARIANT_TYPE_BYTESTRING_ARRAY  = newVariantType(( /*line :88:50*/*_Cvar__G_VARIANT_TYPE_BYTESTRING_ARRAY /*line :88:83*/))
	VARIANT_TYPE_VARDICT           = newVariantType(( /*line :89:50*/*_Cvar__G_VARIANT_TYPE_VARDICT /*line :89:74*/))
)

// Free is a wrapper around g_variant_type_free.
// Reference counting is usually handled in the gotk layer,
// most applications should not call this.
func (v *VariantType) Free() {
	func() { _cgo0 := /*line :96:24*/v.native(); _cgoCheckPointer(_cgo0, nil); /*line :96:35*/_Cfunc_g_variant_type_free(_cgo0); }()
}

// VariantTypeNew is a wrapper around g_variant_type_new.
func VariantTypeNew(typeString string) *VariantType {
	cstr := (* /*line :101:12*/_Ctype_gchar /*line :101:19*/)(( /*line :101:21*/_Cfunc_CString /*line :101:29*/)(typeString))
	defer func() func() { _cgo0 := /*line :102:15*/unsafe.Pointer(cstr); return func() { _cgoCheckPointer(_cgo0, nil); /*line :102:36*/_Cfunc_free(_cgo0); }}()()

	c := ( /*line :104:7*/_Cfunc_g_variant_type_new /*line :104:26*/)(cstr)
	return takeVariantType(c)
}

// VariantTypeStringIsValid is a wrapper around g_variant_type_string_is_valid.
func VariantTypeStringIsValid(typeString string) bool {
	cstr := (* /*line :110:12*/_Ctype_gchar /*line :110:19*/)(( /*line :110:21*/_Cfunc_CString /*line :110:29*/)(typeString))
	defer func() func() { _cgo0 := /*line :111:15*/unsafe.Pointer(cstr); return func() { _cgoCheckPointer(_cgo0, nil); /*line :111:36*/_Cfunc_free(_cgo0); }}()()

	return gobool(( /*line :113:16*/_Cfunc_g_variant_type_string_is_valid /*line :113:47*/)(cstr))
}

// VariantTypeEqual is a wrapper around g_variant_type_equal
func VariantTypeEqual(type1, type2 *VariantType) bool {
	return gobool(func() _Ctype_gboolean{ _cgo0 := _Ctype_gconstpointer /*line :118:54*/(type1.native()); _cgo1 := _Ctype_gconstpointer /*line :118:87*/(type2.native()); _cgoCheckPointer(_cgo0, nil); _cgoCheckPointer(_cgo1, nil); return /*line :118:104*/_Cfunc_g_variant_type_equal(_cgo0, _cgo1); }())
}

// IsSubtypeOf is a wrapper around g_variant_type_is_subtype_of
func (v *VariantType) IsSubtypeOf(supertype *VariantType) bool {
	return gobool(func() _Ctype_gboolean{ _cgo0 := /*line :123:47*/v.native(); _cgo1 := /*line :123:59*/supertype.native(); _cgoCheckPointer(_cgo0, nil); _cgoCheckPointer(_cgo1, nil); return /*line :123:78*/_Cfunc_g_variant_type_is_subtype_of(_cgo0, _cgo1); }())
}

// TODO:
// g_variant_type_copy
// g_variant_type_string_scan
// g_variant_type_is_definite
// g_variant_type_is_container
// g_variant_type_is_basic
// g_variant_type_is_maybe
// g_variant_type_is_array
// g_variant_type_is_tuple
// g_variant_type_is_dict_entry
// g_variant_type_is_variant
// g_variant_type_hash
// g_variant_type_new_maybe
// g_variant_type_new_array
// g_variant_type_new_tuple
// g_variant_type_new_dict_entry
// g_variant_type_element
// g_variant_type_n_items
// g_variant_type_first
// g_variant_type_next
// g_variant_type_key
// g_variant_type_value