1// Package glib was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package glib
3
4import (
5 "structs"
6 "unsafe"
7
8 "github.com/ebitengine/purego"
9
10 "github.com/bnema/puregotk/pkg/core"
11 "github.com/bnema/puregotk/v4/gobject/types"
12)
13
14// A type in the [type@GLib.Variant] type system.
15//
16// [type@GLib.Variant] types are represented as strings, but have a strict
17// syntax described below. All [type@GLib.VariantType]s passed to GLib must be
18// valid, and they are typically expected to be static (i.e. not provided by
19// user input) as they determine how binary [type@GLib.Variant] data is
20// interpreted.
21//
22// To convert a static string to a [type@GLib.VariantType] in C, use the
23// [func@GLib.VARIANT_TYPE] casting macro. When GLib is compiled with checks
24// enabled, it will validate the type. To check if an arbitrary string is a
25// valid [type@GLib.VariantType], use [func@GLib.VariantType.string_is_valid].
26//
27// ## GVariant Type System
28//
29// This section introduces the [type@GLib.Variant] type system. It is based, in
30// large part, on the D-Bus type system, with two major changes and
31// some minor lifting of restrictions. The
32// [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html),
33// therefore, provides a significant amount of
34// information that is useful when working with [type@GLib.Variant].
35//
36// The first major change with respect to the D-Bus type system is the
37// introduction of maybe (or ‘nullable’) types. Any type in [type@GLib.Variant]
38// can be converted to a maybe type, in which case, `nothing` (or `null`)
39// becomes a valid value. Maybe types have been added by introducing the
40// character `m` to type strings.
41//
42// The second major change is that the [type@GLib.Variant] type system supports
43// the concept of ‘indefinite types’ — types that are less specific than
44// the normal types found in D-Bus. For example, it is possible to speak
45// of ‘an array of any type’ in [type@GLib.Variant], where the D-Bus type system
46// would require you to speak of ‘an array of integers’ or ‘an array of
47// strings’. Indefinite types have been added by introducing the
48// characters `*`, `?` and `r` to type strings.
49//
50// Finally, all arbitrary restrictions relating to the complexity of
51// types are lifted along with the restriction that dictionary entries
52// may only appear nested inside of arrays.
53//
54// Just as in D-Bus, [type@GLib.Variant] types are described with strings (‘type
55// strings’). Subject to the differences mentioned above, these strings
56// are of the same form as those found in D-Bus. Note, however: D-Bus
57// always works in terms of messages and therefore individual type
58// strings appear nowhere in its interface. Instead, ‘signatures’
59// are a concatenation of the strings of the type of each argument in a
60// message. [type@GLib.Variant] deals with single values directly so
61// [type@GLib.Variant] type strings always describe the type of exactly one
62// value. This means that a D-Bus signature string is generally not a valid
63// [type@GLib.Variant] type string — except in the case that it is the signature
64// of a message containing exactly one argument.
65//
66// An indefinite type is similar in spirit to what may be called an
67// abstract type in other type systems. No value can exist that has an
68// indefinite type as its type, but values can exist that have types
69// that are subtypes of indefinite types. That is to say,
70// [method@GLib.Variant.get_type] will never return an indefinite type, but
71// calling [method@GLib.Variant.is_of_type] with an indefinite type may return
72// true. For example, you cannot have a value that represents ‘an
73// array of no particular type’, but you can have an ‘array of integers’
74// which certainly matches the type of ‘an array of no particular type’,
75// since ‘array of integers’ is a subtype of ‘array of no particular
76// type’.
77//
78// This is similar to how instances of abstract classes may not
79// directly exist in other type systems, but instances of their
80// non-abstract subtypes may. For example, in GTK, no object that has
81// the type of [`GtkWidget`](https://docs.gtk.org/gtk4/class.Widget.html) can
82// exist (since `GtkWidget` is an abstract class), but a [`GtkWindow`](https://docs.gtk.org/gtk4/class.Window.html)
83// can certainly be instantiated, and you would say that a `GtkWindow` is a
84// `GtkWidget` (since `GtkWindow` is a subclass of `GtkWidget`).
85//
86// Two types may not be compared by value; use [method@GLib.VariantType.equal]
87// or [method@GLib.VariantType.is_subtype_of] May be copied using
88// [method@GLib.VariantType.copy] and freed using [method@GLib.VariantType.free].
89//
90// ## GVariant Type Strings
91//
92// A [type@GLib.Variant] type string can be any of the following:
93//
94// - any basic type string (listed below)
95// - `v`, `r` or `*`
96// - one of the characters `a` or `m`, followed by another type string
97// - the character `(`, followed by a concatenation of zero or more other
98// type strings, followed by the character `)`
99// - the character `{`, followed by a basic type string (see below),
100// followed by another type string, followed by the character `}`
101//
102// A basic type string describes a basic type (as per
103// [method@GLib.VariantType.is_basic]) and is always a single character in
104// length. The valid basic type strings are `b`, `y`, `n`, `q`, `i`, `u`, `x`,
105// `t`, `h`, `d`, `s`, `o`, `g` and `?`.
106//
107// The above definition is recursive to arbitrary depth. `aaaaai` and
108// `(ui(nq((y)))s)` are both valid type strings, as is
109// `a(aa(ui)(qna{ya(yd)}))`. In order to not hit memory limits,
110// [type@GLib.Variant] imposes a limit on recursion depth of 65 nested
111// containers. This is the limit in the D-Bus specification (64) plus one to
112// allow a [`GDBusMessage`](../gio/class.DBusMessage.html) to be nested in
113// a top-level tuple.
114//
115// The meaning of each of the characters is as follows:
116//
117// - `b`: the type string of `G_VARIANT_TYPE_BOOLEAN`; a boolean value.
118//
119// - `y`: the type string of `G_VARIANT_TYPE_BYTE`; a byte.
120//
121// - `n`: the type string of `G_VARIANT_TYPE_INT16`; a signed 16 bit integer.
122//
123// - `q`: the type string of `G_VARIANT_TYPE_UINT16`; an unsigned 16 bit integer.
124//
125// - `i`: the type string of `G_VARIANT_TYPE_INT32`; a signed 32 bit integer.
126//
127// - `u`: the type string of `G_VARIANT_TYPE_UINT32`; an unsigned 32 bit integer.
128//
129// - `x`: the type string of `G_VARIANT_TYPE_INT64`; a signed 64 bit integer.
130//
131// - `t`: the type string of `G_VARIANT_TYPE_UINT64`; an unsigned 64 bit integer.
132//
133// - `h`: the type string of `G_VARIANT_TYPE_HANDLE`; a signed 32 bit value
134// that, by convention, is used as an index into an array of file
135// descriptors that are sent alongside a D-Bus message.
136//
137// - `d`: the type string of `G_VARIANT_TYPE_DOUBLE`; a double precision
138// floating point value.
139//
140// - `s`: the type string of `G_VARIANT_TYPE_STRING`; a string.
141//
142// - `o`: the type string of `G_VARIANT_TYPE_OBJECT_PATH`; a string in the form
143// of a D-Bus object path.
144//
145// - `g`: the type string of `G_VARIANT_TYPE_SIGNATURE`; a string in the form of
146// a D-Bus type signature.
147//
148// - `?`: the type string of `G_VARIANT_TYPE_BASIC`; an indefinite type that
149// is a supertype of any of the basic types.
150//
151// - `v`: the type string of `G_VARIANT_TYPE_VARIANT`; a container type that
152// contain any other type of value.
153//
154// - `a`: used as a prefix on another type string to mean an array of that
155// type; the type string `ai`, for example, is the type of an array of
156// signed 32-bit integers.
157//
158// - `m`: used as a prefix on another type string to mean a ‘maybe’, or
159// ‘nullable’, version of that type; the type string `ms`, for example,
160// is the type of a value that maybe contains a string, or maybe contains
161// nothing.
162//
163// - `()`: used to enclose zero or more other concatenated type strings to
164// create a tuple type; the type string `(is)`, for example, is the type of
165// a pair of an integer and a string.
166//
167// - `r`: the type string of `G_VARIANT_TYPE_TUPLE`; an indefinite type that is
168// a supertype of any tuple type, regardless of the number of items.
169//
170// - `{}`: used to enclose a basic type string concatenated with another type
171// string to create a dictionary entry type, which usually appears inside of
172// an array to form a dictionary; the type string `a{sd}`, for example, is
173// the type of a dictionary that maps strings to double precision floating
174// point values.
175//
176// The first type (the basic type) is the key type and the second type is
177// the value type. The reason that the first type is restricted to being a
178// basic type is so that it can easily be hashed.
179//
180// - `*`: the type string of `G_VARIANT_TYPE_ANY`; the indefinite type that is
181// a supertype of all types. Note that, as with all type strings, this
182// character represents exactly one type. It cannot be used inside of tuples
183// to mean ‘any number of items’.
184//
185// Any type string of a container that contains an indefinite type is,
186// itself, an indefinite type. For example, the type string `a*`
187// (corresponding to `G_VARIANT_TYPE_ARRAY`) is an indefinite type
188// that is a supertype of every array type. `(*s)` is a supertype
189// of all tuples that contain exactly two items where the second
190// item is a string.
191//
192// `a{?*}` is an indefinite type that is a supertype of all arrays
193// containing dictionary entries where the key is any basic type and
194// the value is any type at all. This is, by definition, a dictionary,
195// so this type string corresponds to `G_VARIANT_TYPE_DICTIONARY`. Note
196// that, due to the restriction that the key of a dictionary entry must
197// be a basic type, `{**}` is not a valid type string.
198type VariantType struct {
199 _ structs.HostLayout
200}
201
202var xVariantTypeGLibType func() types.GType
203
204func VariantTypeGLibType() types.GType {
205 return xVariantTypeGLibType()
206}
207
208func (x *VariantType) GoPointer() uintptr {
209 return uintptr(unsafe.Pointer(x))
210}
211
212var xNewVariantType func(string) *VariantType
213
214// Creates a new [type@GLib.VariantType] corresponding to the type string given
215// by @type_string.
216//
217// It is appropriate to call [method@GLib.VariantType.free] on the return value.
218//
219// It is a programmer error to call this function with an invalid type
220// string. Use [func@GLib.VariantType.string_is_valid] if you are unsure.
221func NewVariantType(TypeStringVar string) *VariantType {
222
223 cret := xNewVariantType(TypeStringVar)
224 return cret
225}
226
227var xNewVariantTypeArray func(*VariantType) *VariantType
228
229// Constructs the type corresponding to an array of elements of the
230// type @type.
231//
232// It is appropriate to call [method@GLib.VariantType.first] on the return value.
233func NewVariantTypeArray(ElementVar *VariantType) *VariantType {
234
235 cret := xNewVariantTypeArray(ElementVar)
236 return cret
237}
238
239var xNewVariantTypeDictEntry func(*VariantType, *VariantType) *VariantType
240
241// Constructs the type corresponding to a dictionary entry with a key
242// of type @key and a value of type @value.
243//
244// It is appropriate to call [method@GLib.VariantType.free] on the return value.
245func NewVariantTypeDictEntry(KeyVar *VariantType, ValueVar *VariantType) *VariantType {
246
247 cret := xNewVariantTypeDictEntry(KeyVar, ValueVar)
248 return cret
249}
250
251var xNewVariantTypeMaybe func(*VariantType) *VariantType
252
253// Constructs the type corresponding to a ‘maybe’ instance containing
254// type @type or `Nothing`.
255//
256// It is appropriate to call [method@GLib.VariantType.free] on the return value.
257func NewVariantTypeMaybe(ElementVar *VariantType) *VariantType {
258
259 cret := xNewVariantTypeMaybe(ElementVar)
260 return cret
261}
262
263var xNewVariantTypeTuple func(uintptr, int) *VariantType
264
265// Constructs a new tuple type, from @items.
266//
267// @length is the number of items in @items, or `-1` to indicate that
268// @items is `NULL`-terminated.
269//
270// It is appropriate to call [method@GLib.VariantType.free] on the return value.
271func NewVariantTypeTuple(ItemsVar uintptr, LengthVar int) *VariantType {
272
273 cret := xNewVariantTypeTuple(ItemsVar, LengthVar)
274 return cret
275}
276
277var xVariantTypeCopy func(uintptr) *VariantType
278
279// Makes a copy of a [type@GLib.VariantType].
280//
281// It is appropriate to call [method@GLib.VariantType.free] on the return value.
282// @type may not be `NULL`.
283func (x *VariantType) Copy() *VariantType {
284
285 cret := xVariantTypeCopy(x.GoPointer())
286 return cret
287}
288
289var xVariantTypeDupString func(uintptr) string
290
291// Returns a newly-allocated copy of the type string corresponding to @type.
292//
293// The returned string is nul-terminated. It is appropriate to call
294// [func@GLib.free] on the return value.
295func (x *VariantType) DupString() string {
296
297 cret := xVariantTypeDupString(x.GoPointer())
298 return cret
299}
300
301var xVariantTypeElement func(uintptr) *VariantType
302
303// Determines the element type of an array or ‘maybe’ type.
304//
305// This function may only be used with array or ‘maybe’ types.
306func (x *VariantType) Element() *VariantType {
307
308 cret := xVariantTypeElement(x.GoPointer())
309 return cret
310}
311
312var xVariantTypeEqual func(uintptr, uintptr) bool
313
314// Compares @type1 and @type2 for equality.
315//
316// Only returns true if the types are exactly equal. Even if one type
317// is an indefinite type and the other is a subtype of it, false will
318// be returned if they are not exactly equal. If you want to check for
319// subtypes, use [method@GLib.VariantType.is_subtype_of].
320//
321// The argument types of @type1 and @type2 are only `gconstpointer` to
322// allow use with [type@GLib.HashTable] without function pointer casting. For
323// both arguments, a valid [type@GLib.VariantType] must be provided.
324func (x *VariantType) Equal(Type2Var uintptr) bool {
325
326 cret := xVariantTypeEqual(x.GoPointer(), Type2Var)
327 return cret
328}
329
330var xVariantTypeFirst func(uintptr) *VariantType
331
332// Determines the first item type of a tuple or dictionary entry
333// type.
334//
335// This function may only be used with tuple or dictionary entry types,
336// but must not be used with the generic tuple type
337// `G_VARIANT_TYPE_TUPLE`.
338//
339// In the case of a dictionary entry type, this returns the type of
340// the key.
341//
342// `NULL` is returned in case of @type being `G_VARIANT_TYPE_UNIT`.
343//
344// This call, together with [method@GLib.VariantType.next] provides an iterator
345// interface over tuple and dictionary entry types.
346func (x *VariantType) First() *VariantType {
347
348 cret := xVariantTypeFirst(x.GoPointer())
349 return cret
350}
351
352var xVariantTypeFree func(uintptr)
353
354// Frees a [type@GLib.VariantType] that was allocated with
355// [method@GLib.VariantType.copy], [ctor@GLib.VariantType.new] or one of the
356// container type constructor functions.
357//
358// In the case that @type is `NULL`, this function does nothing.
359//
360// Since 2.24
361func (x *VariantType) Free() {
362
363 xVariantTypeFree(x.GoPointer())
364
365}
366
367var xVariantTypeGetStringLength func(uintptr) uint
368
369// Returns the length of the type string corresponding to the given @type.
370//
371// This function must be used to determine the valid extent of
372// the memory region returned by [method@GLib.VariantType.peek_string].
373func (x *VariantType) GetStringLength() uint {
374
375 cret := xVariantTypeGetStringLength(x.GoPointer())
376 return cret
377}
378
379var xVariantTypeHash func(uintptr) uint
380
381// Hashes @type.
382//
383// The argument type of @type is only `gconstpointer` to allow use with
384// [type@GLib.HashTable] without function pointer casting. A valid
385// [type@GLib.VariantType] must be provided.
386func (x *VariantType) Hash() uint {
387
388 cret := xVariantTypeHash(x.GoPointer())
389 return cret
390}
391
392var xVariantTypeIsArray func(uintptr) bool
393
394// Determines if the given @type is an array type.
395//
396// This is true if the type string for @type starts with an `a`.
397//
398// This function returns true for any indefinite type for which every
399// definite subtype is an array type — `G_VARIANT_TYPE_ARRAY`, for
400// example.
401func (x *VariantType) IsArray() bool {
402
403 cret := xVariantTypeIsArray(x.GoPointer())
404 return cret
405}
406
407var xVariantTypeIsBasic func(uintptr) bool
408
409// Determines if the given @type is a basic type.
410//
411// Basic types are booleans, bytes, integers, doubles, strings, object
412// paths and signatures.
413//
414// Only a basic type may be used as the key of a dictionary entry.
415//
416// This function returns `FALSE` for all indefinite types except
417// `G_VARIANT_TYPE_BASIC`.
418func (x *VariantType) IsBasic() bool {
419
420 cret := xVariantTypeIsBasic(x.GoPointer())
421 return cret
422}
423
424var xVariantTypeIsContainer func(uintptr) bool
425
426// Determines if the given @type is a container type.
427//
428// Container types are any array, maybe, tuple, or dictionary
429// entry types plus the variant type.
430//
431// This function returns true for any indefinite type for which every
432// definite subtype is a container — `G_VARIANT_TYPE_ARRAY`, for
433// example.
434func (x *VariantType) IsContainer() bool {
435
436 cret := xVariantTypeIsContainer(x.GoPointer())
437 return cret
438}
439
440var xVariantTypeIsDefinite func(uintptr) bool
441
442// Determines if the given @type is definite (ie: not indefinite).
443//
444// A type is definite if its type string does not contain any indefinite
445// type characters (`*`, `?`, or `r`).
446//
447// A [type@GLib.Variant] instance may not have an indefinite type, so calling
448// this function on the result of [method@GLib.Variant.get_type] will always
449// result in true being returned. Calling this function on an
450// indefinite type like `G_VARIANT_TYPE_ARRAY`, however, will result in
451// `FALSE` being returned.
452func (x *VariantType) IsDefinite() bool {
453
454 cret := xVariantTypeIsDefinite(x.GoPointer())
455 return cret
456}
457
458var xVariantTypeIsDictEntry func(uintptr) bool
459
460// Determines if the given @type is a dictionary entry type.
461//
462// This is true if the type string for @type starts with a `{`.
463//
464// This function returns true for any indefinite type for which every
465// definite subtype is a dictionary entry type —
466// `G_VARIANT_TYPE_DICT_ENTRY`, for example.
467func (x *VariantType) IsDictEntry() bool {
468
469 cret := xVariantTypeIsDictEntry(x.GoPointer())
470 return cret
471}
472
473var xVariantTypeIsMaybe func(uintptr) bool
474
475// Determines if the given @type is a ‘maybe’ type.
476//
477// This is true if the type string for @type starts with an `m`.
478//
479// This function returns true for any indefinite type for which every
480// definite subtype is a ‘maybe’ type — `G_VARIANT_TYPE_MAYBE`, for
481// example.
482func (x *VariantType) IsMaybe() bool {
483
484 cret := xVariantTypeIsMaybe(x.GoPointer())
485 return cret
486}
487
488var xVariantTypeIsSubtypeOf func(uintptr, *VariantType) bool
489
490// Checks if @type is a subtype of @supertype.
491//
492// This function returns true if @type is a subtype of @supertype. All
493// types are considered to be subtypes of themselves. Aside from that,
494// only indefinite types can have subtypes.
495func (x *VariantType) IsSubtypeOf(SupertypeVar *VariantType) bool {
496
497 cret := xVariantTypeIsSubtypeOf(x.GoPointer(), SupertypeVar)
498 return cret
499}
500
501var xVariantTypeIsTuple func(uintptr) bool
502
503// Determines if the given @type is a tuple type.
504//
505// This is true if the type string for @type starts with a `(` or if @type is
506// `G_VARIANT_TYPE_TUPLE`.
507//
508// This function returns true for any indefinite type for which every
509// definite subtype is a tuple type — `G_VARIANT_TYPE_TUPLE`, for
510// example.
511func (x *VariantType) IsTuple() bool {
512
513 cret := xVariantTypeIsTuple(x.GoPointer())
514 return cret
515}
516
517var xVariantTypeIsVariant func(uintptr) bool
518
519// Determines if the given @type is the variant type.
520func (x *VariantType) IsVariant() bool {
521
522 cret := xVariantTypeIsVariant(x.GoPointer())
523 return cret
524}
525
526var xVariantTypeKey func(uintptr) *VariantType
527
528// Determines the key type of a dictionary entry type.
529//
530// This function may only be used with a dictionary entry type. Other
531// than the additional restriction, this call is equivalent to
532// [method@GLib.VariantType.first].
533func (x *VariantType) Key() *VariantType {
534
535 cret := xVariantTypeKey(x.GoPointer())
536 return cret
537}
538
539var xVariantTypeNItems func(uintptr) uint
540
541// Determines the number of items contained in a tuple or
542// dictionary entry type.
543//
544// This function may only be used with tuple or dictionary entry types,
545// but must not be used with the generic tuple type
546// `G_VARIANT_TYPE_TUPLE`.
547//
548// In the case of a dictionary entry type, this function will always
549// return `2`.
550func (x *VariantType) NItems() uint {
551
552 cret := xVariantTypeNItems(x.GoPointer())
553 return cret
554}
555
556var xVariantTypeNext func(uintptr) *VariantType
557
558// Determines the next item type of a tuple or dictionary entry
559// type.
560//
561// @type must be the result of a previous call to
562// [method@GLib.VariantType.first] or [method@GLib.VariantType.next].
563//
564// If called on the key type of a dictionary entry then this call
565// returns the value type. If called on the value type of a dictionary
566// entry then this call returns `NULL`.
567//
568// For tuples, `NULL` is returned when @type is the last item in the tuple.
569func (x *VariantType) Next() *VariantType {
570
571 cret := xVariantTypeNext(x.GoPointer())
572 return cret
573}
574
575var xVariantTypePeekString func(uintptr) string
576
577// Returns the type string corresponding to the given @type.
578//
579// The result is not nul-terminated; in order to determine its length you
580// must call [method@GLib.VariantType.get_string_length].
581//
582// To get a nul-terminated string, see [method@GLib.VariantType.dup_string].
583func (x *VariantType) PeekString() string {
584
585 cret := xVariantTypePeekString(x.GoPointer())
586 return cret
587}
588
589var xVariantTypeValue func(uintptr) *VariantType
590
591// Determines the value type of a dictionary entry type.
592//
593// This function may only be used with a dictionary entry type.
594func (x *VariantType) Value() *VariantType {
595
596 cret := xVariantTypeValue(x.GoPointer())
597 return cret
598}
599
600var xVariantTypeChecked func(string) *VariantType
601
602func VariantTypeChecked(TypeStringVar string) *VariantType {
603
604 cret := xVariantTypeChecked(TypeStringVar)
605
606 return cret
607}
608
609var xVariantTypeStringGetDepth func(string) uint
610
611func VariantTypeStringGetDepth(TypeStringVar string) uint {
612
613 cret := xVariantTypeStringGetDepth(TypeStringVar)
614
615 return cret
616}
617
618var xVariantTypeStringIsValid func(string) bool
619
620// Checks if @type_string is a valid
621// [GVariant type string](./struct.VariantType.html#gvariant-type-strings).
622//
623// This call is equivalent to calling [func@GLib.VariantType.string_scan] and
624// confirming that the following character is a nul terminator.
625func VariantTypeStringIsValid(TypeStringVar string) bool {
626
627 cret := xVariantTypeStringIsValid(TypeStringVar)
628
629 return cret
630}
631
632var xVariantTypeStringScan func(string, uintptr, *string) bool
633
634// Scan for a single complete and valid GVariant type string in @string.
635//
636// The memory pointed to by @limit (or bytes beyond it) is never
637// accessed.
638//
639// If a valid type string is found, @endptr is updated to point to the
640// first character past the end of the string that was found and %TRUE
641// is returned.
642//
643// If there is no valid type string starting at @string, or if the type
644// string does not end before @limit then %FALSE is returned.
645//
646// For the simple case of checking if a string is a valid type string,
647// see [func@GLib.VariantType.string_is_valid].
648func VariantTypeStringScan(StringVar string, LimitVar *string, EndptrVar *string) bool {
649
650 LimitVarPtr := core.GStrdupNullable(LimitVar)
651 defer core.GFreeNullable(LimitVarPtr)
652
653 cret := xVariantTypeStringScan(StringVar, LimitVarPtr, EndptrVar)
654
655 return cret
656}
657
658func init() {
659 core.SetPackageName("GLIB", "glib-2.0")
660 core.SetSharedLibraries("GLIB", []string{"libgobject-2.0.so.0", "libglib-2.0.so.0"})
661 var libs []uintptr
662 for _, libPath := range core.GetPaths("GLIB") {
663 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
664 if err != nil {
665 panic(err)
666 }
667 libs = append(libs, lib)
668 }
669
670 core.PuregoSafeRegister(&xVariantTypeChecked, libs, "g_variant_type_checked_")
671 core.PuregoSafeRegister(&xVariantTypeStringGetDepth, libs, "g_variant_type_string_get_depth_")
672 core.PuregoSafeRegister(&xVariantTypeStringIsValid, libs, "g_variant_type_string_is_valid")
673 core.PuregoSafeRegister(&xVariantTypeStringScan, libs, "g_variant_type_string_scan")
674
675 core.PuregoSafeRegister(&xVariantTypeGLibType, libs, "g_variant_type_get_gtype")
676
677 core.PuregoSafeRegister(&xNewVariantType, libs, "g_variant_type_new")
678 core.PuregoSafeRegister(&xNewVariantTypeArray, libs, "g_variant_type_new_array")
679 core.PuregoSafeRegister(&xNewVariantTypeDictEntry, libs, "g_variant_type_new_dict_entry")
680 core.PuregoSafeRegister(&xNewVariantTypeMaybe, libs, "g_variant_type_new_maybe")
681 core.PuregoSafeRegister(&xNewVariantTypeTuple, libs, "g_variant_type_new_tuple")
682
683 core.PuregoSafeRegister(&xVariantTypeCopy, libs, "g_variant_type_copy")
684 core.PuregoSafeRegister(&xVariantTypeDupString, libs, "g_variant_type_dup_string")
685 core.PuregoSafeRegister(&xVariantTypeElement, libs, "g_variant_type_element")
686 core.PuregoSafeRegister(&xVariantTypeEqual, libs, "g_variant_type_equal")
687 core.PuregoSafeRegister(&xVariantTypeFirst, libs, "g_variant_type_first")
688 core.PuregoSafeRegister(&xVariantTypeFree, libs, "g_variant_type_free")
689 core.PuregoSafeRegister(&xVariantTypeGetStringLength, libs, "g_variant_type_get_string_length")
690 core.PuregoSafeRegister(&xVariantTypeHash, libs, "g_variant_type_hash")
691 core.PuregoSafeRegister(&xVariantTypeIsArray, libs, "g_variant_type_is_array")
692 core.PuregoSafeRegister(&xVariantTypeIsBasic, libs, "g_variant_type_is_basic")
693 core.PuregoSafeRegister(&xVariantTypeIsContainer, libs, "g_variant_type_is_container")
694 core.PuregoSafeRegister(&xVariantTypeIsDefinite, libs, "g_variant_type_is_definite")
695 core.PuregoSafeRegister(&xVariantTypeIsDictEntry, libs, "g_variant_type_is_dict_entry")
696 core.PuregoSafeRegister(&xVariantTypeIsMaybe, libs, "g_variant_type_is_maybe")
697 core.PuregoSafeRegister(&xVariantTypeIsSubtypeOf, libs, "g_variant_type_is_subtype_of")
698 core.PuregoSafeRegister(&xVariantTypeIsTuple, libs, "g_variant_type_is_tuple")
699 core.PuregoSafeRegister(&xVariantTypeIsVariant, libs, "g_variant_type_is_variant")
700 core.PuregoSafeRegister(&xVariantTypeKey, libs, "g_variant_type_key")
701 core.PuregoSafeRegister(&xVariantTypeNItems, libs, "g_variant_type_n_items")
702 core.PuregoSafeRegister(&xVariantTypeNext, libs, "g_variant_type_next")
703 core.PuregoSafeRegister(&xVariantTypePeekString, libs, "g_variant_type_peek_string")
704 core.PuregoSafeRegister(&xVariantTypeValue, libs, "g_variant_type_value")
705
706}