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 FileOutputStreamClass struct {
16 _ structs.HostLayout
17
18 ParentClass OutputStreamClass
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 *FileOutputStreamClass) GoPointer() uintptr {
50 return uintptr(unsafe.Pointer(x))
51}
52
53// OverrideTell sets the "tell" callback function.
54func (x *FileOutputStreamClass) OverrideTell(cb func(*FileOutputStream) int64) {
55 if cb == nil {
56 x.xTell = 0
57 } else {
58 x.xTell = purego.NewCallback(func(StreamVarp uintptr) int64 {
59 return cb(FileOutputStreamNewFromInternalPtr(StreamVarp))
60 })
61 }
62}
63
64// GetTell gets the "tell" callback function.
65func (x *FileOutputStreamClass) GetTell() func(*FileOutputStream) 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 *FileOutputStream) int64 {
72 return rawCallback(StreamVar.GoPointer())
73 }
74}
75
76// OverrideCanSeek sets the "can_seek" callback function.
77func (x *FileOutputStreamClass) OverrideCanSeek(cb func(*FileOutputStream) bool) {
78 if cb == nil {
79 x.xCanSeek = 0
80 } else {
81 x.xCanSeek = purego.NewCallback(func(StreamVarp uintptr) bool {
82 return cb(FileOutputStreamNewFromInternalPtr(StreamVarp))
83 })
84 }
85}
86
87// GetCanSeek gets the "can_seek" callback function.
88func (x *FileOutputStreamClass) GetCanSeek() func(*FileOutputStream) 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 *FileOutputStream) bool {
95 return rawCallback(StreamVar.GoPointer())
96 }
97}
98
99// OverrideSeek sets the "seek" callback function.
100func (x *FileOutputStreamClass) OverrideSeek(cb func(*FileOutputStream, 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(FileOutputStreamNewFromInternalPtr(StreamVarp), OffsetVarp, TypeVarp, CancellableNewFromInternalPtr(CancellableVarp))
106 })
107 }
108}
109
110// GetSeek gets the "seek" callback function.
111func (x *FileOutputStreamClass) GetSeek() func(*FileOutputStream, 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 *FileOutputStream, 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 *FileOutputStreamClass) OverrideCanTruncate(cb func(*FileOutputStream) bool) {
124 if cb == nil {
125 x.xCanTruncate = 0
126 } else {
127 x.xCanTruncate = purego.NewCallback(func(StreamVarp uintptr) bool {
128 return cb(FileOutputStreamNewFromInternalPtr(StreamVarp))
129 })
130 }
131}
132
133// GetCanTruncate gets the "can_truncate" callback function.
134func (x *FileOutputStreamClass) GetCanTruncate() func(*FileOutputStream) 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 *FileOutputStream) bool {
141 return rawCallback(StreamVar.GoPointer())
142 }
143}
144
145// OverrideTruncateFn sets the "truncate_fn" callback function.
146func (x *FileOutputStreamClass) OverrideTruncateFn(cb func(*FileOutputStream, 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(FileOutputStreamNewFromInternalPtr(StreamVarp), SizeVarp, CancellableNewFromInternalPtr(CancellableVarp))
152 })
153 }
154}
155
156// GetTruncateFn gets the "truncate_fn" callback function.
157func (x *FileOutputStreamClass) GetTruncateFn() func(*FileOutputStream, 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 *FileOutputStream, 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 *FileOutputStreamClass) OverrideQueryInfo(cb func(*FileOutputStream, 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(FileOutputStreamNewFromInternalPtr(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 *FileOutputStreamClass) GetQueryInfo() func(*FileOutputStream, 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 *FileOutputStream, 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 *FileOutputStreamClass) OverrideQueryInfoAsync(cb func(*FileOutputStream, 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(FileOutputStreamNewFromInternalPtr(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 *FileOutputStreamClass) GetQueryInfoAsync() func(*FileOutputStream, 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 *FileOutputStream, 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 *FileOutputStreamClass) OverrideQueryInfoFinish(cb func(*FileOutputStream, 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(FileOutputStreamNewFromInternalPtr(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 *FileOutputStreamClass) GetQueryInfoFinish() func(*FileOutputStream, 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 *FileOutputStream, 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 *FileOutputStreamClass) OverrideGetEtag(cb func(*FileOutputStream) string) {
259 if cb == nil {
260 x.xGetEtag = 0
261 } else {
262 x.xGetEtag = purego.NewCallback(func(StreamVarp uintptr) string {
263 return cb(FileOutputStreamNewFromInternalPtr(StreamVarp))
264 })
265 }
266}
267
268// GetGetEtag gets the "get_etag" callback function.
269func (x *FileOutputStreamClass) GetGetEtag() func(*FileOutputStream) 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 *FileOutputStream) string {
276 return rawCallback(StreamVar.GoPointer())
277 }
278}
279
280// OverrideGReserved1 sets the "_g_reserved1" callback function.
281func (x *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 *FileOutputStreamClass) 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 FileOutputStreamPrivate struct {
396 _ structs.HostLayout
397}
398
399func (x *FileOutputStreamPrivate) GoPointer() uintptr {
400 return uintptr(unsafe.Pointer(x))
401}
402
403// `GFileOutputStream` provides output streams that write their
404// content to a file.
405//
406// `GFileOutputStream` implements [iface@Gio.Seekable], which allows the output
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 output stream, use [method@Gio.Seekable.tell].
412// To find out if a file output stream supports seeking, use
413// [method@Gio.Seekable.can_seek].To position a file output stream, use
414// [method@Gio.Seekable.seek]. To find out if a file output stream supports
415// truncating, use [method@Gio.Seekable.can_truncate]. To truncate a file output
416// stream, use [method@Gio.Seekable.truncate].
417type FileOutputStream struct {
418 OutputStream
419}
420
421var xFileOutputStreamGLibType func() types.GType
422
423func FileOutputStreamGLibType() types.GType {
424 return xFileOutputStreamGLibType()
425}
426
427func FileOutputStreamNewFromInternalPtr(ptr uintptr) *FileOutputStream {
428 cls := &FileOutputStream{}
429 cls.Ptr = ptr
430 return cls
431}
432
433var xFileOutputStreamGetEtag func(uintptr) string
434
435// Gets the entity tag for the file when it has been written.
436// This must be called after the stream has been written
437// and closed, as the etag can change while writing.
438func (x *FileOutputStream) GetEtag() string {
439
440 cret := xFileOutputStreamGetEtag(x.GoPointer())
441 return cret
442}
443
444var xFileOutputStreamQueryInfo func(uintptr, string, uintptr, **glib.Error) uintptr
445
446// Queries a file output stream for the given @attributes.
447// This function blocks while querying the stream. For the asynchronous
448// version of this function, see g_file_output_stream_query_info_async().
449// While the stream is blocked, the stream will set the pending flag
450// internally, and any other operations on the stream will fail with
451// %G_IO_ERROR_PENDING.
452//
453// Can fail if the stream was already closed (with @error being set to
454// %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being
455// set to %G_IO_ERROR_PENDING), or if querying info is not supported for
456// the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). In
457// all cases of failure, %NULL will be returned.
458//
459// If @cancellable is not %NULL, then the operation can be cancelled by
460// triggering the cancellable object from another thread. If the operation
461// was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
462// be returned.
463func (x *FileOutputStream) QueryInfo(AttributesVar string, CancellableVar *Cancellable) (*FileInfo, error) {
464 var cls *FileInfo
465 var cerr *glib.Error
466
467 cret := xFileOutputStreamQueryInfo(x.GoPointer(), AttributesVar, CancellableVar.GoPointer(), &cerr)
468
469 if cret == 0 {
470 return nil, cerr
471 }
472 cls = &FileInfo{}
473 cls.Ptr = cret
474 if cerr == nil {
475 return cls, nil
476 }
477 return cls, cerr
478
479}
480
481var xFileOutputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr, uintptr)
482
483// Asynchronously queries the @stream for a #GFileInfo. When completed,
484// @callback will be called with a #GAsyncResult which can be used to
485// finish the operation with g_file_output_stream_query_info_finish().
486//
487// For the synchronous version of this function, see
488// g_file_output_stream_query_info().
489func (x *FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
490
491 var CallbackVarRef uintptr
492 if CallbackVar != nil {
493 CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
494 if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
495 CallbackVarRef = cbRefPtr
496 } else {
497 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
498 cbFn := *CallbackVar
499 cbFn(arg0, arg1, arg2)
500 }
501 CallbackVarRef = purego.NewCallback(fcb)
502 glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
503 }
504 }
505
506 xFileOutputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
507
508}
509
510var xFileOutputStreamQueryInfoFinish func(uintptr, uintptr, **glib.Error) uintptr
511
512// Finalizes the asynchronous query started
513// by g_file_output_stream_query_info_async().
514func (x *FileOutputStream) QueryInfoFinish(ResultVar AsyncResult) (*FileInfo, error) {
515 var cls *FileInfo
516 var cerr *glib.Error
517
518 cret := xFileOutputStreamQueryInfoFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
519
520 if cret == 0 {
521 return nil, cerr
522 }
523 cls = &FileInfo{}
524 cls.Ptr = cret
525 if cerr == nil {
526 return cls, nil
527 }
528 return cls, cerr
529
530}
531
532func (c *FileOutputStream) GoPointer() uintptr {
533 if c == nil {
534 return 0
535 }
536 return c.Ptr
537}
538
539func (c *FileOutputStream) SetGoPointer(ptr uintptr) {
540 c.Ptr = ptr
541}
542
543// Tests if the stream supports the #GSeekableIface.
544func (x *FileOutputStream) CanSeek() bool {
545
546 cret := XGSeekableCanSeek(x.GoPointer())
547 return cret
548}
549
550// Tests if the length of the stream can be adjusted with
551// g_seekable_truncate().
552func (x *FileOutputStream) CanTruncate() bool {
553
554 cret := XGSeekableCanTruncate(x.GoPointer())
555 return cret
556}
557
558// Seeks in the stream by the given @offset, modified by @type.
559//
560// Attempting to seek past the end of the stream will have different
561// results depending on if the stream is fixed-sized or resizable. If
562// the stream is resizable then seeking past the end and then writing
563// will result in zeros filling the empty space. Seeking past the end
564// of a resizable stream and reading will result in EOF. Seeking past
565// the end of a fixed-sized stream will fail.
566//
567// Any operation that would result in a negative offset will fail.
568//
569// If @cancellable is not %NULL, then the operation can be cancelled by
570// triggering the cancellable object from another thread. If the operation
571// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
572func (x *FileOutputStream) Seek(OffsetVar int64, TypeVar glib.SeekType, CancellableVar *Cancellable) (bool, error) {
573 var cerr *glib.Error
574
575 cret := XGSeekableSeek(x.GoPointer(), OffsetVar, TypeVar, CancellableVar.GoPointer(), &cerr)
576 if cerr == nil {
577 return cret, nil
578 }
579 return cret, cerr
580
581}
582
583// Tells the current position within the stream.
584func (x *FileOutputStream) Tell() int64 {
585
586 cret := XGSeekableTell(x.GoPointer())
587 return cret
588}
589
590// Sets the length of the stream to @offset. If the stream was previously
591// larger than @offset, the extra data is discarded. If the stream was
592// previously shorter than @offset, it is extended with NUL ('\0') bytes.
593//
594// If @cancellable is not %NULL, then the operation can be cancelled by
595// triggering the cancellable object from another thread. If the operation
596// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
597// operation was partially finished when the operation was cancelled the
598// partial result will be returned, without an error.
599func (x *FileOutputStream) Truncate(OffsetVar int64, CancellableVar *Cancellable) (bool, error) {
600 var cerr *glib.Error
601
602 cret := XGSeekableTruncate(x.GoPointer(), OffsetVar, CancellableVar.GoPointer(), &cerr)
603 if cerr == nil {
604 return cret, nil
605 }
606 return cret, cerr
607
608}
609
610func init() {
611 core.SetPackageName("GIO", "gio-2.0")
612 core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
613 var libs []uintptr
614 for _, libPath := range core.GetPaths("GIO") {
615 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
616 if err != nil {
617 panic(err)
618 }
619 libs = append(libs, lib)
620 }
621
622 core.PuregoSafeRegister(&xFileOutputStreamGLibType, libs, "g_file_output_stream_get_type")
623
624 core.PuregoSafeRegister(&xFileOutputStreamGetEtag, libs, "g_file_output_stream_get_etag")
625 core.PuregoSafeRegister(&xFileOutputStreamQueryInfo, libs, "g_file_output_stream_query_info")
626 core.PuregoSafeRegister(&xFileOutputStreamQueryInfoAsync, libs, "g_file_output_stream_query_info_async")
627 core.PuregoSafeRegister(&xFileOutputStreamQueryInfoFinish, libs, "g_file_output_stream_query_info_finish")
628
629}