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// Specifies the type of function passed to g_tree_traverse(). It is
15// passed the key and value of each node, together with the @user_data
16// parameter passed to g_tree_traverse(). If the function returns
17// %TRUE, the traversal is stopped.
18type TraverseFunc func(uintptr, uintptr, uintptr) bool
19
20// Specifies the type of function passed to g_tree_foreach_node(). It is
21// passed each node, together with the @user_data parameter passed to
22// g_tree_foreach_node(). If the function returns %TRUE, the traversal is
23// stopped.
24type TraverseNodeFunc func(*TreeNode, uintptr) bool
25
26// The GTree struct is an opaque data structure representing a
27// [balanced binary tree](data-structures.html#binary-trees). It should be
28// accessed only by using the following functions.
29type Tree struct {
30 _ structs.HostLayout
31}
32
33var xTreeGLibType func() types.GType
34
35func TreeGLibType() types.GType {
36 return xTreeGLibType()
37}
38
39func (x *Tree) GoPointer() uintptr {
40 return uintptr(unsafe.Pointer(x))
41}
42
43var xNewTree func(uintptr) *Tree
44
45// Creates a new #GTree.
46func NewTree(KeyCompareFuncVar *CompareFunc) *Tree {
47
48 var KeyCompareFuncVarRef uintptr
49 if KeyCompareFuncVar != nil {
50 KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
51 if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
52 KeyCompareFuncVarRef = cbRefPtr
53 } else {
54 fcb := func(arg0 uintptr, arg1 uintptr) int {
55 cbFn := *KeyCompareFuncVar
56 return cbFn(arg0, arg1)
57 }
58 KeyCompareFuncVarRef = purego.NewCallback(fcb)
59 SaveCallbackWithClosure(KeyCompareFuncVarPtr, KeyCompareFuncVarRef, KeyCompareFuncVar)
60 }
61 }
62
63 cret := xNewTree(KeyCompareFuncVarRef)
64 return cret
65}
66
67var xNewTreeFull func(uintptr, uintptr, uintptr, uintptr) *Tree
68
69// Creates a new #GTree like g_tree_new() and allows to specify functions
70// to free the memory allocated for the key and value that get called when
71// removing the entry from the #GTree.
72func NewTreeFull(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar *DestroyNotify, ValueDestroyFuncVar *DestroyNotify) *Tree {
73
74 var KeyCompareFuncVarRef uintptr
75 if KeyCompareFuncVar != nil {
76 KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
77 if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
78 KeyCompareFuncVarRef = cbRefPtr
79 } else {
80 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
81 cbFn := *KeyCompareFuncVar
82 return cbFn(arg0, arg1, arg2)
83 }
84 KeyCompareFuncVarRef = purego.NewCallback(fcb)
85 SaveCallbackWithClosure(KeyCompareFuncVarPtr, KeyCompareFuncVarRef, KeyCompareFuncVar)
86 }
87 }
88
89 var KeyDestroyFuncVarRef uintptr
90 if KeyDestroyFuncVar != nil {
91 KeyDestroyFuncVarPtr := uintptr(unsafe.Pointer(KeyDestroyFuncVar))
92 if cbRefPtr, ok := GetCallback(KeyDestroyFuncVarPtr); ok {
93 KeyDestroyFuncVarRef = cbRefPtr
94 } else {
95 fcb := func(arg0 uintptr) {
96 cbFn := *KeyDestroyFuncVar
97 cbFn(arg0)
98 }
99 KeyDestroyFuncVarRef = purego.NewCallback(fcb)
100 SaveCallbackWithClosure(KeyDestroyFuncVarPtr, KeyDestroyFuncVarRef, KeyDestroyFuncVar)
101 }
102 }
103
104 var ValueDestroyFuncVarRef uintptr
105 if ValueDestroyFuncVar != nil {
106 ValueDestroyFuncVarPtr := uintptr(unsafe.Pointer(ValueDestroyFuncVar))
107 if cbRefPtr, ok := GetCallback(ValueDestroyFuncVarPtr); ok {
108 ValueDestroyFuncVarRef = cbRefPtr
109 } else {
110 fcb := func(arg0 uintptr) {
111 cbFn := *ValueDestroyFuncVar
112 cbFn(arg0)
113 }
114 ValueDestroyFuncVarRef = purego.NewCallback(fcb)
115 SaveCallbackWithClosure(ValueDestroyFuncVarPtr, ValueDestroyFuncVarRef, ValueDestroyFuncVar)
116 }
117 }
118
119 cret := xNewTreeFull(KeyCompareFuncVarRef, KeyCompareDataVar, KeyDestroyFuncVarRef, ValueDestroyFuncVarRef)
120 return cret
121}
122
123var xNewTreeWithData func(uintptr, uintptr) *Tree
124
125// Creates a new #GTree with a comparison function that accepts user data.
126// See g_tree_new() for more details.
127func NewTreeWithData(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr) *Tree {
128
129 var KeyCompareFuncVarRef uintptr
130 if KeyCompareFuncVar != nil {
131 KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
132 if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
133 KeyCompareFuncVarRef = cbRefPtr
134 } else {
135 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
136 cbFn := *KeyCompareFuncVar
137 return cbFn(arg0, arg1, arg2)
138 }
139 KeyCompareFuncVarRef = purego.NewCallback(fcb)
140 SaveCallbackWithClosure(KeyCompareFuncVarPtr, KeyCompareFuncVarRef, KeyCompareFuncVar)
141 }
142 }
143
144 cret := xNewTreeWithData(KeyCompareFuncVarRef, KeyCompareDataVar)
145 return cret
146}
147
148var xTreeDestroy func(uintptr)
149
150// Removes all keys and values from the #GTree and decreases its
151// reference count by one. If keys and/or values are dynamically
152// allocated, you should either free them first or create the #GTree
153// using g_tree_new_full(). In the latter case the destroy functions
154// you supplied will be called on all keys and values before destroying
155// the #GTree.
156func (x *Tree) Destroy() {
157
158 xTreeDestroy(x.GoPointer())
159
160}
161
162var xTreeForeach func(uintptr, uintptr, uintptr)
163
164// Calls the given function for each of the key/value pairs in the #GTree.
165// The function is passed the key and value of each pair, and the given
166// @data parameter. The tree is traversed in sorted order.
167//
168// The tree may not be modified while iterating over it (you can't
169// add/remove items). To remove all items matching a predicate, you need
170// to add each item to a list in your #GTraverseFunc as you walk over
171// the tree, then walk the list and remove each item.
172func (x *Tree) Foreach(FuncVar *TraverseFunc, UserDataVar uintptr) {
173
174 var FuncVarRef uintptr
175 if FuncVar != nil {
176 FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
177 if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
178 FuncVarRef = cbRefPtr
179 } else {
180 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
181 cbFn := *FuncVar
182 return cbFn(arg0, arg1, arg2)
183 }
184 FuncVarRef = purego.NewCallback(fcb)
185 SaveCallbackWithClosure(FuncVarPtr, FuncVarRef, FuncVar)
186 }
187 }
188
189 xTreeForeach(x.GoPointer(), FuncVarRef, UserDataVar)
190
191}
192
193var xTreeForeachNode func(uintptr, uintptr, uintptr)
194
195// Calls the given function for each of the nodes in the #GTree.
196// The function is passed the pointer to the particular node, and the given
197// @data parameter. The tree traversal happens in-order.
198//
199// The tree may not be modified while iterating over it (you can't
200// add/remove items). To remove all items matching a predicate, you need
201// to add each item to a list in your #GTraverseFunc as you walk over
202// the tree, then walk the list and remove each item.
203func (x *Tree) ForeachNode(FuncVar *TraverseNodeFunc, UserDataVar uintptr) {
204
205 var FuncVarRef uintptr
206 if FuncVar != nil {
207 FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
208 if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
209 FuncVarRef = cbRefPtr
210 } else {
211 fcb := func(arg0 *TreeNode, arg1 uintptr) bool {
212 cbFn := *FuncVar
213 return cbFn(arg0, arg1)
214 }
215 FuncVarRef = purego.NewCallback(fcb)
216 SaveCallbackWithClosure(FuncVarPtr, FuncVarRef, FuncVar)
217 }
218 }
219
220 xTreeForeachNode(x.GoPointer(), FuncVarRef, UserDataVar)
221
222}
223
224var xTreeHeight func(uintptr) int
225
226// Gets the height of a #GTree.
227//
228// If the #GTree contains no nodes, the height is 0.
229// If the #GTree contains only one root node the height is 1.
230// If the root node has children the height is 2, etc.
231func (x *Tree) Height() int {
232
233 cret := xTreeHeight(x.GoPointer())
234 return cret
235}
236
237var xTreeInsert func(uintptr, uintptr, uintptr)
238
239// Inserts a key/value pair into a #GTree.
240//
241// Inserts a new key and value into a #GTree as g_tree_insert_node() does,
242// only this function does not return the inserted or set node.
243func (x *Tree) Insert(KeyVar uintptr, ValueVar uintptr) {
244
245 xTreeInsert(x.GoPointer(), KeyVar, ValueVar)
246
247}
248
249var xTreeInsertNode func(uintptr, uintptr, uintptr) *TreeNode
250
251// Inserts a key/value pair into a #GTree.
252//
253// If the given key already exists in the #GTree its corresponding value
254// is set to the new value. If you supplied a @value_destroy_func when
255// creating the #GTree, the old value is freed using that function. If
256// you supplied a @key_destroy_func when creating the #GTree, the passed
257// key is freed using that function.
258//
259// The tree is automatically 'balanced' as new key/value pairs are added,
260// so that the distance from the root to every leaf is as small as possible.
261// The cost of maintaining a balanced tree while inserting new key/value
262// result in a O(n log(n)) operation where most of the other operations
263// are O(log(n)).
264func (x *Tree) InsertNode(KeyVar uintptr, ValueVar uintptr) *TreeNode {
265
266 cret := xTreeInsertNode(x.GoPointer(), KeyVar, ValueVar)
267 return cret
268}
269
270var xTreeLookup func(uintptr, uintptr) uintptr
271
272// Gets the value corresponding to the given key. Since a #GTree is
273// automatically balanced as key/value pairs are added, key lookup
274// is O(log n) (where n is the number of key/value pairs in the tree).
275func (x *Tree) Lookup(KeyVar uintptr) uintptr {
276
277 cret := xTreeLookup(x.GoPointer(), KeyVar)
278 return cret
279}
280
281var xTreeLookupExtended func(uintptr, uintptr, *uintptr, *uintptr) bool
282
283// Looks up a key in the #GTree, returning the original key and the
284// associated value. This is useful if you need to free the memory
285// allocated for the original key, for example before calling
286// g_tree_remove().
287func (x *Tree) LookupExtended(LookupKeyVar uintptr, OrigKeyVar *uintptr, ValueVar *uintptr) bool {
288
289 cret := xTreeLookupExtended(x.GoPointer(), LookupKeyVar, OrigKeyVar, ValueVar)
290 return cret
291}
292
293var xTreeLookupNode func(uintptr, uintptr) *TreeNode
294
295// Gets the tree node corresponding to the given key. Since a #GTree is
296// automatically balanced as key/value pairs are added, key lookup
297// is O(log n) (where n is the number of key/value pairs in the tree).
298func (x *Tree) LookupNode(KeyVar uintptr) *TreeNode {
299
300 cret := xTreeLookupNode(x.GoPointer(), KeyVar)
301 return cret
302}
303
304var xTreeLowerBound func(uintptr, uintptr) *TreeNode
305
306// Gets the lower bound node corresponding to the given key,
307// or %NULL if the tree is empty or all the nodes in the tree
308// have keys that are strictly lower than the searched key.
309//
310// The lower bound is the first node that has its key greater
311// than or equal to the searched key.
312func (x *Tree) LowerBound(KeyVar uintptr) *TreeNode {
313
314 cret := xTreeLowerBound(x.GoPointer(), KeyVar)
315 return cret
316}
317
318var xTreeNnodes func(uintptr) int
319
320// Gets the number of nodes in a #GTree.
321func (x *Tree) Nnodes() int {
322
323 cret := xTreeNnodes(x.GoPointer())
324 return cret
325}
326
327var xTreeNodeFirst func(uintptr) *TreeNode
328
329// Returns the first in-order node of the tree, or %NULL
330// for an empty tree.
331func (x *Tree) NodeFirst() *TreeNode {
332
333 cret := xTreeNodeFirst(x.GoPointer())
334 return cret
335}
336
337var xTreeNodeLast func(uintptr) *TreeNode
338
339// Returns the last in-order node of the tree, or %NULL
340// for an empty tree.
341func (x *Tree) NodeLast() *TreeNode {
342
343 cret := xTreeNodeLast(x.GoPointer())
344 return cret
345}
346
347var xTreeRef func(uintptr) *Tree
348
349// Increments the reference count of @tree by one.
350//
351// It is safe to call this function from any thread.
352func (x *Tree) Ref() *Tree {
353
354 cret := xTreeRef(x.GoPointer())
355 return cret
356}
357
358var xTreeRemove func(uintptr, uintptr) bool
359
360// Removes a key/value pair from a #GTree.
361//
362// If the #GTree was created using g_tree_new_full(), the key and value
363// are freed using the supplied destroy functions, otherwise you have to
364// make sure that any dynamically allocated values are freed yourself.
365// If the key does not exist in the #GTree, the function does nothing.
366//
367// The cost of maintaining a balanced tree while removing a key/value
368// result in a O(n log(n)) operation where most of the other operations
369// are O(log(n)).
370func (x *Tree) Remove(KeyVar uintptr) bool {
371
372 cret := xTreeRemove(x.GoPointer(), KeyVar)
373 return cret
374}
375
376var xTreeRemoveAll func(uintptr)
377
378// Removes all nodes from a #GTree and destroys their keys and values,
379// then resets the #GTree’s root to %NULL.
380func (x *Tree) RemoveAll() {
381
382 xTreeRemoveAll(x.GoPointer())
383
384}
385
386var xTreeReplace func(uintptr, uintptr, uintptr)
387
388// Inserts a new key and value into a #GTree as g_tree_replace_node() does,
389// only this function does not return the inserted or set node.
390func (x *Tree) Replace(KeyVar uintptr, ValueVar uintptr) {
391
392 xTreeReplace(x.GoPointer(), KeyVar, ValueVar)
393
394}
395
396var xTreeReplaceNode func(uintptr, uintptr, uintptr) *TreeNode
397
398// Inserts a new key and value into a #GTree similar to g_tree_insert_node().
399// The difference is that if the key already exists in the #GTree, it gets
400// replaced by the new key. If you supplied a @value_destroy_func when
401// creating the #GTree, the old value is freed using that function. If you
402// supplied a @key_destroy_func when creating the #GTree, the old key is
403// freed using that function.
404//
405// The tree is automatically 'balanced' as new key/value pairs are added,
406// so that the distance from the root to every leaf is as small as possible.
407func (x *Tree) ReplaceNode(KeyVar uintptr, ValueVar uintptr) *TreeNode {
408
409 cret := xTreeReplaceNode(x.GoPointer(), KeyVar, ValueVar)
410 return cret
411}
412
413var xTreeSearch func(uintptr, uintptr, uintptr) uintptr
414
415// Searches a #GTree using @search_func.
416//
417// The @search_func is called with a pointer to the key of a key/value
418// pair in the tree, and the passed in @user_data. If @search_func returns
419// 0 for a key/value pair, then the corresponding value is returned as
420// the result of g_tree_search(). If @search_func returns -1, searching
421// will proceed among the key/value pairs that have a smaller key; if
422// @search_func returns 1, searching will proceed among the key/value
423// pairs that have a larger key.
424func (x *Tree) Search(SearchFuncVar *CompareFunc, UserDataVar uintptr) uintptr {
425
426 var SearchFuncVarRef uintptr
427 if SearchFuncVar != nil {
428 SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
429 if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
430 SearchFuncVarRef = cbRefPtr
431 } else {
432 fcb := func(arg0 uintptr, arg1 uintptr) int {
433 cbFn := *SearchFuncVar
434 return cbFn(arg0, arg1)
435 }
436 SearchFuncVarRef = purego.NewCallback(fcb)
437 SaveCallbackWithClosure(SearchFuncVarPtr, SearchFuncVarRef, SearchFuncVar)
438 }
439 }
440
441 cret := xTreeSearch(x.GoPointer(), SearchFuncVarRef, UserDataVar)
442 return cret
443}
444
445var xTreeSearchNode func(uintptr, uintptr, uintptr) *TreeNode
446
447// Searches a #GTree using @search_func.
448//
449// The @search_func is called with a pointer to the key of a key/value
450// pair in the tree, and the passed in @user_data. If @search_func returns
451// 0 for a key/value pair, then the corresponding node is returned as
452// the result of g_tree_search(). If @search_func returns -1, searching
453// will proceed among the key/value pairs that have a smaller key; if
454// @search_func returns 1, searching will proceed among the key/value
455// pairs that have a larger key.
456func (x *Tree) SearchNode(SearchFuncVar *CompareFunc, UserDataVar uintptr) *TreeNode {
457
458 var SearchFuncVarRef uintptr
459 if SearchFuncVar != nil {
460 SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
461 if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
462 SearchFuncVarRef = cbRefPtr
463 } else {
464 fcb := func(arg0 uintptr, arg1 uintptr) int {
465 cbFn := *SearchFuncVar
466 return cbFn(arg0, arg1)
467 }
468 SearchFuncVarRef = purego.NewCallback(fcb)
469 SaveCallbackWithClosure(SearchFuncVarPtr, SearchFuncVarRef, SearchFuncVar)
470 }
471 }
472
473 cret := xTreeSearchNode(x.GoPointer(), SearchFuncVarRef, UserDataVar)
474 return cret
475}
476
477var xTreeSteal func(uintptr, uintptr) bool
478
479// Removes a key and its associated value from a #GTree without calling
480// the key and value destroy functions.
481//
482// If the key does not exist in the #GTree, the function does nothing.
483func (x *Tree) Steal(KeyVar uintptr) bool {
484
485 cret := xTreeSteal(x.GoPointer(), KeyVar)
486 return cret
487}
488
489var xTreeTraverse func(uintptr, uintptr, TraverseType, uintptr)
490
491// Calls the given function for each node in the #GTree.
492func (x *Tree) Traverse(TraverseFuncVar *TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {
493
494 var TraverseFuncVarRef uintptr
495 if TraverseFuncVar != nil {
496 TraverseFuncVarPtr := uintptr(unsafe.Pointer(TraverseFuncVar))
497 if cbRefPtr, ok := GetCallback(TraverseFuncVarPtr); ok {
498 TraverseFuncVarRef = cbRefPtr
499 } else {
500 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
501 cbFn := *TraverseFuncVar
502 return cbFn(arg0, arg1, arg2)
503 }
504 TraverseFuncVarRef = purego.NewCallback(fcb)
505 SaveCallbackWithClosure(TraverseFuncVarPtr, TraverseFuncVarRef, TraverseFuncVar)
506 }
507 }
508
509 xTreeTraverse(x.GoPointer(), TraverseFuncVarRef, TraverseTypeVar, UserDataVar)
510
511}
512
513var xTreeUnref func(uintptr)
514
515// Decrements the reference count of @tree by one.
516// If the reference count drops to 0, all keys and values will
517// be destroyed (if destroy functions were specified) and all
518// memory allocated by @tree will be released.
519//
520// It is safe to call this function from any thread.
521func (x *Tree) Unref() {
522
523 xTreeUnref(x.GoPointer())
524
525}
526
527var xTreeUpperBound func(uintptr, uintptr) *TreeNode
528
529// Gets the upper bound node corresponding to the given key,
530// or %NULL if the tree is empty or all the nodes in the tree
531// have keys that are lower than or equal to the searched key.
532//
533// The upper bound is the first node that has its key strictly greater
534// than the searched key.
535func (x *Tree) UpperBound(KeyVar uintptr) *TreeNode {
536
537 cret := xTreeUpperBound(x.GoPointer(), KeyVar)
538 return cret
539}
540
541// An opaque type which identifies a specific node in a #GTree.
542type TreeNode struct {
543 _ structs.HostLayout
544}
545
546func (x *TreeNode) GoPointer() uintptr {
547 return uintptr(unsafe.Pointer(x))
548}
549
550var xTreeNodeKey func(uintptr) uintptr
551
552// Gets the key stored at a particular tree node.
553func (x *TreeNode) Key() uintptr {
554
555 cret := xTreeNodeKey(x.GoPointer())
556 return cret
557}
558
559var xTreeNodeNext func(uintptr) *TreeNode
560
561// Returns the next in-order node of the tree, or %NULL
562// if the passed node was already the last one.
563func (x *TreeNode) Next() *TreeNode {
564
565 cret := xTreeNodeNext(x.GoPointer())
566 return cret
567}
568
569var xTreeNodePrevious func(uintptr) *TreeNode
570
571// Returns the previous in-order node of the tree, or %NULL
572// if the passed node was already the first one.
573func (x *TreeNode) Previous() *TreeNode {
574
575 cret := xTreeNodePrevious(x.GoPointer())
576 return cret
577}
578
579var xTreeNodeValue func(uintptr) uintptr
580
581// Gets the value stored at a particular tree node.
582func (x *TreeNode) Value() uintptr {
583
584 cret := xTreeNodeValue(x.GoPointer())
585 return cret
586}
587
588func init() {
589 core.SetPackageName("GLIB", "glib-2.0")
590 core.SetSharedLibraries("GLIB", []string{"libgobject-2.0.so.0", "libglib-2.0.so.0"})
591 var libs []uintptr
592 for _, libPath := range core.GetPaths("GLIB") {
593 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
594 if err != nil {
595 panic(err)
596 }
597 libs = append(libs, lib)
598 }
599
600 core.PuregoSafeRegister(&xTreeGLibType, libs, "g_tree_get_type")
601
602 core.PuregoSafeRegister(&xNewTree, libs, "g_tree_new")
603 core.PuregoSafeRegister(&xNewTreeFull, libs, "g_tree_new_full")
604 core.PuregoSafeRegister(&xNewTreeWithData, libs, "g_tree_new_with_data")
605
606 core.PuregoSafeRegister(&xTreeDestroy, libs, "g_tree_destroy")
607 core.PuregoSafeRegister(&xTreeForeach, libs, "g_tree_foreach")
608 core.PuregoSafeRegister(&xTreeForeachNode, libs, "g_tree_foreach_node")
609 core.PuregoSafeRegister(&xTreeHeight, libs, "g_tree_height")
610 core.PuregoSafeRegister(&xTreeInsert, libs, "g_tree_insert")
611 core.PuregoSafeRegister(&xTreeInsertNode, libs, "g_tree_insert_node")
612 core.PuregoSafeRegister(&xTreeLookup, libs, "g_tree_lookup")
613 core.PuregoSafeRegister(&xTreeLookupExtended, libs, "g_tree_lookup_extended")
614 core.PuregoSafeRegister(&xTreeLookupNode, libs, "g_tree_lookup_node")
615 core.PuregoSafeRegister(&xTreeLowerBound, libs, "g_tree_lower_bound")
616 core.PuregoSafeRegister(&xTreeNnodes, libs, "g_tree_nnodes")
617 core.PuregoSafeRegister(&xTreeNodeFirst, libs, "g_tree_node_first")
618 core.PuregoSafeRegister(&xTreeNodeLast, libs, "g_tree_node_last")
619 core.PuregoSafeRegister(&xTreeRef, libs, "g_tree_ref")
620 core.PuregoSafeRegister(&xTreeRemove, libs, "g_tree_remove")
621 core.PuregoSafeRegister(&xTreeRemoveAll, libs, "g_tree_remove_all")
622 core.PuregoSafeRegister(&xTreeReplace, libs, "g_tree_replace")
623 core.PuregoSafeRegister(&xTreeReplaceNode, libs, "g_tree_replace_node")
624 core.PuregoSafeRegister(&xTreeSearch, libs, "g_tree_search")
625 core.PuregoSafeRegister(&xTreeSearchNode, libs, "g_tree_search_node")
626 core.PuregoSafeRegister(&xTreeSteal, libs, "g_tree_steal")
627 core.PuregoSafeRegister(&xTreeTraverse, libs, "g_tree_traverse")
628 core.PuregoSafeRegister(&xTreeUnref, libs, "g_tree_unref")
629 core.PuregoSafeRegister(&xTreeUpperBound, libs, "g_tree_upper_bound")
630
631 core.PuregoSafeRegister(&xTreeNodeKey, libs, "g_tree_node_key")
632 core.PuregoSafeRegister(&xTreeNodeNext, libs, "g_tree_node_next")
633 core.PuregoSafeRegister(&xTreeNodePrevious, libs, "g_tree_node_previous")
634 core.PuregoSafeRegister(&xTreeNodeValue, libs, "g_tree_node_value")
635
636}