1// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gio
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/glib"
12 "github.com/bnema/puregotk/v4/gobject/types"
13)
14
15type FileIOStreamClass struct {
16 _ structs.HostLayout
17
18 ParentClass IOStreamClass
19
20 xTell uintptr
21
22 xCanSeek uintptr
23
24 xSeek uintptr
25
26 xCanTruncate uintptr
27
28 xTruncateFn uintptr
29
30 xQueryInfo uintptr
31
32 xQueryInfoAsync uintptr
33
34 xQueryInfoFinish uintptr
35
36 xGetEtag uintptr
37
38 xGReserved1 uintptr
39
40 xGReserved2 uintptr
41
42 xGReserved3 uintptr
43
44 xGReserved4 uintptr
45
46 xGReserved5 uintptr
47}
48
49func (x *FileIOStreamClass) GoPointer() uintptr {
50 return uintptr(unsafe.Pointer(x))
51}
52
53// OverrideTell sets the "tell" callback function.
54func (x *FileIOStreamClass) OverrideTell(cb func(*FileIOStream) int64) {
55 if cb == nil {
56 x.xTell = 0
57 } else {
58 x.xTell = purego.NewCallback(func(StreamVarp uintptr) int64 {
59 return cb(FileIOStreamNewFromInternalPtr(StreamVarp))
60 })
61 }
62}
63
64// GetTell gets the "tell" callback function.
65func (x *FileIOStreamClass) GetTell() func(*FileIOStream) int64 {
66 if x.xTell == 0 {
67 return nil
68 }
69 var rawCallback func(StreamVarp uintptr) int64
70 purego.RegisterFunc(&rawCallback, x.xTell)
71 return func(StreamVar *FileIOStream) int64 {
72 return rawCallback(StreamVar.GoPointer())
73 }
74}
75
76// OverrideCanSeek sets the "can_seek" callback function.
77func (x *FileIOStreamClass) OverrideCanSeek(cb func(*FileIOStream) bool) {
78 if cb == nil {
79 x.xCanSeek = 0
80 } else {
81 x.xCanSeek = purego.NewCallback(func(StreamVarp uintptr) bool {
82 return cb(FileIOStreamNewFromInternalPtr(StreamVarp))
83 })
84 }
85}
86
87// GetCanSeek gets the "can_seek" callback function.
88func (x *FileIOStreamClass) GetCanSeek() func(*FileIOStream) bool {
89 if x.xCanSeek == 0 {
90 return nil
91 }
92 var rawCallback func(StreamVarp uintptr) bool
93 purego.RegisterFunc(&rawCallback, x.xCanSeek)
94 return func(StreamVar *FileIOStream) bool {
95 return rawCallback(StreamVar.GoPointer())
96 }
97}
98
99// OverrideSeek sets the "seek" callback function.
100func (x *FileIOStreamClass) OverrideSeek(cb func(*FileIOStream, int64, glib.SeekType, *Cancellable) bool) {
101 if cb == nil {
102 x.xSeek = 0
103 } else {
104 x.xSeek = purego.NewCallback(func(StreamVarp uintptr, OffsetVarp int64, TypeVarp glib.SeekType, CancellableVarp uintptr) bool {
105 return cb(FileIOStreamNewFromInternalPtr(StreamVarp), OffsetVarp, TypeVarp, CancellableNewFromInternalPtr(CancellableVarp))
106 })
107 }
108}
109
110// GetSeek gets the "seek" callback function.
111func (x *FileIOStreamClass) GetSeek() func(*FileIOStream, int64, glib.SeekType, *Cancellable) bool {
112 if x.xSeek == 0 {
113 return nil
114 }
115 var rawCallback func(StreamVarp uintptr, OffsetVarp int64, TypeVarp glib.SeekType, CancellableVarp uintptr) bool
116 purego.RegisterFunc(&rawCallback, x.xSeek)
117 return func(StreamVar *FileIOStream, OffsetVar int64, TypeVar glib.SeekType, CancellableVar *Cancellable) bool {
118 return rawCallback(StreamVar.GoPointer(), OffsetVar, TypeVar, CancellableVar.GoPointer())
119 }
120}
121
122// OverrideCanTruncate sets the "can_truncate" callback function.
123func (x *FileIOStreamClass) OverrideCanTruncate(cb func(*FileIOStream) bool) {
124 if cb == nil {
125 x.xCanTruncate = 0
126 } else {
127 x.xCanTruncate = purego.NewCallback(func(StreamVarp uintptr) bool {
128 return cb(FileIOStreamNewFromInternalPtr(StreamVarp))
129 })
130 }
131}
132
133// GetCanTruncate gets the "can_truncate" callback function.
134func (x *FileIOStreamClass) GetCanTruncate() func(*FileIOStream) bool {
135 if x.xCanTruncate == 0 {
136 return nil
137 }
138 var rawCallback func(StreamVarp uintptr) bool
139 purego.RegisterFunc(&rawCallback, x.xCanTruncate)
140 return func(StreamVar *FileIOStream) bool {
141 return rawCallback(StreamVar.GoPointer())
142 }
143}
144
145// OverrideTruncateFn sets the "truncate_fn" callback function.
146func (x *FileIOStreamClass) OverrideTruncateFn(cb func(*FileIOStream, int64, *Cancellable) bool) {
147 if cb == nil {
148 x.xTruncateFn = 0
149 } else {
150 x.xTruncateFn = purego.NewCallback(func(StreamVarp uintptr, SizeVarp int64, CancellableVarp uintptr) bool {
151 return cb(FileIOStreamNewFromInternalPtr(StreamVarp), SizeVarp, CancellableNewFromInternalPtr(CancellableVarp))
152 })
153 }
154}
155
156// GetTruncateFn gets the "truncate_fn" callback function.
157func (x *FileIOStreamClass) GetTruncateFn() func(*FileIOStream, int64, *Cancellable) bool {
158 if x.xTruncateFn == 0 {
159 return nil
160 }
161 var rawCallback func(StreamVarp uintptr, SizeVarp int64, CancellableVarp uintptr) bool
162 purego.RegisterFunc(&rawCallback, x.xTruncateFn)
163 return func(StreamVar *FileIOStream, SizeVar int64, CancellableVar *Cancellable) bool {
164 return rawCallback(StreamVar.GoPointer(), SizeVar, CancellableVar.GoPointer())
165 }
166}
167
168// OverrideQueryInfo sets the "query_info" callback function.
169func (x *FileIOStreamClass) OverrideQueryInfo(cb func(*FileIOStream, string, *Cancellable) *FileInfo) {
170 if cb == nil {
171 x.xQueryInfo = 0
172 } else {
173 x.xQueryInfo = purego.NewCallback(func(StreamVarp uintptr, AttributesVarp string, CancellableVarp uintptr) uintptr {
174 ret := cb(FileIOStreamNewFromInternalPtr(StreamVarp), AttributesVarp, CancellableNewFromInternalPtr(CancellableVarp))
175 if ret == nil {
176 return 0
177 }
178 return ret.GoPointer()
179 })
180 }
181}
182
183// GetQueryInfo gets the "query_info" callback function.
184func (x *FileIOStreamClass) GetQueryInfo() func(*FileIOStream, string, *Cancellable) *FileInfo {
185 if x.xQueryInfo == 0 {
186 return nil
187 }
188 var rawCallback func(StreamVarp uintptr, AttributesVarp string, CancellableVarp uintptr) uintptr
189 purego.RegisterFunc(&rawCallback, x.xQueryInfo)
190 return func(StreamVar *FileIOStream, AttributesVar string, CancellableVar *Cancellable) *FileInfo {
191 rawRet := rawCallback(StreamVar.GoPointer(), AttributesVar, CancellableVar.GoPointer())
192 if rawRet == 0 {
193 return nil
194 }
195 ret := &FileInfo{}
196 ret.Ptr = rawRet
197 return ret
198 }
199}
200
201// OverrideQueryInfoAsync sets the "query_info_async" callback function.
202func (x *FileIOStreamClass) OverrideQueryInfoAsync(cb func(*FileIOStream, string, int, *Cancellable, *AsyncReadyCallback, uintptr)) {
203 if cb == nil {
204 x.xQueryInfoAsync = 0
205 } else {
206 x.xQueryInfoAsync = purego.NewCallback(func(StreamVarp uintptr, AttributesVarp string, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
207 cb(FileIOStreamNewFromInternalPtr(StreamVarp), AttributesVarp, IoPriorityVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
208 })
209 }
210}
211
212// GetQueryInfoAsync gets the "query_info_async" callback function.
213func (x *FileIOStreamClass) GetQueryInfoAsync() func(*FileIOStream, string, int, *Cancellable, *AsyncReadyCallback, uintptr) {
214 if x.xQueryInfoAsync == 0 {
215 return nil
216 }
217 var rawCallback func(StreamVarp uintptr, AttributesVarp string, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
218 purego.RegisterFunc(&rawCallback, x.xQueryInfoAsync)
219 return func(StreamVar *FileIOStream, AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
220 rawCallback(StreamVar.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
221 }
222}
223
224// OverrideQueryInfoFinish sets the "query_info_finish" callback function.
225func (x *FileIOStreamClass) OverrideQueryInfoFinish(cb func(*FileIOStream, AsyncResult) *FileInfo) {
226 if cb == nil {
227 x.xQueryInfoFinish = 0
228 } else {
229 x.xQueryInfoFinish = purego.NewCallback(func(StreamVarp uintptr, ResultVarp uintptr) uintptr {
230 ret := cb(FileIOStreamNewFromInternalPtr(StreamVarp), &AsyncResultBase{Ptr: ResultVarp})
231 if ret == nil {
232 return 0
233 }
234 return ret.GoPointer()
235 })
236 }
237}
238
239// GetQueryInfoFinish gets the "query_info_finish" callback function.
240func (x *FileIOStreamClass) GetQueryInfoFinish() func(*FileIOStream, AsyncResult) *FileInfo {
241 if x.xQueryInfoFinish == 0 {
242 return nil
243 }
244 var rawCallback func(StreamVarp uintptr, ResultVarp uintptr) uintptr
245 purego.RegisterFunc(&rawCallback, x.xQueryInfoFinish)
246 return func(StreamVar *FileIOStream, ResultVar AsyncResult) *FileInfo {
247 rawRet := rawCallback(StreamVar.GoPointer(), ResultVar.GoPointer())
248 if rawRet == 0 {
249 return nil
250 }
251 ret := &FileInfo{}
252 ret.Ptr = rawRet
253 return ret
254 }
255}
256
257// OverrideGetEtag sets the "get_etag" callback function.
258func (x *FileIOStreamClass) OverrideGetEtag(cb func(*FileIOStream) string) {
259 if cb == nil {
260 x.xGetEtag = 0
261 } else {
262 x.xGetEtag = purego.NewCallback(func(StreamVarp uintptr) string {
263 return cb(FileIOStreamNewFromInternalPtr(StreamVarp))
264 })
265 }
266}
267
268// GetGetEtag gets the "get_etag" callback function.
269func (x *FileIOStreamClass) GetGetEtag() func(*FileIOStream) string {
270 if x.xGetEtag == 0 {
271 return nil
272 }
273 var rawCallback func(StreamVarp uintptr) string
274 purego.RegisterFunc(&rawCallback, x.xGetEtag)
275 return func(StreamVar *FileIOStream) string {
276 return rawCallback(StreamVar.GoPointer())
277 }
278}
279
280// OverrideGReserved1 sets the "_g_reserved1" callback function.
281func (x *FileIOStreamClass) OverrideGReserved1(cb func()) {
282 if cb == nil {
283 x.xGReserved1 = 0
284 } else {
285 x.xGReserved1 = purego.NewCallback(func() {
286 cb()
287 })
288 }
289}
290
291// GetGReserved1 gets the "_g_reserved1" callback function.
292func (x *FileIOStreamClass) GetGReserved1() func() {
293 if x.xGReserved1 == 0 {
294 return nil
295 }
296 var rawCallback func()
297 purego.RegisterFunc(&rawCallback, x.xGReserved1)
298 return func() {
299 rawCallback()
300 }
301}
302
303// OverrideGReserved2 sets the "_g_reserved2" callback function.
304func (x *FileIOStreamClass) OverrideGReserved2(cb func()) {
305 if cb == nil {
306 x.xGReserved2 = 0
307 } else {
308 x.xGReserved2 = purego.NewCallback(func() {
309 cb()
310 })
311 }
312}
313
314// GetGReserved2 gets the "_g_reserved2" callback function.
315func (x *FileIOStreamClass) GetGReserved2() func() {
316 if x.xGReserved2 == 0 {
317 return nil
318 }
319 var rawCallback func()
320 purego.RegisterFunc(&rawCallback, x.xGReserved2)
321 return func() {
322 rawCallback()
323 }
324}
325
326// OverrideGReserved3 sets the "_g_reserved3" callback function.
327func (x *FileIOStreamClass) OverrideGReserved3(cb func()) {
328 if cb == nil {
329 x.xGReserved3 = 0
330 } else {
331 x.xGReserved3 = purego.NewCallback(func() {
332 cb()
333 })
334 }
335}
336
337// GetGReserved3 gets the "_g_reserved3" callback function.
338func (x *FileIOStreamClass) GetGReserved3() func() {
339 if x.xGReserved3 == 0 {
340 return nil
341 }
342 var rawCallback func()
343 purego.RegisterFunc(&rawCallback, x.xGReserved3)
344 return func() {
345 rawCallback()
346 }
347}
348
349// OverrideGReserved4 sets the "_g_reserved4" callback function.
350func (x *FileIOStreamClass) OverrideGReserved4(cb func()) {
351 if cb == nil {
352 x.xGReserved4 = 0
353 } else {
354 x.xGReserved4 = purego.NewCallback(func() {
355 cb()
356 })
357 }
358}
359
360// GetGReserved4 gets the "_g_reserved4" callback function.
361func (x *FileIOStreamClass) GetGReserved4() func() {
362 if x.xGReserved4 == 0 {
363 return nil
364 }
365 var rawCallback func()
366 purego.RegisterFunc(&rawCallback, x.xGReserved4)
367 return func() {
368 rawCallback()
369 }
370}
371
372// OverrideGReserved5 sets the "_g_reserved5" callback function.
373func (x *FileIOStreamClass) OverrideGReserved5(cb func()) {
374 if cb == nil {
375 x.xGReserved5 = 0
376 } else {
377 x.xGReserved5 = purego.NewCallback(func() {
378 cb()
379 })
380 }
381}
382
383// GetGReserved5 gets the "_g_reserved5" callback function.
384func (x *FileIOStreamClass) GetGReserved5() func() {
385 if x.xGReserved5 == 0 {
386 return nil
387 }
388 var rawCallback func()
389 purego.RegisterFunc(&rawCallback, x.xGReserved5)
390 return func() {
391 rawCallback()
392 }
393}
394
395type FileIOStreamPrivate struct {
396 _ structs.HostLayout
397}
398
399func (x *FileIOStreamPrivate) GoPointer() uintptr {
400 return uintptr(unsafe.Pointer(x))
401}
402
403// `GFileIOStream` provides I/O streams that both read and write to the same
404// file handle.
405//
406// `GFileIOStream` implements [iface@Gio.Seekable], which allows the I/O
407// stream to jump to arbitrary positions in the file and to truncate
408// the file, provided the filesystem of the file supports these
409// operations.
410//
411// To find the position of a file I/O stream, use [method@Gio.Seekable.tell].
412//
413// To find out if a file I/O stream supports seeking, use
414// [method@Gio.Seekable.can_seek]. To position a file I/O stream, use
415// [method@Gio.Seekable.seek]. To find out if a file I/O stream supports
416// truncating, use [method@Gio.Seekable.can_truncate]. To truncate a file I/O
417// stream, use [method@Gio.Seekable.truncate].
418//
419// The default implementation of all the `GFileIOStream` operations
420// and the implementation of [iface@Gio.Seekable] just call into the same
421// operations on the output stream.
422type FileIOStream struct {
423 IOStream
424}
425
426var xFileIOStreamGLibType func() types.GType
427
428func FileIOStreamGLibType() types.GType {
429 return xFileIOStreamGLibType()
430}
431
432func FileIOStreamNewFromInternalPtr(ptr uintptr) *FileIOStream {
433 cls := &FileIOStream{}
434 cls.Ptr = ptr
435 return cls
436}
437
438var xFileIOStreamGetEtag func(uintptr) string
439
440// Gets the entity tag for the file when it has been written.
441// This must be called after the stream has been written
442// and closed, as the etag can change while writing.
443func (x *FileIOStream) GetEtag() string {
444
445 cret := xFileIOStreamGetEtag(x.GoPointer())
446 return cret
447}
448
449var xFileIOStreamQueryInfo func(uintptr, string, uintptr, **glib.Error) uintptr
450
451// Queries a file io stream for the given @attributes.
452// This function blocks while querying the stream. For the asynchronous
453// version of this function, see g_file_io_stream_query_info_async().
454// While the stream is blocked, the stream will set the pending flag
455// internally, and any other operations on the stream will fail with
456// %G_IO_ERROR_PENDING.
457//
458// Can fail if the stream was already closed (with @error being set to
459// %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being
460// set to %G_IO_ERROR_PENDING), or if querying info is not supported for
461// the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). I
462// all cases of failure, %NULL will be returned.
463//
464// If @cancellable is not %NULL, then the operation can be cancelled by
465// triggering the cancellable object from another thread. If the operation
466// was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
467// be returned.
468func (x *FileIOStream) QueryInfo(AttributesVar string, CancellableVar *Cancellable) (*FileInfo, error) {
469 var cls *FileInfo
470 var cerr *glib.Error
471
472 cret := xFileIOStreamQueryInfo(x.GoPointer(), AttributesVar, CancellableVar.GoPointer(), &cerr)
473
474 if cret == 0 {
475 return nil, cerr
476 }
477 cls = &FileInfo{}
478 cls.Ptr = cret
479 if cerr == nil {
480 return cls, nil
481 }
482 return cls, cerr
483
484}
485
486var xFileIOStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr, uintptr)
487
488// Asynchronously queries the @stream for a #GFileInfo. When completed,
489// @callback will be called with a #GAsyncResult which can be used to
490// finish the operation with g_file_io_stream_query_info_finish().
491//
492// For the synchronous version of this function, see
493// g_file_io_stream_query_info().
494func (x *FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
495
496 var CallbackVarRef uintptr
497 if CallbackVar != nil {
498 CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
499 if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
500 CallbackVarRef = cbRefPtr
501 } else {
502 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
503 cbFn := *CallbackVar
504 cbFn(arg0, arg1, arg2)
505 }
506 CallbackVarRef = purego.NewCallback(fcb)
507 glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
508 }
509 }
510
511 xFileIOStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
512
513}
514
515var xFileIOStreamQueryInfoFinish func(uintptr, uintptr, **glib.Error) uintptr
516
517// Finalizes the asynchronous query started
518// by g_file_io_stream_query_info_async().
519func (x *FileIOStream) QueryInfoFinish(ResultVar AsyncResult) (*FileInfo, error) {
520 var cls *FileInfo
521 var cerr *glib.Error
522
523 cret := xFileIOStreamQueryInfoFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
524
525 if cret == 0 {
526 return nil, cerr
527 }
528 cls = &FileInfo{}
529 cls.Ptr = cret
530 if cerr == nil {
531 return cls, nil
532 }
533 return cls, cerr
534
535}
536
537func (c *FileIOStream) GoPointer() uintptr {
538 if c == nil {
539 return 0
540 }
541 return c.Ptr
542}
543
544func (c *FileIOStream) SetGoPointer(ptr uintptr) {
545 c.Ptr = ptr
546}
547
548// Tests if the stream supports the #GSeekableIface.
549func (x *FileIOStream) CanSeek() bool {
550
551 cret := XGSeekableCanSeek(x.GoPointer())
552 return cret
553}
554
555// Tests if the length of the stream can be adjusted with
556// g_seekable_truncate().
557func (x *FileIOStream) CanTruncate() bool {
558
559 cret := XGSeekableCanTruncate(x.GoPointer())
560 return cret
561}
562
563// Seeks in the stream by the given @offset, modified by @type.
564//
565// Attempting to seek past the end of the stream will have different
566// results depending on if the stream is fixed-sized or resizable. If
567// the stream is resizable then seeking past the end and then writing
568// will result in zeros filling the empty space. Seeking past the end
569// of a resizable stream and reading will result in EOF. Seeking past
570// the end of a fixed-sized stream will fail.
571//
572// Any operation that would result in a negative offset will fail.
573//
574// If @cancellable is not %NULL, then the operation can be cancelled by
575// triggering the cancellable object from another thread. If the operation
576// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
577func (x *FileIOStream) Seek(OffsetVar int64, TypeVar glib.SeekType, CancellableVar *Cancellable) (bool, error) {
578 var cerr *glib.Error
579
580 cret := XGSeekableSeek(x.GoPointer(), OffsetVar, TypeVar, CancellableVar.GoPointer(), &cerr)
581 if cerr == nil {
582 return cret, nil
583 }
584 return cret, cerr
585
586}
587
588// Tells the current position within the stream.
589func (x *FileIOStream) Tell() int64 {
590
591 cret := XGSeekableTell(x.GoPointer())
592 return cret
593}
594
595// Sets the length of the stream to @offset. If the stream was previously
596// larger than @offset, the extra data is discarded. If the stream was
597// previously shorter than @offset, it is extended with NUL ('\0') bytes.
598//
599// If @cancellable is not %NULL, then the operation can be cancelled by
600// triggering the cancellable object from another thread. If the operation
601// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
602// operation was partially finished when the operation was cancelled the
603// partial result will be returned, without an error.
604func (x *FileIOStream) Truncate(OffsetVar int64, CancellableVar *Cancellable) (bool, error) {
605 var cerr *glib.Error
606
607 cret := XGSeekableTruncate(x.GoPointer(), OffsetVar, CancellableVar.GoPointer(), &cerr)
608 if cerr == nil {
609 return cret, nil
610 }
611 return cret, cerr
612
613}
614
615func init() {
616 core.SetPackageName("GIO", "gio-2.0")
617 core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
618 var libs []uintptr
619 for _, libPath := range core.GetPaths("GIO") {
620 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
621 if err != nil {
622 panic(err)
623 }
624 libs = append(libs, lib)
625 }
626
627 core.PuregoSafeRegister(&xFileIOStreamGLibType, libs, "g_file_io_stream_get_type")
628
629 core.PuregoSafeRegister(&xFileIOStreamGetEtag, libs, "g_file_io_stream_get_etag")
630 core.PuregoSafeRegister(&xFileIOStreamQueryInfo, libs, "g_file_io_stream_query_info")
631 core.PuregoSafeRegister(&xFileIOStreamQueryInfoAsync, libs, "g_file_io_stream_query_info_async")
632 core.PuregoSafeRegister(&xFileIOStreamQueryInfoFinish, libs, "g_file_io_stream_query_info_finish")
633
634}