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 ResolverClass struct {
17 _ structs.HostLayout
18
19 ParentClass gobject.ObjectClass
20
21 xReload uintptr
22
23 xLookupByName uintptr
24
25 xLookupByNameAsync uintptr
26
27 xLookupByNameFinish uintptr
28
29 xLookupByAddress uintptr
30
31 xLookupByAddressAsync uintptr
32
33 xLookupByAddressFinish uintptr
34
35 xLookupService uintptr
36
37 xLookupServiceAsync uintptr
38
39 xLookupServiceFinish uintptr
40
41 xLookupRecords uintptr
42
43 xLookupRecordsAsync uintptr
44
45 xLookupRecordsFinish uintptr
46
47 xLookupByNameWithFlagsAsync uintptr
48
49 xLookupByNameWithFlagsFinish uintptr
50
51 xLookupByNameWithFlags uintptr
52}
53
54func (x *ResolverClass) GoPointer() uintptr {
55 return uintptr(unsafe.Pointer(x))
56}
57
58// OverrideReload sets the "reload" callback function.
59func (x *ResolverClass) OverrideReload(cb func(*Resolver)) {
60 if cb == nil {
61 x.xReload = 0
62 } else {
63 x.xReload = purego.NewCallback(func(ResolverVarp uintptr) {
64 cb(ResolverNewFromInternalPtr(ResolverVarp))
65 })
66 }
67}
68
69// GetReload gets the "reload" callback function.
70func (x *ResolverClass) GetReload() func(*Resolver) {
71 if x.xReload == 0 {
72 return nil
73 }
74 var rawCallback func(ResolverVarp uintptr)
75 purego.RegisterFunc(&rawCallback, x.xReload)
76 return func(ResolverVar *Resolver) {
77 rawCallback(ResolverVar.GoPointer())
78 }
79}
80
81// OverrideLookupByName sets the "lookup_by_name" callback function.
82func (x *ResolverClass) OverrideLookupByName(cb func(*Resolver, string, *Cancellable) *glib.List) {
83 if cb == nil {
84 x.xLookupByName = 0
85 } else {
86 x.xLookupByName = purego.NewCallback(func(ResolverVarp uintptr, HostnameVarp string, CancellableVarp uintptr) *glib.List {
87 return cb(ResolverNewFromInternalPtr(ResolverVarp), HostnameVarp, CancellableNewFromInternalPtr(CancellableVarp))
88 })
89 }
90}
91
92// GetLookupByName gets the "lookup_by_name" callback function.
93func (x *ResolverClass) GetLookupByName() func(*Resolver, string, *Cancellable) *glib.List {
94 if x.xLookupByName == 0 {
95 return nil
96 }
97 var rawCallback func(ResolverVarp uintptr, HostnameVarp string, CancellableVarp uintptr) *glib.List
98 purego.RegisterFunc(&rawCallback, x.xLookupByName)
99 return func(ResolverVar *Resolver, HostnameVar string, CancellableVar *Cancellable) *glib.List {
100 return rawCallback(ResolverVar.GoPointer(), HostnameVar, CancellableVar.GoPointer())
101 }
102}
103
104// OverrideLookupByNameAsync sets the "lookup_by_name_async" callback function.
105func (x *ResolverClass) OverrideLookupByNameAsync(cb func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr)) {
106 if cb == nil {
107 x.xLookupByNameAsync = 0
108 } else {
109 x.xLookupByNameAsync = purego.NewCallback(func(ResolverVarp uintptr, HostnameVarp string, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
110 cb(ResolverNewFromInternalPtr(ResolverVarp), HostnameVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
111 })
112 }
113}
114
115// GetLookupByNameAsync gets the "lookup_by_name_async" callback function.
116func (x *ResolverClass) GetLookupByNameAsync() func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr) {
117 if x.xLookupByNameAsync == 0 {
118 return nil
119 }
120 var rawCallback func(ResolverVarp uintptr, HostnameVarp string, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
121 purego.RegisterFunc(&rawCallback, x.xLookupByNameAsync)
122 return func(ResolverVar *Resolver, HostnameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
123 rawCallback(ResolverVar.GoPointer(), HostnameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
124 }
125}
126
127// OverrideLookupByNameFinish sets the "lookup_by_name_finish" callback function.
128func (x *ResolverClass) OverrideLookupByNameFinish(cb func(*Resolver, AsyncResult) *glib.List) {
129 if cb == nil {
130 x.xLookupByNameFinish = 0
131 } else {
132 x.xLookupByNameFinish = purego.NewCallback(func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List {
133 return cb(ResolverNewFromInternalPtr(ResolverVarp), &AsyncResultBase{Ptr: ResultVarp})
134 })
135 }
136}
137
138// GetLookupByNameFinish gets the "lookup_by_name_finish" callback function.
139func (x *ResolverClass) GetLookupByNameFinish() func(*Resolver, AsyncResult) *glib.List {
140 if x.xLookupByNameFinish == 0 {
141 return nil
142 }
143 var rawCallback func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List
144 purego.RegisterFunc(&rawCallback, x.xLookupByNameFinish)
145 return func(ResolverVar *Resolver, ResultVar AsyncResult) *glib.List {
146 return rawCallback(ResolverVar.GoPointer(), ResultVar.GoPointer())
147 }
148}
149
150// OverrideLookupByAddress sets the "lookup_by_address" callback function.
151func (x *ResolverClass) OverrideLookupByAddress(cb func(*Resolver, *InetAddress, *Cancellable) string) {
152 if cb == nil {
153 x.xLookupByAddress = 0
154 } else {
155 x.xLookupByAddress = purego.NewCallback(func(ResolverVarp uintptr, AddressVarp uintptr, CancellableVarp uintptr) string {
156 return cb(ResolverNewFromInternalPtr(ResolverVarp), InetAddressNewFromInternalPtr(AddressVarp), CancellableNewFromInternalPtr(CancellableVarp))
157 })
158 }
159}
160
161// GetLookupByAddress gets the "lookup_by_address" callback function.
162func (x *ResolverClass) GetLookupByAddress() func(*Resolver, *InetAddress, *Cancellable) string {
163 if x.xLookupByAddress == 0 {
164 return nil
165 }
166 var rawCallback func(ResolverVarp uintptr, AddressVarp uintptr, CancellableVarp uintptr) string
167 purego.RegisterFunc(&rawCallback, x.xLookupByAddress)
168 return func(ResolverVar *Resolver, AddressVar *InetAddress, CancellableVar *Cancellable) string {
169 return rawCallback(ResolverVar.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer())
170 }
171}
172
173// OverrideLookupByAddressAsync sets the "lookup_by_address_async" callback function.
174func (x *ResolverClass) OverrideLookupByAddressAsync(cb func(*Resolver, *InetAddress, *Cancellable, *AsyncReadyCallback, uintptr)) {
175 if cb == nil {
176 x.xLookupByAddressAsync = 0
177 } else {
178 x.xLookupByAddressAsync = purego.NewCallback(func(ResolverVarp uintptr, AddressVarp uintptr, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
179 cb(ResolverNewFromInternalPtr(ResolverVarp), InetAddressNewFromInternalPtr(AddressVarp), CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
180 })
181 }
182}
183
184// GetLookupByAddressAsync gets the "lookup_by_address_async" callback function.
185func (x *ResolverClass) GetLookupByAddressAsync() func(*Resolver, *InetAddress, *Cancellable, *AsyncReadyCallback, uintptr) {
186 if x.xLookupByAddressAsync == 0 {
187 return nil
188 }
189 var rawCallback func(ResolverVarp uintptr, AddressVarp uintptr, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
190 purego.RegisterFunc(&rawCallback, x.xLookupByAddressAsync)
191 return func(ResolverVar *Resolver, AddressVar *InetAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
192 rawCallback(ResolverVar.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
193 }
194}
195
196// OverrideLookupByAddressFinish sets the "lookup_by_address_finish" callback function.
197func (x *ResolverClass) OverrideLookupByAddressFinish(cb func(*Resolver, AsyncResult) string) {
198 if cb == nil {
199 x.xLookupByAddressFinish = 0
200 } else {
201 x.xLookupByAddressFinish = purego.NewCallback(func(ResolverVarp uintptr, ResultVarp uintptr) string {
202 return cb(ResolverNewFromInternalPtr(ResolverVarp), &AsyncResultBase{Ptr: ResultVarp})
203 })
204 }
205}
206
207// GetLookupByAddressFinish gets the "lookup_by_address_finish" callback function.
208func (x *ResolverClass) GetLookupByAddressFinish() func(*Resolver, AsyncResult) string {
209 if x.xLookupByAddressFinish == 0 {
210 return nil
211 }
212 var rawCallback func(ResolverVarp uintptr, ResultVarp uintptr) string
213 purego.RegisterFunc(&rawCallback, x.xLookupByAddressFinish)
214 return func(ResolverVar *Resolver, ResultVar AsyncResult) string {
215 return rawCallback(ResolverVar.GoPointer(), ResultVar.GoPointer())
216 }
217}
218
219// OverrideLookupService sets the "lookup_service" callback function.
220func (x *ResolverClass) OverrideLookupService(cb func(*Resolver, string, *Cancellable) *glib.List) {
221 if cb == nil {
222 x.xLookupService = 0
223 } else {
224 x.xLookupService = purego.NewCallback(func(ResolverVarp uintptr, RrnameVarp string, CancellableVarp uintptr) *glib.List {
225 return cb(ResolverNewFromInternalPtr(ResolverVarp), RrnameVarp, CancellableNewFromInternalPtr(CancellableVarp))
226 })
227 }
228}
229
230// GetLookupService gets the "lookup_service" callback function.
231func (x *ResolverClass) GetLookupService() func(*Resolver, string, *Cancellable) *glib.List {
232 if x.xLookupService == 0 {
233 return nil
234 }
235 var rawCallback func(ResolverVarp uintptr, RrnameVarp string, CancellableVarp uintptr) *glib.List
236 purego.RegisterFunc(&rawCallback, x.xLookupService)
237 return func(ResolverVar *Resolver, RrnameVar string, CancellableVar *Cancellable) *glib.List {
238 return rawCallback(ResolverVar.GoPointer(), RrnameVar, CancellableVar.GoPointer())
239 }
240}
241
242// OverrideLookupServiceAsync sets the "lookup_service_async" callback function.
243func (x *ResolverClass) OverrideLookupServiceAsync(cb func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr)) {
244 if cb == nil {
245 x.xLookupServiceAsync = 0
246 } else {
247 x.xLookupServiceAsync = purego.NewCallback(func(ResolverVarp uintptr, RrnameVarp string, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
248 cb(ResolverNewFromInternalPtr(ResolverVarp), RrnameVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
249 })
250 }
251}
252
253// GetLookupServiceAsync gets the "lookup_service_async" callback function.
254func (x *ResolverClass) GetLookupServiceAsync() func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr) {
255 if x.xLookupServiceAsync == 0 {
256 return nil
257 }
258 var rawCallback func(ResolverVarp uintptr, RrnameVarp string, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
259 purego.RegisterFunc(&rawCallback, x.xLookupServiceAsync)
260 return func(ResolverVar *Resolver, RrnameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
261 rawCallback(ResolverVar.GoPointer(), RrnameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
262 }
263}
264
265// OverrideLookupServiceFinish sets the "lookup_service_finish" callback function.
266func (x *ResolverClass) OverrideLookupServiceFinish(cb func(*Resolver, AsyncResult) *glib.List) {
267 if cb == nil {
268 x.xLookupServiceFinish = 0
269 } else {
270 x.xLookupServiceFinish = purego.NewCallback(func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List {
271 return cb(ResolverNewFromInternalPtr(ResolverVarp), &AsyncResultBase{Ptr: ResultVarp})
272 })
273 }
274}
275
276// GetLookupServiceFinish gets the "lookup_service_finish" callback function.
277func (x *ResolverClass) GetLookupServiceFinish() func(*Resolver, AsyncResult) *glib.List {
278 if x.xLookupServiceFinish == 0 {
279 return nil
280 }
281 var rawCallback func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List
282 purego.RegisterFunc(&rawCallback, x.xLookupServiceFinish)
283 return func(ResolverVar *Resolver, ResultVar AsyncResult) *glib.List {
284 return rawCallback(ResolverVar.GoPointer(), ResultVar.GoPointer())
285 }
286}
287
288// OverrideLookupRecords sets the "lookup_records" callback function.
289func (x *ResolverClass) OverrideLookupRecords(cb func(*Resolver, string, ResolverRecordType, *Cancellable) *glib.List) {
290 if cb == nil {
291 x.xLookupRecords = 0
292 } else {
293 x.xLookupRecords = purego.NewCallback(func(ResolverVarp uintptr, RrnameVarp string, RecordTypeVarp ResolverRecordType, CancellableVarp uintptr) *glib.List {
294 return cb(ResolverNewFromInternalPtr(ResolverVarp), RrnameVarp, RecordTypeVarp, CancellableNewFromInternalPtr(CancellableVarp))
295 })
296 }
297}
298
299// GetLookupRecords gets the "lookup_records" callback function.
300func (x *ResolverClass) GetLookupRecords() func(*Resolver, string, ResolverRecordType, *Cancellable) *glib.List {
301 if x.xLookupRecords == 0 {
302 return nil
303 }
304 var rawCallback func(ResolverVarp uintptr, RrnameVarp string, RecordTypeVarp ResolverRecordType, CancellableVarp uintptr) *glib.List
305 purego.RegisterFunc(&rawCallback, x.xLookupRecords)
306 return func(ResolverVar *Resolver, RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable) *glib.List {
307 return rawCallback(ResolverVar.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer())
308 }
309}
310
311// OverrideLookupRecordsAsync sets the "lookup_records_async" callback function.
312func (x *ResolverClass) OverrideLookupRecordsAsync(cb func(*Resolver, string, ResolverRecordType, *Cancellable, *AsyncReadyCallback, uintptr)) {
313 if cb == nil {
314 x.xLookupRecordsAsync = 0
315 } else {
316 x.xLookupRecordsAsync = purego.NewCallback(func(ResolverVarp uintptr, RrnameVarp string, RecordTypeVarp ResolverRecordType, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
317 cb(ResolverNewFromInternalPtr(ResolverVarp), RrnameVarp, RecordTypeVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
318 })
319 }
320}
321
322// GetLookupRecordsAsync gets the "lookup_records_async" callback function.
323func (x *ResolverClass) GetLookupRecordsAsync() func(*Resolver, string, ResolverRecordType, *Cancellable, *AsyncReadyCallback, uintptr) {
324 if x.xLookupRecordsAsync == 0 {
325 return nil
326 }
327 var rawCallback func(ResolverVarp uintptr, RrnameVarp string, RecordTypeVarp ResolverRecordType, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
328 purego.RegisterFunc(&rawCallback, x.xLookupRecordsAsync)
329 return func(ResolverVar *Resolver, RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
330 rawCallback(ResolverVar.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
331 }
332}
333
334// OverrideLookupRecordsFinish sets the "lookup_records_finish" callback function.
335func (x *ResolverClass) OverrideLookupRecordsFinish(cb func(*Resolver, AsyncResult) *glib.List) {
336 if cb == nil {
337 x.xLookupRecordsFinish = 0
338 } else {
339 x.xLookupRecordsFinish = purego.NewCallback(func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List {
340 return cb(ResolverNewFromInternalPtr(ResolverVarp), &AsyncResultBase{Ptr: ResultVarp})
341 })
342 }
343}
344
345// GetLookupRecordsFinish gets the "lookup_records_finish" callback function.
346func (x *ResolverClass) GetLookupRecordsFinish() func(*Resolver, AsyncResult) *glib.List {
347 if x.xLookupRecordsFinish == 0 {
348 return nil
349 }
350 var rawCallback func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List
351 purego.RegisterFunc(&rawCallback, x.xLookupRecordsFinish)
352 return func(ResolverVar *Resolver, ResultVar AsyncResult) *glib.List {
353 return rawCallback(ResolverVar.GoPointer(), ResultVar.GoPointer())
354 }
355}
356
357// OverrideLookupByNameWithFlagsAsync sets the "lookup_by_name_with_flags_async" callback function.
358func (x *ResolverClass) OverrideLookupByNameWithFlagsAsync(cb func(*Resolver, string, ResolverNameLookupFlags, *Cancellable, *AsyncReadyCallback, uintptr)) {
359 if cb == nil {
360 x.xLookupByNameWithFlagsAsync = 0
361 } else {
362 x.xLookupByNameWithFlagsAsync = purego.NewCallback(func(ResolverVarp uintptr, HostnameVarp string, FlagsVarp ResolverNameLookupFlags, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
363 cb(ResolverNewFromInternalPtr(ResolverVarp), HostnameVarp, FlagsVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
364 })
365 }
366}
367
368// GetLookupByNameWithFlagsAsync gets the "lookup_by_name_with_flags_async" callback function.
369func (x *ResolverClass) GetLookupByNameWithFlagsAsync() func(*Resolver, string, ResolverNameLookupFlags, *Cancellable, *AsyncReadyCallback, uintptr) {
370 if x.xLookupByNameWithFlagsAsync == 0 {
371 return nil
372 }
373 var rawCallback func(ResolverVarp uintptr, HostnameVarp string, FlagsVarp ResolverNameLookupFlags, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
374 purego.RegisterFunc(&rawCallback, x.xLookupByNameWithFlagsAsync)
375 return func(ResolverVar *Resolver, HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
376 rawCallback(ResolverVar.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
377 }
378}
379
380// OverrideLookupByNameWithFlagsFinish sets the "lookup_by_name_with_flags_finish" callback function.
381func (x *ResolverClass) OverrideLookupByNameWithFlagsFinish(cb func(*Resolver, AsyncResult) *glib.List) {
382 if cb == nil {
383 x.xLookupByNameWithFlagsFinish = 0
384 } else {
385 x.xLookupByNameWithFlagsFinish = purego.NewCallback(func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List {
386 return cb(ResolverNewFromInternalPtr(ResolverVarp), &AsyncResultBase{Ptr: ResultVarp})
387 })
388 }
389}
390
391// GetLookupByNameWithFlagsFinish gets the "lookup_by_name_with_flags_finish" callback function.
392func (x *ResolverClass) GetLookupByNameWithFlagsFinish() func(*Resolver, AsyncResult) *glib.List {
393 if x.xLookupByNameWithFlagsFinish == 0 {
394 return nil
395 }
396 var rawCallback func(ResolverVarp uintptr, ResultVarp uintptr) *glib.List
397 purego.RegisterFunc(&rawCallback, x.xLookupByNameWithFlagsFinish)
398 return func(ResolverVar *Resolver, ResultVar AsyncResult) *glib.List {
399 return rawCallback(ResolverVar.GoPointer(), ResultVar.GoPointer())
400 }
401}
402
403// OverrideLookupByNameWithFlags sets the "lookup_by_name_with_flags" callback function.
404func (x *ResolverClass) OverrideLookupByNameWithFlags(cb func(*Resolver, string, ResolverNameLookupFlags, *Cancellable) *glib.List) {
405 if cb == nil {
406 x.xLookupByNameWithFlags = 0
407 } else {
408 x.xLookupByNameWithFlags = purego.NewCallback(func(ResolverVarp uintptr, HostnameVarp string, FlagsVarp ResolverNameLookupFlags, CancellableVarp uintptr) *glib.List {
409 return cb(ResolverNewFromInternalPtr(ResolverVarp), HostnameVarp, FlagsVarp, CancellableNewFromInternalPtr(CancellableVarp))
410 })
411 }
412}
413
414// GetLookupByNameWithFlags gets the "lookup_by_name_with_flags" callback function.
415func (x *ResolverClass) GetLookupByNameWithFlags() func(*Resolver, string, ResolverNameLookupFlags, *Cancellable) *glib.List {
416 if x.xLookupByNameWithFlags == 0 {
417 return nil
418 }
419 var rawCallback func(ResolverVarp uintptr, HostnameVarp string, FlagsVarp ResolverNameLookupFlags, CancellableVarp uintptr) *glib.List
420 purego.RegisterFunc(&rawCallback, x.xLookupByNameWithFlags)
421 return func(ResolverVar *Resolver, HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable) *glib.List {
422 return rawCallback(ResolverVar.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer())
423 }
424}
425
426type ResolverPrivate struct {
427 _ structs.HostLayout
428}
429
430func (x *ResolverPrivate) GoPointer() uintptr {
431 return uintptr(unsafe.Pointer(x))
432}
433
434// Flags to modify lookup behavior.
435type ResolverNameLookupFlags int
436
437var xResolverNameLookupFlagsGLibType func() types.GType
438
439func ResolverNameLookupFlagsGLibType() types.GType {
440 return xResolverNameLookupFlagsGLibType()
441}
442
443const (
444
445 // default behavior (same as g_resolver_lookup_by_name())
446 GResolverNameLookupFlagsDefaultValue ResolverNameLookupFlags = 0
447 // only resolve ipv4 addresses
448 GResolverNameLookupFlagsIpv4OnlyValue ResolverNameLookupFlags = 1
449 // only resolve ipv6 addresses
450 GResolverNameLookupFlagsIpv6OnlyValue ResolverNameLookupFlags = 2
451)
452
453var xResolverErrorQuark func() glib.Quark
454
455// Gets the #GResolver Error Quark.
456func ResolverErrorQuark() glib.Quark {
457
458 cret := xResolverErrorQuark()
459 return cret
460}
461
462// The object that handles DNS resolution. Use [func@Gio.Resolver.get_default]
463// to get the default resolver.
464//
465// `GResolver` provides cancellable synchronous and asynchronous DNS
466// resolution, for hostnames ([method@Gio.Resolver.lookup_by_address],
467// [method@Gio.Resolver.lookup_by_name] and their async variants) and SRV
468// (service) records ([method@Gio.Resolver.lookup_service]).
469//
470// [class@Gio.NetworkAddress] and [class@Gio.NetworkService] provide wrappers
471// around `GResolver` functionality that also implement
472// [iface@Gio.SocketConnectable], making it easy to connect to a remote
473// host/service.
474//
475// The default resolver (see [func@Gio.Resolver.get_default]) has a timeout of
476// 30s set on it since GLib 2.78. Earlier versions of GLib did not support
477// resolver timeouts.
478//
479// This is an abstract type; subclasses of it implement different resolvers for
480// different platforms and situations.
481type Resolver struct {
482 gobject.Object
483}
484
485var xResolverGLibType func() types.GType
486
487func ResolverGLibType() types.GType {
488 return xResolverGLibType()
489}
490
491func ResolverNewFromInternalPtr(ptr uintptr) *Resolver {
492 cls := &Resolver{}
493 cls.Ptr = ptr
494 return cls
495}
496
497var xResolverGetTimeout func(uintptr) uint
498
499// Get the timeout applied to all resolver lookups. See #GResolver:timeout.
500func (x *Resolver) GetTimeout() uint {
501
502 cret := xResolverGetTimeout(x.GoPointer())
503 return cret
504}
505
506var xResolverLookupByAddress func(uintptr, uintptr, uintptr, **glib.Error) string
507
508// Synchronously reverse-resolves @address to determine its
509// associated hostname.
510//
511// If the DNS resolution fails, @error (if non-%NULL) will be set to
512// a value from #GResolverError.
513//
514// If @cancellable is non-%NULL, it can be used to cancel the
515// operation, in which case @error (if non-%NULL) will be set to
516// %G_IO_ERROR_CANCELLED.
517func (x *Resolver) LookupByAddress(AddressVar *InetAddress, CancellableVar *Cancellable) (string, error) {
518 var cerr *glib.Error
519
520 cret := xResolverLookupByAddress(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
521 if cerr == nil {
522 return cret, nil
523 }
524 return cret, cerr
525
526}
527
528var xResolverLookupByAddressAsync func(uintptr, uintptr, uintptr, uintptr, uintptr)
529
530// Begins asynchronously reverse-resolving @address to determine its
531// associated hostname, and eventually calls @callback, which must
532// call g_resolver_lookup_by_address_finish() to get the final result.
533func (x *Resolver) LookupByAddressAsync(AddressVar *InetAddress, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
534
535 var CallbackVarRef uintptr
536 if CallbackVar != nil {
537 CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
538 if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
539 CallbackVarRef = cbRefPtr
540 } else {
541 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
542 cbFn := *CallbackVar
543 cbFn(arg0, arg1, arg2)
544 }
545 CallbackVarRef = purego.NewCallback(fcb)
546 glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
547 }
548 }
549
550 xResolverLookupByAddressAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
551
552}
553
554var xResolverLookupByAddressFinish func(uintptr, uintptr, **glib.Error) string
555
556// Retrieves the result of a previous call to
557// g_resolver_lookup_by_address_async().
558//
559// If the DNS resolution failed, @error (if non-%NULL) will be set to
560// a value from #GResolverError. If the operation was cancelled,
561// @error will be set to %G_IO_ERROR_CANCELLED.
562func (x *Resolver) LookupByAddressFinish(ResultVar AsyncResult) (string, error) {
563 var cerr *glib.Error
564
565 cret := xResolverLookupByAddressFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
566 if cerr == nil {
567 return cret, nil
568 }
569 return cret, cerr
570
571}
572
573var xResolverLookupByName func(uintptr, string, uintptr, **glib.Error) *glib.List
574
575// Synchronously resolves @hostname to determine its associated IP
576// address(es). @hostname may be an ASCII-only or UTF-8 hostname, or
577// the textual form of an IP address (in which case this just becomes
578// a wrapper around g_inet_address_new_from_string()).
579//
580// On success, g_resolver_lookup_by_name() will return a non-empty #GList of
581// #GInetAddress, sorted in order of preference and guaranteed to not
582// contain duplicates. That is, if using the result to connect to
583// @hostname, you should attempt to connect to the first address
584// first, then the second if the first fails, etc. If you are using
585// the result to listen on a socket, it is appropriate to add each
586// result using e.g. g_socket_listener_add_address().
587//
588// If the DNS resolution fails, @error (if non-%NULL) will be set to a
589// value from #GResolverError and %NULL will be returned.
590//
591// If @cancellable is non-%NULL, it can be used to cancel the
592// operation, in which case @error (if non-%NULL) will be set to
593// %G_IO_ERROR_CANCELLED.
594//
595// If you are planning to connect to a socket on the resolved IP
596// address, it may be easier to create a #GNetworkAddress and use its
597// #GSocketConnectable interface.
598func (x *Resolver) LookupByName(HostnameVar string, CancellableVar *Cancellable) (*glib.List, error) {
599 var cerr *glib.Error
600
601 cret := xResolverLookupByName(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), &cerr)
602 if cerr == nil {
603 return cret, nil
604 }
605 return cret, cerr
606
607}
608
609var xResolverLookupByNameAsync func(uintptr, string, uintptr, uintptr, uintptr)
610
611// Begins asynchronously resolving @hostname to determine its
612// associated IP address(es), and eventually calls @callback, which
613// must call g_resolver_lookup_by_name_finish() to get the result.
614// See g_resolver_lookup_by_name() for more details.
615func (x *Resolver) LookupByNameAsync(HostnameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
616
617 var CallbackVarRef uintptr
618 if CallbackVar != nil {
619 CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
620 if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
621 CallbackVarRef = cbRefPtr
622 } else {
623 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
624 cbFn := *CallbackVar
625 cbFn(arg0, arg1, arg2)
626 }
627 CallbackVarRef = purego.NewCallback(fcb)
628 glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
629 }
630 }
631
632 xResolverLookupByNameAsync(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
633
634}
635
636var xResolverLookupByNameFinish func(uintptr, uintptr, **glib.Error) *glib.List
637
638// Retrieves the result of a call to
639// g_resolver_lookup_by_name_async().
640//
641// If the DNS resolution failed, @error (if non-%NULL) will be set to
642// a value from #GResolverError. If the operation was cancelled,
643// @error will be set to %G_IO_ERROR_CANCELLED.
644func (x *Resolver) LookupByNameFinish(ResultVar AsyncResult) (*glib.List, error) {
645 var cerr *glib.Error
646
647 cret := xResolverLookupByNameFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
648 if cerr == nil {
649 return cret, nil
650 }
651 return cret, cerr
652
653}
654
655var xResolverLookupByNameWithFlags func(uintptr, string, ResolverNameLookupFlags, uintptr, **glib.Error) *glib.List
656
657// This differs from g_resolver_lookup_by_name() in that you can modify
658// the lookup behavior with @flags. For example this can be used to limit
659// results with %G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY.
660func (x *Resolver) LookupByNameWithFlags(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable) (*glib.List, error) {
661 var cerr *glib.Error
662
663 cret := xResolverLookupByNameWithFlags(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), &cerr)
664 if cerr == nil {
665 return cret, nil
666 }
667 return cret, cerr
668
669}
670
671var xResolverLookupByNameWithFlagsAsync func(uintptr, string, ResolverNameLookupFlags, uintptr, uintptr, uintptr)
672
673// Begins asynchronously resolving @hostname to determine its
674// associated IP address(es), and eventually calls @callback, which
675// must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
676// See g_resolver_lookup_by_name() for more details.
677func (x *Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
678
679 var CallbackVarRef uintptr
680 if CallbackVar != nil {
681 CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
682 if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
683 CallbackVarRef = cbRefPtr
684 } else {
685 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
686 cbFn := *CallbackVar
687 cbFn(arg0, arg1, arg2)
688 }
689 CallbackVarRef = purego.NewCallback(fcb)
690 glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
691 }
692 }
693
694 xResolverLookupByNameWithFlagsAsync(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
695
696}
697
698var xResolverLookupByNameWithFlagsFinish func(uintptr, uintptr, **glib.Error) *glib.List
699
700// Retrieves the result of a call to
701// g_resolver_lookup_by_name_with_flags_async().
702//
703// If the DNS resolution failed, @error (if non-%NULL) will be set to
704// a value from #GResolverError. If the operation was cancelled,
705// @error will be set to %G_IO_ERROR_CANCELLED.
706func (x *Resolver) LookupByNameWithFlagsFinish(ResultVar AsyncResult) (*glib.List, error) {
707 var cerr *glib.Error
708
709 cret := xResolverLookupByNameWithFlagsFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
710 if cerr == nil {
711 return cret, nil
712 }
713 return cret, cerr
714
715}
716
717var xResolverLookupRecords func(uintptr, string, ResolverRecordType, uintptr, **glib.Error) *glib.List
718
719// Synchronously performs a DNS record lookup for the given @rrname and returns
720// a list of records as #GVariant tuples. See #GResolverRecordType for
721// information on what the records contain for each @record_type.
722//
723// If the DNS resolution fails, @error (if non-%NULL) will be set to
724// a value from #GResolverError and %NULL will be returned.
725//
726// If @cancellable is non-%NULL, it can be used to cancel the
727// operation, in which case @error (if non-%NULL) will be set to
728// %G_IO_ERROR_CANCELLED.
729func (x *Resolver) LookupRecords(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable) (*glib.List, error) {
730 var cerr *glib.Error
731
732 cret := xResolverLookupRecords(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), &cerr)
733 if cerr == nil {
734 return cret, nil
735 }
736 return cret, cerr
737
738}
739
740var xResolverLookupRecordsAsync func(uintptr, string, ResolverRecordType, uintptr, uintptr, uintptr)
741
742// Begins asynchronously performing a DNS lookup for the given
743// @rrname, and eventually calls @callback, which must call
744// g_resolver_lookup_records_finish() to get the final result. See
745// g_resolver_lookup_records() for more details.
746func (x *Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
747
748 var CallbackVarRef uintptr
749 if CallbackVar != nil {
750 CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
751 if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
752 CallbackVarRef = cbRefPtr
753 } else {
754 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
755 cbFn := *CallbackVar
756 cbFn(arg0, arg1, arg2)
757 }
758 CallbackVarRef = purego.NewCallback(fcb)
759 glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
760 }
761 }
762
763 xResolverLookupRecordsAsync(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
764
765}
766
767var xResolverLookupRecordsFinish func(uintptr, uintptr, **glib.Error) *glib.List
768
769// Retrieves the result of a previous call to
770// g_resolver_lookup_records_async(). Returns a non-empty list of records as
771// #GVariant tuples. See #GResolverRecordType for information on what the
772// records contain.
773//
774// If the DNS resolution failed, @error (if non-%NULL) will be set to
775// a value from #GResolverError. If the operation was cancelled,
776// @error will be set to %G_IO_ERROR_CANCELLED.
777func (x *Resolver) LookupRecordsFinish(ResultVar AsyncResult) (*glib.List, error) {
778 var cerr *glib.Error
779
780 cret := xResolverLookupRecordsFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
781 if cerr == nil {
782 return cret, nil
783 }
784 return cret, cerr
785
786}
787
788var xResolverLookupService func(uintptr, string, string, string, uintptr, **glib.Error) *glib.List
789
790// Synchronously performs a DNS SRV lookup for the given @service and
791// @protocol in the given @domain and returns an array of #GSrvTarget.
792// @domain may be an ASCII-only or UTF-8 hostname. Note also that the
793// @service and @protocol arguments do not include the leading underscore
794// that appears in the actual DNS entry.
795//
796// On success, g_resolver_lookup_service() will return a non-empty #GList of
797// #GSrvTarget, sorted in order of preference. (That is, you should
798// attempt to connect to the first target first, then the second if
799// the first fails, etc.)
800//
801// If the DNS resolution fails, @error (if non-%NULL) will be set to
802// a value from #GResolverError and %NULL will be returned.
803//
804// If @cancellable is non-%NULL, it can be used to cancel the
805// operation, in which case @error (if non-%NULL) will be set to
806// %G_IO_ERROR_CANCELLED.
807//
808// If you are planning to connect to the service, it is usually easier
809// to create a #GNetworkService and use its #GSocketConnectable
810// interface.
811func (x *Resolver) LookupService(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar *Cancellable) (*glib.List, error) {
812 var cerr *glib.Error
813
814 cret := xResolverLookupService(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), &cerr)
815 if cerr == nil {
816 return cret, nil
817 }
818 return cret, cerr
819
820}
821
822var xResolverLookupServiceAsync func(uintptr, string, string, string, uintptr, uintptr, uintptr)
823
824// Begins asynchronously performing a DNS SRV lookup for the given
825// @service and @protocol in the given @domain, and eventually calls
826// @callback, which must call g_resolver_lookup_service_finish() to
827// get the final result. See g_resolver_lookup_service() for more
828// details.
829func (x *Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
830
831 var CallbackVarRef uintptr
832 if CallbackVar != nil {
833 CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
834 if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
835 CallbackVarRef = cbRefPtr
836 } else {
837 fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
838 cbFn := *CallbackVar
839 cbFn(arg0, arg1, arg2)
840 }
841 CallbackVarRef = purego.NewCallback(fcb)
842 glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
843 }
844 }
845
846 xResolverLookupServiceAsync(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
847
848}
849
850var xResolverLookupServiceFinish func(uintptr, uintptr, **glib.Error) *glib.List
851
852// Retrieves the result of a previous call to
853// g_resolver_lookup_service_async().
854//
855// If the DNS resolution failed, @error (if non-%NULL) will be set to
856// a value from #GResolverError. If the operation was cancelled,
857// @error will be set to %G_IO_ERROR_CANCELLED.
858func (x *Resolver) LookupServiceFinish(ResultVar AsyncResult) (*glib.List, error) {
859 var cerr *glib.Error
860
861 cret := xResolverLookupServiceFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
862 if cerr == nil {
863 return cret, nil
864 }
865 return cret, cerr
866
867}
868
869var xResolverSetDefault func(uintptr)
870
871// Sets @resolver to be the application's default resolver (reffing
872// @resolver, and unreffing the previous default resolver, if any).
873// Future calls to g_resolver_get_default() will return this resolver.
874//
875// This can be used if an application wants to perform any sort of DNS
876// caching or "pinning"; it can implement its own #GResolver that
877// calls the original default resolver for DNS operations, and
878// implements its own cache policies on top of that, and then set
879// itself as the default resolver for all later code to use.
880func (x *Resolver) SetDefault() {
881
882 xResolverSetDefault(x.GoPointer())
883
884}
885
886var xResolverSetTimeout func(uintptr, uint)
887
888// Set the timeout applied to all resolver lookups. See #GResolver:timeout.
889func (x *Resolver) SetTimeout(TimeoutMsVar uint) {
890
891 xResolverSetTimeout(x.GoPointer(), TimeoutMsVar)
892
893}
894
895func (c *Resolver) GoPointer() uintptr {
896 if c == nil {
897 return 0
898 }
899 return c.Ptr
900}
901
902func (c *Resolver) SetGoPointer(ptr uintptr) {
903 c.Ptr = ptr
904}
905
906// SetPropertyTimeout sets the "timeout" property.
907// The timeout applied to all resolver lookups, in milliseconds.
908//
909// This may be changed through the lifetime of the #GResolver. The new value
910// will apply to any lookups started after the change, but not to any
911// already-ongoing lookups.
912//
913// If this is `0`, no timeout is applied to lookups.
914//
915// No timeout was applied to lookups before this property was added in
916// GLib 2.78.
917func (x *Resolver) SetPropertyTimeout(value uint) {
918 var v gobject.Value
919 v.Init(gobject.TypeUintVal)
920 v.SetUint(value)
921 x.SetProperty("timeout", &v)
922}
923
924// GetPropertyTimeout gets the "timeout" property.
925// The timeout applied to all resolver lookups, in milliseconds.
926//
927// This may be changed through the lifetime of the #GResolver. The new value
928// will apply to any lookups started after the change, but not to any
929// already-ongoing lookups.
930//
931// If this is `0`, no timeout is applied to lookups.
932//
933// No timeout was applied to lookups before this property was added in
934// GLib 2.78.
935func (x *Resolver) GetPropertyTimeout() uint {
936 var v gobject.Value
937 x.GetProperty("timeout", &v)
938 return v.GetUint()
939}
940
941// Emitted when the resolver notices that the system resolver
942// configuration has changed.
943func (x *Resolver) ConnectReload(cb *func(Resolver)) uint {
944 cbPtr := uintptr(unsafe.Pointer(cb))
945 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
946 handlerID := gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
947 glib.SaveHandlerMapping(handlerID, cbPtr)
948 return handlerID
949 }
950
951 fcb := func(clsPtr uintptr) {
952 fa := Resolver{}
953 fa.Ptr = clsPtr
954 cbFn := *cb
955
956 cbFn(fa)
957
958 }
959 cbRefPtr := purego.NewCallback(fcb)
960 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
961 handlerID := gobject.SignalConnect(x.GoPointer(), "reload", cbRefPtr)
962 glib.SaveHandlerMapping(handlerID, cbPtr)
963 return handlerID
964}
965
966var xResolverFreeAddresses func(*glib.List)
967
968// Frees @addresses (which should be the return value from
969// g_resolver_lookup_by_name() or g_resolver_lookup_by_name_finish()).
970// (This is a convenience method; you can also simply free the results
971// by hand.)
972func ResolverFreeAddresses(AddressesVar *glib.List) {
973
974 xResolverFreeAddresses(AddressesVar)
975
976}
977
978var xResolverFreeTargets func(*glib.List)
979
980// Frees @targets (which should be the return value from
981// g_resolver_lookup_service() or g_resolver_lookup_service_finish()).
982// (This is a convenience method; you can also simply free the
983// results by hand.)
984func ResolverFreeTargets(TargetsVar *glib.List) {
985
986 xResolverFreeTargets(TargetsVar)
987
988}
989
990var xResolverGetDefault func() uintptr
991
992// Gets the default #GResolver. You should unref it when you are done
993// with it. #GResolver may use its reference count as a hint about how
994// many threads it should allocate for concurrent DNS resolutions.
995func ResolverGetDefault() *Resolver {
996 var cls *Resolver
997
998 cret := xResolverGetDefault()
999
1000 if cret == 0 {
1001 return nil
1002 }
1003 cls = &Resolver{}
1004 cls.Ptr = cret
1005 return cls
1006}
1007
1008func init() {
1009 core.SetPackageName("GIO", "gio-2.0")
1010 core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
1011 var libs []uintptr
1012 for _, libPath := range core.GetPaths("GIO") {
1013 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1014 if err != nil {
1015 panic(err)
1016 }
1017 libs = append(libs, lib)
1018 }
1019
1020 core.PuregoSafeRegister(&xResolverNameLookupFlagsGLibType, libs, "g_resolver_name_lookup_flags_get_type")
1021
1022 core.PuregoSafeRegister(&xResolverErrorQuark, libs, "g_resolver_error_quark")
1023
1024 core.PuregoSafeRegister(&xResolverGLibType, libs, "g_resolver_get_type")
1025
1026 core.PuregoSafeRegister(&xResolverGetTimeout, libs, "g_resolver_get_timeout")
1027 core.PuregoSafeRegister(&xResolverLookupByAddress, libs, "g_resolver_lookup_by_address")
1028 core.PuregoSafeRegister(&xResolverLookupByAddressAsync, libs, "g_resolver_lookup_by_address_async")
1029 core.PuregoSafeRegister(&xResolverLookupByAddressFinish, libs, "g_resolver_lookup_by_address_finish")
1030 core.PuregoSafeRegister(&xResolverLookupByName, libs, "g_resolver_lookup_by_name")
1031 core.PuregoSafeRegister(&xResolverLookupByNameAsync, libs, "g_resolver_lookup_by_name_async")
1032 core.PuregoSafeRegister(&xResolverLookupByNameFinish, libs, "g_resolver_lookup_by_name_finish")
1033 core.PuregoSafeRegister(&xResolverLookupByNameWithFlags, libs, "g_resolver_lookup_by_name_with_flags")
1034 core.PuregoSafeRegister(&xResolverLookupByNameWithFlagsAsync, libs, "g_resolver_lookup_by_name_with_flags_async")
1035 core.PuregoSafeRegister(&xResolverLookupByNameWithFlagsFinish, libs, "g_resolver_lookup_by_name_with_flags_finish")
1036 core.PuregoSafeRegister(&xResolverLookupRecords, libs, "g_resolver_lookup_records")
1037 core.PuregoSafeRegister(&xResolverLookupRecordsAsync, libs, "g_resolver_lookup_records_async")
1038 core.PuregoSafeRegister(&xResolverLookupRecordsFinish, libs, "g_resolver_lookup_records_finish")
1039 core.PuregoSafeRegister(&xResolverLookupService, libs, "g_resolver_lookup_service")
1040 core.PuregoSafeRegister(&xResolverLookupServiceAsync, libs, "g_resolver_lookup_service_async")
1041 core.PuregoSafeRegister(&xResolverLookupServiceFinish, libs, "g_resolver_lookup_service_finish")
1042 core.PuregoSafeRegister(&xResolverSetDefault, libs, "g_resolver_set_default")
1043 core.PuregoSafeRegister(&xResolverSetTimeout, libs, "g_resolver_set_timeout")
1044
1045 core.PuregoSafeRegister(&xResolverFreeAddresses, libs, "g_resolver_free_addresses")
1046 core.PuregoSafeRegister(&xResolverFreeTargets, libs, "g_resolver_free_targets")
1047 core.PuregoSafeRegister(&xResolverGetDefault, libs, "g_resolver_get_default")
1048
1049}