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"
13 "github.com/bnema/puregotk/v4/gobject/types"
14)
15
16type ConverterInputStreamClass struct {
17 _ structs.HostLayout
18
19 ParentClass FilterInputStreamClass
20
21 xGReserved1 uintptr
22
23 xGReserved2 uintptr
24
25 xGReserved3 uintptr
26
27 xGReserved4 uintptr
28
29 xGReserved5 uintptr
30}
31
32func (x *ConverterInputStreamClass) GoPointer() uintptr {
33 return uintptr(unsafe.Pointer(x))
34}
35
36// OverrideGReserved1 sets the "_g_reserved1" callback function.
37func (x *ConverterInputStreamClass) OverrideGReserved1(cb func()) {
38 if cb == nil {
39 x.xGReserved1 = 0
40 } else {
41 x.xGReserved1 = purego.NewCallback(func() {
42 cb()
43 })
44 }
45}
46
47// GetGReserved1 gets the "_g_reserved1" callback function.
48func (x *ConverterInputStreamClass) GetGReserved1() func() {
49 if x.xGReserved1 == 0 {
50 return nil
51 }
52 var rawCallback func()
53 purego.RegisterFunc(&rawCallback, x.xGReserved1)
54 return func() {
55 rawCallback()
56 }
57}
58
59// OverrideGReserved2 sets the "_g_reserved2" callback function.
60func (x *ConverterInputStreamClass) OverrideGReserved2(cb func()) {
61 if cb == nil {
62 x.xGReserved2 = 0
63 } else {
64 x.xGReserved2 = purego.NewCallback(func() {
65 cb()
66 })
67 }
68}
69
70// GetGReserved2 gets the "_g_reserved2" callback function.
71func (x *ConverterInputStreamClass) GetGReserved2() func() {
72 if x.xGReserved2 == 0 {
73 return nil
74 }
75 var rawCallback func()
76 purego.RegisterFunc(&rawCallback, x.xGReserved2)
77 return func() {
78 rawCallback()
79 }
80}
81
82// OverrideGReserved3 sets the "_g_reserved3" callback function.
83func (x *ConverterInputStreamClass) OverrideGReserved3(cb func()) {
84 if cb == nil {
85 x.xGReserved3 = 0
86 } else {
87 x.xGReserved3 = purego.NewCallback(func() {
88 cb()
89 })
90 }
91}
92
93// GetGReserved3 gets the "_g_reserved3" callback function.
94func (x *ConverterInputStreamClass) GetGReserved3() func() {
95 if x.xGReserved3 == 0 {
96 return nil
97 }
98 var rawCallback func()
99 purego.RegisterFunc(&rawCallback, x.xGReserved3)
100 return func() {
101 rawCallback()
102 }
103}
104
105// OverrideGReserved4 sets the "_g_reserved4" callback function.
106func (x *ConverterInputStreamClass) OverrideGReserved4(cb func()) {
107 if cb == nil {
108 x.xGReserved4 = 0
109 } else {
110 x.xGReserved4 = purego.NewCallback(func() {
111 cb()
112 })
113 }
114}
115
116// GetGReserved4 gets the "_g_reserved4" callback function.
117func (x *ConverterInputStreamClass) GetGReserved4() func() {
118 if x.xGReserved4 == 0 {
119 return nil
120 }
121 var rawCallback func()
122 purego.RegisterFunc(&rawCallback, x.xGReserved4)
123 return func() {
124 rawCallback()
125 }
126}
127
128// OverrideGReserved5 sets the "_g_reserved5" callback function.
129func (x *ConverterInputStreamClass) OverrideGReserved5(cb func()) {
130 if cb == nil {
131 x.xGReserved5 = 0
132 } else {
133 x.xGReserved5 = purego.NewCallback(func() {
134 cb()
135 })
136 }
137}
138
139// GetGReserved5 gets the "_g_reserved5" callback function.
140func (x *ConverterInputStreamClass) GetGReserved5() func() {
141 if x.xGReserved5 == 0 {
142 return nil
143 }
144 var rawCallback func()
145 purego.RegisterFunc(&rawCallback, x.xGReserved5)
146 return func() {
147 rawCallback()
148 }
149}
150
151type ConverterInputStreamPrivate struct {
152 _ structs.HostLayout
153}
154
155func (x *ConverterInputStreamPrivate) GoPointer() uintptr {
156 return uintptr(unsafe.Pointer(x))
157}
158
159// Converter input stream implements [class@Gio.InputStream] and allows
160// conversion of data of various types during reading.
161//
162// As of GLib 2.34, `GConverterInputStream` implements
163// [iface@Gio.PollableInputStream].
164type ConverterInputStream struct {
165 FilterInputStream
166}
167
168var xConverterInputStreamGLibType func() types.GType
169
170func ConverterInputStreamGLibType() types.GType {
171 return xConverterInputStreamGLibType()
172}
173
174func ConverterInputStreamNewFromInternalPtr(ptr uintptr) *ConverterInputStream {
175 cls := &ConverterInputStream{}
176 cls.Ptr = ptr
177 return cls
178}
179
180var xNewConverterInputStream func(uintptr, uintptr) uintptr
181
182// Creates a new converter input stream for the @base_stream.
183func NewConverterInputStream(BaseStreamVar *InputStream, ConverterVar Converter) *ConverterInputStream {
184 var cls *ConverterInputStream
185
186 cret := xNewConverterInputStream(BaseStreamVar.GoPointer(), ConverterVar.GoPointer())
187
188 if cret == 0 {
189 return nil
190 }
191 cls = &ConverterInputStream{}
192 cls.Ptr = cret
193 return cls
194}
195
196var xConverterInputStreamGetConverter func(uintptr) uintptr
197
198// Gets the #GConverter that is used by @converter_stream.
199func (x *ConverterInputStream) GetConverter() *ConverterBase {
200 var cls *ConverterBase
201
202 cret := xConverterInputStreamGetConverter(x.GoPointer())
203
204 if cret == 0 {
205 return nil
206 }
207 gobject.IncreaseRef(cret)
208 cls = &ConverterBase{}
209 cls.Ptr = cret
210 return cls
211}
212
213func (c *ConverterInputStream) GoPointer() uintptr {
214 if c == nil {
215 return 0
216 }
217 return c.Ptr
218}
219
220func (c *ConverterInputStream) SetGoPointer(ptr uintptr) {
221 c.Ptr = ptr
222}
223
224// Checks if @stream is actually pollable. Some classes may implement
225// #GPollableInputStream but have only certain instances of that class
226// be pollable. If this method returns %FALSE, then the behavior of
227// other #GPollableInputStream methods is undefined.
228//
229// For any given stream, the value returned by this method is constant;
230// a stream cannot switch from pollable to non-pollable or vice versa.
231func (x *ConverterInputStream) CanPoll() bool {
232
233 cret := XGPollableInputStreamCanPoll(x.GoPointer())
234 return cret
235}
236
237// Creates a #GSource that triggers when @stream can be read, or
238// @cancellable is triggered or an error occurs. The callback on the
239// source is of the #GPollableSourceFunc type.
240//
241// As with g_pollable_input_stream_is_readable(), it is possible that
242// the stream may not actually be readable even after the source
243// triggers, so you should use g_pollable_input_stream_read_nonblocking()
244// rather than g_input_stream_read() from the callback.
245//
246// The behaviour of this method is undefined if
247// g_pollable_input_stream_can_poll() returns %FALSE for @stream.
248func (x *ConverterInputStream) CreateSource(CancellableVar *Cancellable) *glib.Source {
249
250 cret := XGPollableInputStreamCreateSource(x.GoPointer(), CancellableVar.GoPointer())
251 return cret
252}
253
254// Checks if @stream can be read.
255//
256// Note that some stream types may not be able to implement this 100%
257// reliably, and it is possible that a call to g_input_stream_read()
258// after this returns %TRUE would still block. To guarantee
259// non-blocking behavior, you should always use
260// g_pollable_input_stream_read_nonblocking(), which will return a
261// %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
262//
263// The behaviour of this method is undefined if
264// g_pollable_input_stream_can_poll() returns %FALSE for @stream.
265func (x *ConverterInputStream) IsReadable() bool {
266
267 cret := XGPollableInputStreamIsReadable(x.GoPointer())
268 return cret
269}
270
271// Attempts to read up to @count bytes from @stream into @buffer, as
272// with g_input_stream_read(). If @stream is not currently readable,
273// this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
274// use g_pollable_input_stream_create_source() to create a #GSource
275// that will be triggered when @stream is readable.
276//
277// Note that since this method never blocks, you cannot actually
278// use @cancellable to cancel it. However, it will return an error
279// if @cancellable has already been cancelled when you call, which
280// may happen if you call this method after a source triggers due
281// to having been cancelled.
282//
283// The behaviour of this method is undefined if
284// g_pollable_input_stream_can_poll() returns %FALSE for @stream.
285func (x *ConverterInputStream) ReadNonblocking(BufferVar *[]byte, CountVar uint, CancellableVar *Cancellable) (int, error) {
286 var cerr *glib.Error
287
288 cret := XGPollableInputStreamReadNonblocking(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)
289 if cerr == nil {
290 return cret, nil
291 }
292 return cret, cerr
293
294}
295
296func init() {
297 core.SetPackageName("GIO", "gio-2.0")
298 core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
299 var libs []uintptr
300 for _, libPath := range core.GetPaths("GIO") {
301 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
302 if err != nil {
303 panic(err)
304 }
305 libs = append(libs, lib)
306 }
307
308 core.PuregoSafeRegister(&xConverterInputStreamGLibType, libs, "g_converter_input_stream_get_type")
309
310 core.PuregoSafeRegister(&xNewConverterInputStream, libs, "g_converter_input_stream_new")
311
312 core.PuregoSafeRegister(&xConverterInputStreamGetConverter, libs, "g_converter_input_stream_get_converter")
313
314}