1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
|
[CCode (gir_namespace = "GirTest", gir_version = "1.0")]
namespace GirTest {
namespace Nested {
[CCode (cheader_filename = "girtest.h")]
public static void function ();
}
[CCode (cheader_filename = "girtest.h")]
public abstract class AbstractObjectTest : GLib.Object {
protected AbstractObjectTest ();
public abstract void method_implicit_params (int[] param1, owned GirTest.DelegateTest param2);
public abstract void method_int8_in (int8 param);
public abstract void method_int8_inout (ref int8 param);
public abstract void method_int8_out (out int8 param);
public abstract void method_throw () throws GirTest.ErrorTest;
public abstract void method_valist (int param, va_list vargs);
[NoWrapper]
public abstract void no_wrapper_method ();
[NoWrapper]
public abstract async void no_wrapper_method_async ();
[GIR (visible = false)]
public abstract async void skipped_coroutine_method (int param);
}
[CCode (cheader_filename = "girtest.h")]
[Compact]
public class CompactClass {
public int i;
public string s;
public CompactClass ();
}
[CCode (cheader_filename = "girtest.h")]
[Version (deprecated = true, deprecated_since = "0.1.2", since = "0.1.0")]
public class DeprecatedClassTest {
public DeprecatedClassTest ();
}
[CCode (cheader_filename = "girtest.h")]
public class GenericsObjectTest<G,T> : GLib.Object {
public GenericsObjectTest ();
public void method<K> (K[] param);
}
[CCode (cheader_filename = "girtest.h")]
public class GenericsTest<G,T> {
public GenericsTest (owned GirTest.DelegateTest cb);
public void method (T? param);
public GenericsTest.typed (owned GirTest.DelegateGenericsTest<G,T> cb);
}
[CCode (cheader_filename = "girtest.h")]
public class ImplementionTest : GLib.Object, GirTest.InterfaceTest {
public ImplementionTest ();
}
[CCode (cheader_filename = "girtest.h")]
[GIR (name = "RenamedClass")]
public class NamedClass {
public NamedClass ();
}
[CCode (cheader_filename = "girtest.h")]
[Compact]
[GIR (name = "RenamedCompactClass")]
public class NamedCompactClass {
public int i;
public string s;
public NamedCompactClass ();
}
[CCode (cheader_filename = "girtest.h")]
public class ObjectTest : GLib.Object {
public int field;
public int fixed_array_field[23];
public string? nullable_field;
public ObjectTest ();
public void array_in (int[] array);
public void array_inout (ref int[] array);
public void array_out (out int[] array);
public int[] array_return ();
public int[] array_return_int_in_delegate_out (int i1, out GirTest.DelegateTest d);
public (unowned string)[] container_return ();
public async void coroutine_async ();
public virtual async void coroutine_method_throw (int i1, out int o1) throws GirTest.ErrorTest;
public virtual async void coroutine_virtual_async ();
public GirTest.DelegateTest delegate_return ();
public GirTest.DelegateTest delegate_return_int_in_array_out (int i1, out int[] a);
public static void full_inout (ref GirTest.ObjectTest obj);
public static void full_out (out GirTest.ObjectTest obj);
public static GirTest.ObjectTest full_return ();
public GLib.GenericArray<weak string>? generic_array_container_return ();
public void int8_in (int8 param);
public void int8_out (out int8 param);
public void int_in_int_in_array_out (int param1, int param2, out int[] array);
public int[] int_in_int_in_array_return (int param1, int param2);
public ObjectTest.may_fail (int param) throws GirTest.ErrorTest;
public void method ();
public virtual void method_implicit_params (int[] param1, owned GirTest.DelegateTest param2);
public virtual void method_throw () throws GirTest.ErrorTest;
public void method_valist (int param, va_list vargs);
public void method_varargs (int param, ...);
public void method_with_default (int i = GLib.Priority.HIGH);
public virtual void method_with_default_impl (int8 param);
public ObjectTest.new_valist (int param, va_list vargs);
public ObjectTest.newv (int param, ...);
[NoWrapper]
public virtual void no_wrapper_method ();
[NoWrapper]
public virtual async void no_wrapper_method_async ();
public void none_in ();
public static void none_inout (ref unowned GirTest.ObjectTest obj);
public static void none_out (out unowned GirTest.ObjectTest obj);
public static unowned GirTest.ObjectTest none_return ();
public GLib.EqualFunc<string> simple_delegate_return ();
public void simple_throw () throws GirTest.ErrorTest;
[GIR (visible = false)]
public void skipped_method ();
public static void static_method ();
public void string_array_out (out string[] array);
public string[] string_array_return ();
public ObjectTest.with_int (int param);
public string construct_only_property { construct; }
[GIR (visible = false)]
public string skipped_property { get; set construct; }
public string some_property { get; set construct; }
public string write_only_property { set; }
public virtual signal void signal_with_default_handlder (int i1);
[GIR (visible = false)]
public signal void skipped_signal (int param);
public signal void some_signal (int param);
}
[CCode (cheader_filename = "girtest.h")]
public sealed class SealedObjectTest : GLib.Object {
public SealedObjectTest ();
}
[CCode (cheader_filename = "girtest.h")]
[GIR (visible = false)]
public class SkippedClass {
public SkippedClass ();
}
[CCode (cheader_filename = "girtest.h")]
public class SubTypeTest : GirTest.TypeTest {
public string[] array_field;
public GirTest.DelegateTest delegate_field;
public SubTypeTest ();
}
[CCode (cheader_filename = "girtest.h")]
public class TypeTest {
public TypeTest ();
public string some_property { get; set; }
}
[CCode (cheader_filename = "girtest.h")]
public interface InterfaceTest : GLib.Object {
public virtual async void coroutine_async ();
public virtual void int8_in (int8 param);
public virtual void method_implicit_params (int[] param1, owned GirTest.DelegateTest param2);
public virtual void method_valist (int param, va_list vargs);
[NoWrapper]
public virtual void no_wrapper_method ();
[NoWrapper]
public virtual async void no_wrapper_method_async ();
[GIR (visible = false)]
public virtual async void skipped_coroutine_method (int param);
public static void static_method ();
public abstract int property { get; set construct; }
[HasEmitter]
public signal void some_signal (int param);
}
[CCode (cheader_filename = "girtest.h")]
[GIR (name = "RenamedInterface")]
public interface NamedInterface : GLib.Object {
}
[CCode (cheader_filename = "girtest.h")]
public interface PrerequisiteTest : GirTest.InterfaceTest {
}
[CCode (cheader_filename = "girtest.h")]
[GIR (visible = false)]
public interface SkippedInterface {
}
[CCode (cheader_filename = "girtest.h")]
public struct BoxedStruct {
public int field_name;
public int internal_field_name;
public BoxedStruct ();
public BoxedStruct.foo (int param1, int param2);
public void inv ();
public GirTest.BoxedStruct ret ();
}
[CCode (cheader_filename = "girtest.h")]
[GIR (name = "RenamedStruct")]
public struct NamedStruct {
public int field_name;
}
[CCode (cheader_filename = "girtest.h")]
[GIR (visible = false)]
public struct SkippedStruct {
public int field_name;
}
[CCode (cheader_filename = "girtest.h", has_type_id = false)]
public struct Struct {
public int field_name;
public int internal_field_name;
public Struct ();
public Struct.foo (int param1, int param2);
public void inv ();
public GirTest.Struct ret ();
}
[CCode (cheader_filename = "girtest.h")]
public enum EnumTest {
VALUE1,
VALUE2,
VALUE3
}
[CCode (cheader_filename = "girtest.h")]
[Flags]
public enum FlagsTest {
VALUE1,
VALUE2,
VALUE3
}
[CCode (cheader_filename = "girtest.h")]
[Flags]
[GIR (name = "RenamedBitfield")]
public enum NamedBitfield {
VALUE1
}
[CCode (cheader_filename = "girtest.h")]
[GIR (name = "RenamedEnumeration")]
public enum NamedEnumeration {
VALUE1
}
[CCode (cheader_filename = "girtest.h", has_type_id = false)]
public enum PlainEnumTest {
VALUE1,
VALUE2,
VALUE3
}
[CCode (cheader_filename = "girtest.h")]
[GIR (visible = false)]
public enum SkippedEnum {
VALUE1
}
[CCode (cheader_filename = "girtest.h")]
[Flags]
[GIR (visible = false)]
public enum SkippedFlags {
VALUE1
}
[CCode (cheader_filename = "girtest.h")]
public errordomain ErrorTest {
FAILED,
SMELLY,
FISHY
}
[CCode (cheader_filename = "girtest.h")]
[GIR (name = "RenamedError")]
public errordomain NamedError {
FAILED
}
[CCode (cheader_filename = "girtest.h", has_type_id = false)]
public errordomain PlainErrorTest {
FAILED,
SMELLY,
FISHY
}
[CCode (cheader_filename = "girtest.h")]
public delegate bool DelegateErrorTest () throws GirTest.ErrorTest;
[CCode (cheader_filename = "girtest.h")]
public delegate bool DelegateGenericsTest<G,T> (G g, T? t);
[CCode (cheader_filename = "girtest.h")]
public delegate bool DelegateTest (void* a, void* b);
[CCode (cheader_filename = "girtest.h")]
[GIR (name = "RenamedDelegate")]
public delegate void NamedDelegate ();
[CCode (cheader_filename = "girtest.h")]
[GIR (visible = false)]
public delegate void SkippedDelegate ();
[CCode (cheader_filename = "girtest.h")]
public const char CHAR_LITERAL;
[CCode (cheader_filename = "girtest.h")]
public const int CONSTANT_NUMBER;
[CCode (cheader_filename = "girtest.h")]
public const string CONSTANT_STRING;
[CCode (cheader_filename = "girtest.h")]
public const bool FALSE_LITERAL;
[CCode (cheader_filename = "girtest.h")]
public const float FLOAT_LITERAL;
[CCode (cheader_filename = "girtest.h")]
public const int INTEGER_LITERAL;
[CCode (cheader_filename = "girtest.h")]
[GIR (name = "RENAMED_CONSTANT")]
public const int NAMED_CONSTANT;
[CCode (cheader_filename = "girtest.h")]
public const double REAL_LITERAL;
[CCode (cheader_filename = "girtest.h")]
public const bool TRUE_LITERAL;
[CCode (cheader_filename = "girtest.h")]
public static GirTest.NamedClass use_renamed_class (GirTest.NamedClass param);
[CCode (cheader_filename = "girtest.h")]
public static unowned GirTest.NamedCompactClass use_renamed_compact_class (GirTest.NamedCompactClass param);
[CCode (cheader_filename = "girtest.h")]
public static unowned GirTest.NamedDelegate use_renamed_delegate (GirTest.NamedDelegate param);
[CCode (cheader_filename = "girtest.h")]
public static GirTest.NamedEnumeration use_renamed_enumeration (GirTest.NamedEnumeration param);
[CCode (cheader_filename = "girtest.h")]
public static GirTest.NamedError use_renamed_error (GirTest.NamedError param);
[CCode (cheader_filename = "girtest.h")]
public static GirTest.NamedBitfield use_renamed_flags (GirTest.NamedBitfield param);
[CCode (cheader_filename = "girtest.h")]
public static GirTest.NamedInterface use_renamed_interface (GirTest.NamedInterface param);
[CCode (cheader_filename = "girtest.h")]
public static GirTest.NamedStruct? use_renamed_struct (GirTest.NamedStruct param);
}
[CCode (cheader_filename = "girtest.h")]
public enum InvalidEnum {
VALUE
}
[CCode (cheader_filename = "girtest.h")]
public errordomain InvalidError {
FAILED
}
[CCode (cheader_filename = "girtest.h")]
public class InvalidClass {
public InvalidClass ();
}
[CCode (cheader_filename = "girtest.h")]
public interface InvalidIface {
}
[CCode (cheader_filename = "girtest.h")]
public struct InvalidStruct {
public int i;
}
[CCode (cheader_filename = "girtest.h")]
public delegate void InvalidFunc ();
[CCode (cheader_filename = "girtest.h")]
public const int INVALID_CONST;
[CCode (cheader_filename = "girtest.h")]
public static int invalid_field;
[CCode (cheader_filename = "girtest.h")]
public static void invalid_method ();
|
