google-protobuf 3.22.0-arm64-darwin

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.


This version of google-protobuf might be problematic. Click here for more details.

Files changed (45) hide show
  1. checksums.yaml +7 -0
  2. data/ext/google/protobuf_c/convert.c +361 -0
  3. data/ext/google/protobuf_c/convert.h +75 -0
  4. data/ext/google/protobuf_c/defs.c +1280 -0
  5. data/ext/google/protobuf_c/defs.h +107 -0
  6. data/ext/google/protobuf_c/extconf.rb +27 -0
  7. data/ext/google/protobuf_c/map.c +687 -0
  8. data/ext/google/protobuf_c/map.h +66 -0
  9. data/ext/google/protobuf_c/message.c +1426 -0
  10. data/ext/google/protobuf_c/message.h +104 -0
  11. data/ext/google/protobuf_c/protobuf.c +480 -0
  12. data/ext/google/protobuf_c/protobuf.h +120 -0
  13. data/ext/google/protobuf_c/repeated_field.c +657 -0
  14. data/ext/google/protobuf_c/repeated_field.h +63 -0
  15. data/ext/google/protobuf_c/ruby-upb.c +13926 -0
  16. data/ext/google/protobuf_c/ruby-upb.h +10673 -0
  17. data/ext/google/protobuf_c/third_party/utf8_range/LICENSE +22 -0
  18. data/ext/google/protobuf_c/third_party/utf8_range/naive.c +92 -0
  19. data/ext/google/protobuf_c/third_party/utf8_range/range2-neon.c +157 -0
  20. data/ext/google/protobuf_c/third_party/utf8_range/range2-sse.c +170 -0
  21. data/ext/google/protobuf_c/third_party/utf8_range/utf8_range.h +21 -0
  22. data/ext/google/protobuf_c/wrap_memcpy.c +52 -0
  23. data/lib/google/2.6/protobuf_c.bundle +0 -0
  24. data/lib/google/2.7/protobuf_c.bundle +0 -0
  25. data/lib/google/3.0/protobuf_c.bundle +0 -0
  26. data/lib/google/3.1/protobuf_c.bundle +0 -0
  27. data/lib/google/3.2/protobuf_c.bundle +0 -0
  28. data/lib/google/protobuf/any_pb.rb +19 -0
  29. data/lib/google/protobuf/api_pb.rb +42 -0
  30. data/lib/google/protobuf/descriptor_dsl.rb +465 -0
  31. data/lib/google/protobuf/descriptor_pb.rb +298 -0
  32. data/lib/google/protobuf/duration_pb.rb +19 -0
  33. data/lib/google/protobuf/empty_pb.rb +17 -0
  34. data/lib/google/protobuf/field_mask_pb.rb +18 -0
  35. data/lib/google/protobuf/message_exts.rb +58 -0
  36. data/lib/google/protobuf/plugin_pb.rb +50 -0
  37. data/lib/google/protobuf/repeated_field.rb +201 -0
  38. data/lib/google/protobuf/source_context_pb.rb +18 -0
  39. data/lib/google/protobuf/struct_pb.rb +37 -0
  40. data/lib/google/protobuf/timestamp_pb.rb +19 -0
  41. data/lib/google/protobuf/type_pb.rb +92 -0
  42. data/lib/google/protobuf/well_known_types.rb +240 -0
  43. data/lib/google/protobuf/wrappers_pb.rb +50 -0
  44. data/lib/google/protobuf.rb +79 -0
  45. metadata +137 -0
@@ -0,0 +1,1280 @@
1
+ // Protocol Buffers - Google's data interchange format
2
+ // Copyright 2014 Google Inc. All rights reserved.
3
+ // https://developers.google.com/protocol-buffers/
4
+ //
5
+ // Redistribution and use in source and binary forms, with or without
6
+ // modification, are permitted provided that the following conditions are
7
+ // met:
8
+ //
9
+ // * Redistributions of source code must retain the above copyright
10
+ // notice, this list of conditions and the following disclaimer.
11
+ // * Redistributions in binary form must reproduce the above
12
+ // copyright notice, this list of conditions and the following disclaimer
13
+ // in the documentation and/or other materials provided with the
14
+ // distribution.
15
+ // * Neither the name of Google Inc. nor the names of its
16
+ // contributors may be used to endorse or promote products derived from
17
+ // this software without specific prior written permission.
18
+ //
19
+ // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20
+ // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21
+ // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22
+ // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23
+ // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24
+ // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25
+ // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26
+ // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27
+ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28
+ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29
+ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
+
31
+ #include <ctype.h>
32
+ #include <errno.h>
33
+ #include <ruby/version.h>
34
+
35
+ #include "convert.h"
36
+ #include "message.h"
37
+ #include "protobuf.h"
38
+
39
+ // -----------------------------------------------------------------------------
40
+ // Global map from upb {msg,enum}defs to wrapper Descriptor/EnumDescriptor
41
+ // instances.
42
+ // -----------------------------------------------------------------------------
43
+
44
+ static VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_MessageDef* def);
45
+ static VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_EnumDef* def);
46
+ static VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_FieldDef* def);
47
+ static VALUE get_filedef_obj(VALUE descriptor_pool, const upb_FileDef* def);
48
+ static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_OneofDef* def);
49
+
50
+ // A distinct object that is not accessible from Ruby. We use this as a
51
+ // constructor argument to enforce that certain objects cannot be created from
52
+ // Ruby.
53
+ VALUE c_only_cookie = Qnil;
54
+
55
+ // -----------------------------------------------------------------------------
56
+ // Common utilities.
57
+ // -----------------------------------------------------------------------------
58
+
59
+ static const char* get_str(VALUE str) {
60
+ Check_Type(str, T_STRING);
61
+ return RSTRING_PTR(str);
62
+ }
63
+
64
+ static VALUE rb_str_maybe_null(const char* s) {
65
+ if (s == NULL) {
66
+ s = "";
67
+ }
68
+ return rb_str_new2(s);
69
+ }
70
+
71
+ // -----------------------------------------------------------------------------
72
+ // DescriptorPool.
73
+ // -----------------------------------------------------------------------------
74
+
75
+ typedef struct {
76
+ VALUE def_to_descriptor; // Hash table of def* -> Ruby descriptor.
77
+ upb_DefPool* symtab;
78
+ } DescriptorPool;
79
+
80
+ VALUE cDescriptorPool = Qnil;
81
+
82
+ // Global singleton DescriptorPool. The user is free to create others, but this
83
+ // is used by generated code.
84
+ VALUE generated_pool = Qnil;
85
+
86
+ static void DescriptorPool_mark(void* _self) {
87
+ DescriptorPool* self = _self;
88
+ rb_gc_mark(self->def_to_descriptor);
89
+ }
90
+
91
+ static void DescriptorPool_free(void* _self) {
92
+ DescriptorPool* self = _self;
93
+ upb_DefPool_Free(self->symtab);
94
+ xfree(self);
95
+ }
96
+
97
+ static const rb_data_type_t DescriptorPool_type = {
98
+ "Google::Protobuf::DescriptorPool",
99
+ {DescriptorPool_mark, DescriptorPool_free, NULL},
100
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY,
101
+ };
102
+
103
+ static DescriptorPool* ruby_to_DescriptorPool(VALUE val) {
104
+ DescriptorPool* ret;
105
+ TypedData_Get_Struct(val, DescriptorPool, &DescriptorPool_type, ret);
106
+ return ret;
107
+ }
108
+
109
+ // Exposed to other modules in defs.h.
110
+ const upb_DefPool* DescriptorPool_GetSymtab(VALUE desc_pool_rb) {
111
+ DescriptorPool* pool = ruby_to_DescriptorPool(desc_pool_rb);
112
+ return pool->symtab;
113
+ }
114
+
115
+ /*
116
+ * call-seq:
117
+ * DescriptorPool.new => pool
118
+ *
119
+ * Creates a new, empty, descriptor pool.
120
+ */
121
+ static VALUE DescriptorPool_alloc(VALUE klass) {
122
+ DescriptorPool* self = ALLOC(DescriptorPool);
123
+ VALUE ret;
124
+
125
+ self->def_to_descriptor = Qnil;
126
+ ret = TypedData_Wrap_Struct(klass, &DescriptorPool_type, self);
127
+
128
+ self->def_to_descriptor = rb_hash_new();
129
+ self->symtab = upb_DefPool_New();
130
+ ObjectCache_Add(self->symtab, ret);
131
+
132
+ return ret;
133
+ }
134
+
135
+ /*
136
+ * call-seq:
137
+ * DescriptorPool.add_serialized_file(serialized_file_proto)
138
+ *
139
+ * Adds the given serialized FileDescriptorProto to the pool.
140
+ */
141
+ VALUE DescriptorPool_add_serialized_file(VALUE _self,
142
+ VALUE serialized_file_proto) {
143
+ DescriptorPool* self = ruby_to_DescriptorPool(_self);
144
+ Check_Type(serialized_file_proto, T_STRING);
145
+ VALUE arena_rb = Arena_new();
146
+ upb_Arena* arena = Arena_get(arena_rb);
147
+ google_protobuf_FileDescriptorProto* file_proto =
148
+ google_protobuf_FileDescriptorProto_parse(
149
+ RSTRING_PTR(serialized_file_proto),
150
+ RSTRING_LEN(serialized_file_proto), arena);
151
+ if (!file_proto) {
152
+ rb_raise(rb_eArgError, "Unable to parse FileDescriptorProto");
153
+ }
154
+ upb_Status status;
155
+ upb_Status_Clear(&status);
156
+ const upb_FileDef* filedef =
157
+ upb_DefPool_AddFile(self->symtab, file_proto, &status);
158
+ if (!filedef) {
159
+ rb_raise(cTypeError, "Unable to build file to DescriptorPool: %s",
160
+ upb_Status_ErrorMessage(&status));
161
+ }
162
+ RB_GC_GUARD(arena_rb);
163
+ return get_filedef_obj(_self, filedef);
164
+ }
165
+
166
+ /*
167
+ * call-seq:
168
+ * DescriptorPool.lookup(name) => descriptor
169
+ *
170
+ * Finds a Descriptor or EnumDescriptor by name and returns it, or nil if none
171
+ * exists with the given name.
172
+ */
173
+ static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
174
+ DescriptorPool* self = ruby_to_DescriptorPool(_self);
175
+ const char* name_str = get_str(name);
176
+ const upb_MessageDef* msgdef;
177
+ const upb_EnumDef* enumdef;
178
+
179
+ msgdef = upb_DefPool_FindMessageByName(self->symtab, name_str);
180
+ if (msgdef) {
181
+ return get_msgdef_obj(_self, msgdef);
182
+ }
183
+
184
+ enumdef = upb_DefPool_FindEnumByName(self->symtab, name_str);
185
+ if (enumdef) {
186
+ return get_enumdef_obj(_self, enumdef);
187
+ }
188
+
189
+ return Qnil;
190
+ }
191
+
192
+ /*
193
+ * call-seq:
194
+ * DescriptorPool.generated_pool => descriptor_pool
195
+ *
196
+ * Class method that returns the global DescriptorPool. This is a singleton into
197
+ * which generated-code message and enum types are registered. The user may also
198
+ * register types in this pool for convenience so that they do not have to hold
199
+ * a reference to a private pool instance.
200
+ */
201
+ static VALUE DescriptorPool_generated_pool(VALUE _self) {
202
+ return generated_pool;
203
+ }
204
+
205
+ static void DescriptorPool_register(VALUE module) {
206
+ VALUE klass = rb_define_class_under(module, "DescriptorPool", rb_cObject);
207
+ rb_define_alloc_func(klass, DescriptorPool_alloc);
208
+ rb_define_method(klass, "add_serialized_file",
209
+ DescriptorPool_add_serialized_file, 1);
210
+ rb_define_method(klass, "lookup", DescriptorPool_lookup, 1);
211
+ rb_define_singleton_method(klass, "generated_pool",
212
+ DescriptorPool_generated_pool, 0);
213
+ rb_gc_register_address(&cDescriptorPool);
214
+ cDescriptorPool = klass;
215
+
216
+ rb_gc_register_address(&generated_pool);
217
+ generated_pool = rb_class_new_instance(0, NULL, klass);
218
+ }
219
+
220
+ // -----------------------------------------------------------------------------
221
+ // Descriptor.
222
+ // -----------------------------------------------------------------------------
223
+
224
+ typedef struct {
225
+ const upb_MessageDef* msgdef;
226
+ VALUE klass;
227
+ VALUE descriptor_pool;
228
+ } Descriptor;
229
+
230
+ VALUE cDescriptor = Qnil;
231
+
232
+ static void Descriptor_mark(void* _self) {
233
+ Descriptor* self = _self;
234
+ rb_gc_mark(self->klass);
235
+ rb_gc_mark(self->descriptor_pool);
236
+ }
237
+
238
+ static const rb_data_type_t Descriptor_type = {
239
+ "Google::Protobuf::Descriptor",
240
+ {Descriptor_mark, RUBY_DEFAULT_FREE, NULL},
241
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY,
242
+ };
243
+
244
+ static Descriptor* ruby_to_Descriptor(VALUE val) {
245
+ Descriptor* ret;
246
+ TypedData_Get_Struct(val, Descriptor, &Descriptor_type, ret);
247
+ return ret;
248
+ }
249
+
250
+ /*
251
+ * call-seq:
252
+ * Descriptor.new => descriptor
253
+ *
254
+ * Creates a new, empty, message type descriptor. At a minimum, its name must be
255
+ * set before it is added to a pool. It cannot be used to create messages until
256
+ * it is added to a pool, after which it becomes immutable (as part of a
257
+ * finalization process).
258
+ */
259
+ static VALUE Descriptor_alloc(VALUE klass) {
260
+ Descriptor* self = ALLOC(Descriptor);
261
+ VALUE ret = TypedData_Wrap_Struct(klass, &Descriptor_type, self);
262
+ self->msgdef = NULL;
263
+ self->klass = Qnil;
264
+ self->descriptor_pool = Qnil;
265
+ return ret;
266
+ }
267
+
268
+ /*
269
+ * call-seq:
270
+ * Descriptor.new(c_only_cookie, ptr) => Descriptor
271
+ *
272
+ * Creates a descriptor wrapper object. May only be called from C.
273
+ */
274
+ static VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
275
+ VALUE descriptor_pool, VALUE ptr) {
276
+ Descriptor* self = ruby_to_Descriptor(_self);
277
+
278
+ if (cookie != c_only_cookie) {
279
+ rb_raise(rb_eRuntimeError,
280
+ "Descriptor objects may not be created from Ruby.");
281
+ }
282
+
283
+ self->descriptor_pool = descriptor_pool;
284
+ self->msgdef = (const upb_MessageDef*)NUM2ULL(ptr);
285
+
286
+ return Qnil;
287
+ }
288
+
289
+ /*
290
+ * call-seq:
291
+ * Descriptor.file_descriptor
292
+ *
293
+ * Returns the FileDescriptor object this message belongs to.
294
+ */
295
+ static VALUE Descriptor_file_descriptor(VALUE _self) {
296
+ Descriptor* self = ruby_to_Descriptor(_self);
297
+ return get_filedef_obj(self->descriptor_pool,
298
+ upb_MessageDef_File(self->msgdef));
299
+ }
300
+
301
+ /*
302
+ * call-seq:
303
+ * Descriptor.name => name
304
+ *
305
+ * Returns the name of this message type as a fully-qualified string (e.g.,
306
+ * My.Package.MessageType).
307
+ */
308
+ static VALUE Descriptor_name(VALUE _self) {
309
+ Descriptor* self = ruby_to_Descriptor(_self);
310
+ return rb_str_maybe_null(upb_MessageDef_FullName(self->msgdef));
311
+ }
312
+
313
+ /*
314
+ * call-seq:
315
+ * Descriptor.each(&block)
316
+ *
317
+ * Iterates over fields in this message type, yielding to the block on each one.
318
+ */
319
+ static VALUE Descriptor_each(VALUE _self) {
320
+ Descriptor* self = ruby_to_Descriptor(_self);
321
+
322
+ int n = upb_MessageDef_FieldCount(self->msgdef);
323
+ for (int i = 0; i < n; i++) {
324
+ const upb_FieldDef* field = upb_MessageDef_Field(self->msgdef, i);
325
+ VALUE obj = get_fielddef_obj(self->descriptor_pool, field);
326
+ rb_yield(obj);
327
+ }
328
+ return Qnil;
329
+ }
330
+
331
+ /*
332
+ * call-seq:
333
+ * Descriptor.lookup(name) => FieldDescriptor
334
+ *
335
+ * Returns the field descriptor for the field with the given name, if present,
336
+ * or nil if none.
337
+ */
338
+ static VALUE Descriptor_lookup(VALUE _self, VALUE name) {
339
+ Descriptor* self = ruby_to_Descriptor(_self);
340
+ const char* s = get_str(name);
341
+ const upb_FieldDef* field = upb_MessageDef_FindFieldByName(self->msgdef, s);
342
+ if (field == NULL) {
343
+ return Qnil;
344
+ }
345
+ return get_fielddef_obj(self->descriptor_pool, field);
346
+ }
347
+
348
+ /*
349
+ * call-seq:
350
+ * Descriptor.each_oneof(&block) => nil
351
+ *
352
+ * Invokes the given block for each oneof in this message type, passing the
353
+ * corresponding OneofDescriptor.
354
+ */
355
+ static VALUE Descriptor_each_oneof(VALUE _self) {
356
+ Descriptor* self = ruby_to_Descriptor(_self);
357
+
358
+ int n = upb_MessageDef_OneofCount(self->msgdef);
359
+ for (int i = 0; i < n; i++) {
360
+ const upb_OneofDef* oneof = upb_MessageDef_Oneof(self->msgdef, i);
361
+ VALUE obj = get_oneofdef_obj(self->descriptor_pool, oneof);
362
+ rb_yield(obj);
363
+ }
364
+ return Qnil;
365
+ }
366
+
367
+ /*
368
+ * call-seq:
369
+ * Descriptor.lookup_oneof(name) => OneofDescriptor
370
+ *
371
+ * Returns the oneof descriptor for the oneof with the given name, if present,
372
+ * or nil if none.
373
+ */
374
+ static VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
375
+ Descriptor* self = ruby_to_Descriptor(_self);
376
+ const char* s = get_str(name);
377
+ const upb_OneofDef* oneof = upb_MessageDef_FindOneofByName(self->msgdef, s);
378
+ if (oneof == NULL) {
379
+ return Qnil;
380
+ }
381
+ return get_oneofdef_obj(self->descriptor_pool, oneof);
382
+ }
383
+
384
+ /*
385
+ * call-seq:
386
+ * Descriptor.msgclass => message_klass
387
+ *
388
+ * Returns the Ruby class created for this message type.
389
+ */
390
+ static VALUE Descriptor_msgclass(VALUE _self) {
391
+ Descriptor* self = ruby_to_Descriptor(_self);
392
+ if (self->klass == Qnil) {
393
+ self->klass = build_class_from_descriptor(_self);
394
+ }
395
+ return self->klass;
396
+ }
397
+
398
+ static void Descriptor_register(VALUE module) {
399
+ VALUE klass = rb_define_class_under(module, "Descriptor", rb_cObject);
400
+ rb_define_alloc_func(klass, Descriptor_alloc);
401
+ rb_define_method(klass, "initialize", Descriptor_initialize, 3);
402
+ rb_define_method(klass, "each", Descriptor_each, 0);
403
+ rb_define_method(klass, "lookup", Descriptor_lookup, 1);
404
+ rb_define_method(klass, "each_oneof", Descriptor_each_oneof, 0);
405
+ rb_define_method(klass, "lookup_oneof", Descriptor_lookup_oneof, 1);
406
+ rb_define_method(klass, "msgclass", Descriptor_msgclass, 0);
407
+ rb_define_method(klass, "name", Descriptor_name, 0);
408
+ rb_define_method(klass, "file_descriptor", Descriptor_file_descriptor, 0);
409
+ rb_include_module(klass, rb_mEnumerable);
410
+ rb_gc_register_address(&cDescriptor);
411
+ cDescriptor = klass;
412
+ }
413
+
414
+ // -----------------------------------------------------------------------------
415
+ // FileDescriptor.
416
+ // -----------------------------------------------------------------------------
417
+
418
+ typedef struct {
419
+ const upb_FileDef* filedef;
420
+ VALUE descriptor_pool; // Owns the upb_FileDef.
421
+ } FileDescriptor;
422
+
423
+ static VALUE cFileDescriptor = Qnil;
424
+
425
+ static void FileDescriptor_mark(void* _self) {
426
+ FileDescriptor* self = _self;
427
+ rb_gc_mark(self->descriptor_pool);
428
+ }
429
+
430
+ static const rb_data_type_t FileDescriptor_type = {
431
+ "Google::Protobuf::FileDescriptor",
432
+ {FileDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
433
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY,
434
+ };
435
+
436
+ static FileDescriptor* ruby_to_FileDescriptor(VALUE val) {
437
+ FileDescriptor* ret;
438
+ TypedData_Get_Struct(val, FileDescriptor, &FileDescriptor_type, ret);
439
+ return ret;
440
+ }
441
+
442
+ static VALUE FileDescriptor_alloc(VALUE klass) {
443
+ FileDescriptor* self = ALLOC(FileDescriptor);
444
+ VALUE ret = TypedData_Wrap_Struct(klass, &FileDescriptor_type, self);
445
+ self->descriptor_pool = Qnil;
446
+ self->filedef = NULL;
447
+ return ret;
448
+ }
449
+
450
+ /*
451
+ * call-seq:
452
+ * FileDescriptor.new => file
453
+ *
454
+ * Returns a new file descriptor. The syntax must be set before it's passed
455
+ * to a builder.
456
+ */
457
+ static VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
458
+ VALUE descriptor_pool, VALUE ptr) {
459
+ FileDescriptor* self = ruby_to_FileDescriptor(_self);
460
+
461
+ if (cookie != c_only_cookie) {
462
+ rb_raise(rb_eRuntimeError,
463
+ "Descriptor objects may not be created from Ruby.");
464
+ }
465
+
466
+ self->descriptor_pool = descriptor_pool;
467
+ self->filedef = (const upb_FileDef*)NUM2ULL(ptr);
468
+
469
+ return Qnil;
470
+ }
471
+
472
+ /*
473
+ * call-seq:
474
+ * FileDescriptor.name => name
475
+ *
476
+ * Returns the name of the file.
477
+ */
478
+ static VALUE FileDescriptor_name(VALUE _self) {
479
+ FileDescriptor* self = ruby_to_FileDescriptor(_self);
480
+ const char* name = upb_FileDef_Name(self->filedef);
481
+ return name == NULL ? Qnil : rb_str_new2(name);
482
+ }
483
+
484
+ /*
485
+ * call-seq:
486
+ * FileDescriptor.syntax => syntax
487
+ *
488
+ * Returns this file descriptors syntax.
489
+ *
490
+ * Valid syntax versions are:
491
+ * :proto2 or :proto3.
492
+ */
493
+ static VALUE FileDescriptor_syntax(VALUE _self) {
494
+ FileDescriptor* self = ruby_to_FileDescriptor(_self);
495
+
496
+ switch (upb_FileDef_Syntax(self->filedef)) {
497
+ case kUpb_Syntax_Proto3:
498
+ return ID2SYM(rb_intern("proto3"));
499
+ case kUpb_Syntax_Proto2:
500
+ return ID2SYM(rb_intern("proto2"));
501
+ default:
502
+ return Qnil;
503
+ }
504
+ }
505
+
506
+ static void FileDescriptor_register(VALUE module) {
507
+ VALUE klass = rb_define_class_under(module, "FileDescriptor", rb_cObject);
508
+ rb_define_alloc_func(klass, FileDescriptor_alloc);
509
+ rb_define_method(klass, "initialize", FileDescriptor_initialize, 3);
510
+ rb_define_method(klass, "name", FileDescriptor_name, 0);
511
+ rb_define_method(klass, "syntax", FileDescriptor_syntax, 0);
512
+ rb_gc_register_address(&cFileDescriptor);
513
+ cFileDescriptor = klass;
514
+ }
515
+
516
+ // -----------------------------------------------------------------------------
517
+ // FieldDescriptor.
518
+ // -----------------------------------------------------------------------------
519
+
520
+ typedef struct {
521
+ const upb_FieldDef* fielddef;
522
+ VALUE descriptor_pool; // Owns the upb_FieldDef.
523
+ } FieldDescriptor;
524
+
525
+ static VALUE cFieldDescriptor = Qnil;
526
+
527
+ static void FieldDescriptor_mark(void* _self) {
528
+ FieldDescriptor* self = _self;
529
+ rb_gc_mark(self->descriptor_pool);
530
+ }
531
+
532
+ static const rb_data_type_t FieldDescriptor_type = {
533
+ "Google::Protobuf::FieldDescriptor",
534
+ {FieldDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
535
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY,
536
+ };
537
+
538
+ static FieldDescriptor* ruby_to_FieldDescriptor(VALUE val) {
539
+ FieldDescriptor* ret;
540
+ TypedData_Get_Struct(val, FieldDescriptor, &FieldDescriptor_type, ret);
541
+ return ret;
542
+ }
543
+
544
+ /*
545
+ * call-seq:
546
+ * FieldDescriptor.new => field
547
+ *
548
+ * Returns a new field descriptor. Its name, type, etc. must be set before it is
549
+ * added to a message type.
550
+ */
551
+ static VALUE FieldDescriptor_alloc(VALUE klass) {
552
+ FieldDescriptor* self = ALLOC(FieldDescriptor);
553
+ VALUE ret = TypedData_Wrap_Struct(klass, &FieldDescriptor_type, self);
554
+ self->fielddef = NULL;
555
+ return ret;
556
+ }
557
+
558
+ /*
559
+ * call-seq:
560
+ * EnumDescriptor.new(c_only_cookie, pool, ptr) => EnumDescriptor
561
+ *
562
+ * Creates a descriptor wrapper object. May only be called from C.
563
+ */
564
+ static VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
565
+ VALUE descriptor_pool, VALUE ptr) {
566
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
567
+
568
+ if (cookie != c_only_cookie) {
569
+ rb_raise(rb_eRuntimeError,
570
+ "Descriptor objects may not be created from Ruby.");
571
+ }
572
+
573
+ self->descriptor_pool = descriptor_pool;
574
+ self->fielddef = (const upb_FieldDef*)NUM2ULL(ptr);
575
+
576
+ return Qnil;
577
+ }
578
+
579
+ /*
580
+ * call-seq:
581
+ * FieldDescriptor.name => name
582
+ *
583
+ * Returns the name of this field.
584
+ */
585
+ static VALUE FieldDescriptor_name(VALUE _self) {
586
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
587
+ return rb_str_maybe_null(upb_FieldDef_Name(self->fielddef));
588
+ }
589
+
590
+ // Non-static, exposed to other .c files.
591
+ upb_CType ruby_to_fieldtype(VALUE type) {
592
+ if (TYPE(type) != T_SYMBOL) {
593
+ rb_raise(rb_eArgError, "Expected symbol for field type.");
594
+ }
595
+
596
+ #define CONVERT(upb, ruby) \
597
+ if (SYM2ID(type) == rb_intern(#ruby)) { \
598
+ return kUpb_CType_##upb; \
599
+ }
600
+
601
+ CONVERT(Float, float);
602
+ CONVERT(Double, double);
603
+ CONVERT(Bool, bool);
604
+ CONVERT(String, string);
605
+ CONVERT(Bytes, bytes);
606
+ CONVERT(Message, message);
607
+ CONVERT(Enum, enum);
608
+ CONVERT(Int32, int32);
609
+ CONVERT(Int64, int64);
610
+ CONVERT(UInt32, uint32);
611
+ CONVERT(UInt64, uint64);
612
+
613
+ #undef CONVERT
614
+
615
+ rb_raise(rb_eArgError, "Unknown field type.");
616
+ return 0;
617
+ }
618
+
619
+ static VALUE descriptortype_to_ruby(upb_FieldType type) {
620
+ switch (type) {
621
+ #define CONVERT(upb, ruby) \
622
+ case kUpb_FieldType_##upb: \
623
+ return ID2SYM(rb_intern(#ruby));
624
+ CONVERT(Float, float);
625
+ CONVERT(Double, double);
626
+ CONVERT(Bool, bool);
627
+ CONVERT(String, string);
628
+ CONVERT(Bytes, bytes);
629
+ CONVERT(Message, message);
630
+ CONVERT(Group, group);
631
+ CONVERT(Enum, enum);
632
+ CONVERT(Int32, int32);
633
+ CONVERT(Int64, int64);
634
+ CONVERT(UInt32, uint32);
635
+ CONVERT(UInt64, uint64);
636
+ CONVERT(SInt32, sint32);
637
+ CONVERT(SInt64, sint64);
638
+ CONVERT(Fixed32, fixed32);
639
+ CONVERT(Fixed64, fixed64);
640
+ CONVERT(SFixed32, sfixed32);
641
+ CONVERT(SFixed64, sfixed64);
642
+ #undef CONVERT
643
+ }
644
+ return Qnil;
645
+ }
646
+
647
+ /*
648
+ * call-seq:
649
+ * FieldDescriptor.type => type
650
+ *
651
+ * Returns this field's type, as a Ruby symbol, or nil if not yet set.
652
+ *
653
+ * Valid field types are:
654
+ * :int32, :int64, :uint32, :uint64, :float, :double, :bool, :string,
655
+ * :bytes, :message.
656
+ */
657
+ static VALUE FieldDescriptor__type(VALUE _self) {
658
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
659
+ return descriptortype_to_ruby(upb_FieldDef_Type(self->fielddef));
660
+ }
661
+
662
+ /*
663
+ * call-seq:
664
+ * FieldDescriptor.default => default
665
+ *
666
+ * Returns this field's default, as a Ruby object, or nil if not yet set.
667
+ */
668
+ static VALUE FieldDescriptor_default(VALUE _self) {
669
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
670
+ const upb_FieldDef* f = self->fielddef;
671
+ upb_MessageValue default_val = {0};
672
+ if (upb_FieldDef_IsSubMessage(f)) {
673
+ return Qnil;
674
+ } else if (!upb_FieldDef_IsRepeated(f)) {
675
+ default_val = upb_FieldDef_Default(f);
676
+ }
677
+ return Convert_UpbToRuby(default_val, TypeInfo_get(self->fielddef), Qnil);
678
+ }
679
+
680
+ /*
681
+ * call-seq:
682
+ * FieldDescriptor.json_name => json_name
683
+ *
684
+ * Returns this field's json_name, as a Ruby string, or nil if not yet set.
685
+ */
686
+ static VALUE FieldDescriptor_json_name(VALUE _self) {
687
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
688
+ const upb_FieldDef* f = self->fielddef;
689
+ const char* json_name = upb_FieldDef_JsonName(f);
690
+ return rb_str_new2(json_name);
691
+ }
692
+
693
+ /*
694
+ * call-seq:
695
+ * FieldDescriptor.label => label
696
+ *
697
+ * Returns this field's label (i.e., plurality), as a Ruby symbol.
698
+ *
699
+ * Valid field labels are:
700
+ * :optional, :repeated
701
+ */
702
+ static VALUE FieldDescriptor_label(VALUE _self) {
703
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
704
+ switch (upb_FieldDef_Label(self->fielddef)) {
705
+ #define CONVERT(upb, ruby) \
706
+ case kUpb_Label_##upb: \
707
+ return ID2SYM(rb_intern(#ruby));
708
+
709
+ CONVERT(Optional, optional);
710
+ CONVERT(Required, required);
711
+ CONVERT(Repeated, repeated);
712
+
713
+ #undef CONVERT
714
+ }
715
+
716
+ return Qnil;
717
+ }
718
+
719
+ /*
720
+ * call-seq:
721
+ * FieldDescriptor.number => number
722
+ *
723
+ * Returns the tag number for this field.
724
+ */
725
+ static VALUE FieldDescriptor_number(VALUE _self) {
726
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
727
+ return INT2NUM(upb_FieldDef_Number(self->fielddef));
728
+ }
729
+
730
+ /*
731
+ * call-seq:
732
+ * FieldDescriptor.submsg_name => submsg_name
733
+ *
734
+ * Returns the name of the message or enum type corresponding to this field, if
735
+ * it is a message or enum field (respectively), or nil otherwise. This type
736
+ * name will be resolved within the context of the pool to which the containing
737
+ * message type is added.
738
+ */
739
+ static VALUE FieldDescriptor_submsg_name(VALUE _self) {
740
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
741
+ switch (upb_FieldDef_CType(self->fielddef)) {
742
+ case kUpb_CType_Enum:
743
+ return rb_str_new2(
744
+ upb_EnumDef_FullName(upb_FieldDef_EnumSubDef(self->fielddef)));
745
+ case kUpb_CType_Message:
746
+ return rb_str_new2(
747
+ upb_MessageDef_FullName(upb_FieldDef_MessageSubDef(self->fielddef)));
748
+ default:
749
+ return Qnil;
750
+ }
751
+ }
752
+
753
+ /*
754
+ * call-seq:
755
+ * FieldDescriptor.subtype => message_or_enum_descriptor
756
+ *
757
+ * Returns the message or enum descriptor corresponding to this field's type if
758
+ * it is a message or enum field, respectively, or nil otherwise. Cannot be
759
+ * called *until* the containing message type is added to a pool (and thus
760
+ * resolved).
761
+ */
762
+ static VALUE FieldDescriptor_subtype(VALUE _self) {
763
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
764
+ switch (upb_FieldDef_CType(self->fielddef)) {
765
+ case kUpb_CType_Enum:
766
+ return get_enumdef_obj(self->descriptor_pool,
767
+ upb_FieldDef_EnumSubDef(self->fielddef));
768
+ case kUpb_CType_Message:
769
+ return get_msgdef_obj(self->descriptor_pool,
770
+ upb_FieldDef_MessageSubDef(self->fielddef));
771
+ default:
772
+ return Qnil;
773
+ }
774
+ }
775
+
776
+ /*
777
+ * call-seq:
778
+ * FieldDescriptor.get(message) => value
779
+ *
780
+ * Returns the value set for this field on the given message. Raises an
781
+ * exception if message is of the wrong type.
782
+ */
783
+ static VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
784
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
785
+ const upb_MessageDef* m;
786
+
787
+ Message_Get(msg_rb, &m);
788
+
789
+ if (m != upb_FieldDef_ContainingType(self->fielddef)) {
790
+ rb_raise(cTypeError, "get method called on wrong message type");
791
+ }
792
+
793
+ return Message_getfield(msg_rb, self->fielddef);
794
+ }
795
+
796
+ /*
797
+ * call-seq:
798
+ * FieldDescriptor.has?(message) => boolean
799
+ *
800
+ * Returns whether the value is set on the given message. Raises an
801
+ * exception when calling for fields that do not have presence.
802
+ */
803
+ static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
804
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
805
+ const upb_MessageDef* m;
806
+ const upb_MessageDef* msg = Message_Get(msg_rb, &m);
807
+
808
+ if (m != upb_FieldDef_ContainingType(self->fielddef)) {
809
+ rb_raise(cTypeError, "has method called on wrong message type");
810
+ } else if (!upb_FieldDef_HasPresence(self->fielddef)) {
811
+ rb_raise(rb_eArgError, "does not track presence");
812
+ }
813
+
814
+ return upb_Message_HasFieldByDef(msg, self->fielddef) ? Qtrue : Qfalse;
815
+ }
816
+
817
+ /*
818
+ * call-seq:
819
+ * FieldDescriptor.clear(message)
820
+ *
821
+ * Clears the field from the message if it's set.
822
+ */
823
+ static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
824
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
825
+ const upb_MessageDef* m;
826
+ upb_MessageDef* msg = Message_GetMutable(msg_rb, &m);
827
+
828
+ if (m != upb_FieldDef_ContainingType(self->fielddef)) {
829
+ rb_raise(cTypeError, "has method called on wrong message type");
830
+ }
831
+
832
+ upb_Message_ClearFieldByDef(msg, self->fielddef);
833
+ return Qnil;
834
+ }
835
+
836
+ /*
837
+ * call-seq:
838
+ * FieldDescriptor.set(message, value)
839
+ *
840
+ * Sets the value corresponding to this field to the given value on the given
841
+ * message. Raises an exception if message is of the wrong type. Performs the
842
+ * ordinary type-checks for field setting.
843
+ */
844
+ static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
845
+ FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
846
+ const upb_MessageDef* m;
847
+ upb_MessageDef* msg = Message_GetMutable(msg_rb, &m);
848
+ upb_Arena* arena = Arena_get(Message_GetArena(msg_rb));
849
+ upb_MessageValue msgval;
850
+
851
+ if (m != upb_FieldDef_ContainingType(self->fielddef)) {
852
+ rb_raise(cTypeError, "set method called on wrong message type");
853
+ }
854
+
855
+ msgval = Convert_RubyToUpb(value, upb_FieldDef_Name(self->fielddef),
856
+ TypeInfo_get(self->fielddef), arena);
857
+ upb_Message_SetFieldByDef(msg, self->fielddef, msgval, arena);
858
+ return Qnil;
859
+ }
860
+
861
+ static void FieldDescriptor_register(VALUE module) {
862
+ VALUE klass = rb_define_class_under(module, "FieldDescriptor", rb_cObject);
863
+ rb_define_alloc_func(klass, FieldDescriptor_alloc);
864
+ rb_define_method(klass, "initialize", FieldDescriptor_initialize, 3);
865
+ rb_define_method(klass, "name", FieldDescriptor_name, 0);
866
+ rb_define_method(klass, "type", FieldDescriptor__type, 0);
867
+ rb_define_method(klass, "default", FieldDescriptor_default, 0);
868
+ rb_define_method(klass, "json_name", FieldDescriptor_json_name, 0);
869
+ rb_define_method(klass, "label", FieldDescriptor_label, 0);
870
+ rb_define_method(klass, "number", FieldDescriptor_number, 0);
871
+ rb_define_method(klass, "submsg_name", FieldDescriptor_submsg_name, 0);
872
+ rb_define_method(klass, "subtype", FieldDescriptor_subtype, 0);
873
+ rb_define_method(klass, "has?", FieldDescriptor_has, 1);
874
+ rb_define_method(klass, "clear", FieldDescriptor_clear, 1);
875
+ rb_define_method(klass, "get", FieldDescriptor_get, 1);
876
+ rb_define_method(klass, "set", FieldDescriptor_set, 2);
877
+ rb_gc_register_address(&cFieldDescriptor);
878
+ cFieldDescriptor = klass;
879
+ }
880
+
881
+ // -----------------------------------------------------------------------------
882
+ // OneofDescriptor.
883
+ // -----------------------------------------------------------------------------
884
+
885
+ typedef struct {
886
+ const upb_OneofDef* oneofdef;
887
+ VALUE descriptor_pool; // Owns the upb_OneofDef.
888
+ } OneofDescriptor;
889
+
890
+ static VALUE cOneofDescriptor = Qnil;
891
+
892
+ static void OneofDescriptor_mark(void* _self) {
893
+ OneofDescriptor* self = _self;
894
+ rb_gc_mark(self->descriptor_pool);
895
+ }
896
+
897
+ static const rb_data_type_t OneofDescriptor_type = {
898
+ "Google::Protobuf::OneofDescriptor",
899
+ {OneofDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
900
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY,
901
+ };
902
+
903
+ static OneofDescriptor* ruby_to_OneofDescriptor(VALUE val) {
904
+ OneofDescriptor* ret;
905
+ TypedData_Get_Struct(val, OneofDescriptor, &OneofDescriptor_type, ret);
906
+ return ret;
907
+ }
908
+
909
+ /*
910
+ * call-seq:
911
+ * OneofDescriptor.new => oneof_descriptor
912
+ *
913
+ * Creates a new, empty, oneof descriptor. The oneof may only be modified prior
914
+ * to being added to a message descriptor which is subsequently added to a pool.
915
+ */
916
+ static VALUE OneofDescriptor_alloc(VALUE klass) {
917
+ OneofDescriptor* self = ALLOC(OneofDescriptor);
918
+ VALUE ret = TypedData_Wrap_Struct(klass, &OneofDescriptor_type, self);
919
+ self->oneofdef = NULL;
920
+ self->descriptor_pool = Qnil;
921
+ return ret;
922
+ }
923
+
924
+ /*
925
+ * call-seq:
926
+ * OneofDescriptor.new(c_only_cookie, pool, ptr) => OneofDescriptor
927
+ *
928
+ * Creates a descriptor wrapper object. May only be called from C.
929
+ */
930
+ static VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
931
+ VALUE descriptor_pool, VALUE ptr) {
932
+ OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
933
+
934
+ if (cookie != c_only_cookie) {
935
+ rb_raise(rb_eRuntimeError,
936
+ "Descriptor objects may not be created from Ruby.");
937
+ }
938
+
939
+ self->descriptor_pool = descriptor_pool;
940
+ self->oneofdef = (const upb_OneofDef*)NUM2ULL(ptr);
941
+
942
+ return Qnil;
943
+ }
944
+
945
+ /*
946
+ * call-seq:
947
+ * OneofDescriptor.name => name
948
+ *
949
+ * Returns the name of this oneof.
950
+ */
951
+ static VALUE OneofDescriptor_name(VALUE _self) {
952
+ OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
953
+ return rb_str_maybe_null(upb_OneofDef_Name(self->oneofdef));
954
+ }
955
+
956
+ /*
957
+ * call-seq:
958
+ * OneofDescriptor.each(&block) => nil
959
+ *
960
+ * Iterates through fields in this oneof, yielding to the block on each one.
961
+ */
962
+ static VALUE OneofDescriptor_each(VALUE _self) {
963
+ OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
964
+
965
+ int n = upb_OneofDef_FieldCount(self->oneofdef);
966
+ for (int i = 0; i < n; i++) {
967
+ const upb_FieldDef* f = upb_OneofDef_Field(self->oneofdef, i);
968
+ VALUE obj = get_fielddef_obj(self->descriptor_pool, f);
969
+ rb_yield(obj);
970
+ }
971
+ return Qnil;
972
+ }
973
+
974
+ static void OneofDescriptor_register(VALUE module) {
975
+ VALUE klass = rb_define_class_under(module, "OneofDescriptor", rb_cObject);
976
+ rb_define_alloc_func(klass, OneofDescriptor_alloc);
977
+ rb_define_method(klass, "initialize", OneofDescriptor_initialize, 3);
978
+ rb_define_method(klass, "name", OneofDescriptor_name, 0);
979
+ rb_define_method(klass, "each", OneofDescriptor_each, 0);
980
+ rb_include_module(klass, rb_mEnumerable);
981
+ rb_gc_register_address(&cOneofDescriptor);
982
+ cOneofDescriptor = klass;
983
+ }
984
+
985
+ // -----------------------------------------------------------------------------
986
+ // EnumDescriptor.
987
+ // -----------------------------------------------------------------------------
988
+
989
+ typedef struct {
990
+ const upb_EnumDef* enumdef;
991
+ VALUE module; // begins as nil
992
+ VALUE descriptor_pool; // Owns the upb_EnumDef.
993
+ } EnumDescriptor;
994
+
995
+ static VALUE cEnumDescriptor = Qnil;
996
+
997
+ static void EnumDescriptor_mark(void* _self) {
998
+ EnumDescriptor* self = _self;
999
+ rb_gc_mark(self->module);
1000
+ rb_gc_mark(self->descriptor_pool);
1001
+ }
1002
+
1003
+ static const rb_data_type_t EnumDescriptor_type = {
1004
+ "Google::Protobuf::EnumDescriptor",
1005
+ {EnumDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
1006
+ .flags = RUBY_TYPED_FREE_IMMEDIATELY,
1007
+ };
1008
+
1009
+ static EnumDescriptor* ruby_to_EnumDescriptor(VALUE val) {
1010
+ EnumDescriptor* ret;
1011
+ TypedData_Get_Struct(val, EnumDescriptor, &EnumDescriptor_type, ret);
1012
+ return ret;
1013
+ }
1014
+
1015
+ static VALUE EnumDescriptor_alloc(VALUE klass) {
1016
+ EnumDescriptor* self = ALLOC(EnumDescriptor);
1017
+ VALUE ret = TypedData_Wrap_Struct(klass, &EnumDescriptor_type, self);
1018
+ self->enumdef = NULL;
1019
+ self->module = Qnil;
1020
+ self->descriptor_pool = Qnil;
1021
+ return ret;
1022
+ }
1023
+
1024
+ // Exposed to other modules in defs.h.
1025
+ const upb_EnumDef* EnumDescriptor_GetEnumDef(VALUE enum_desc_rb) {
1026
+ EnumDescriptor* desc = ruby_to_EnumDescriptor(enum_desc_rb);
1027
+ return desc->enumdef;
1028
+ }
1029
+
1030
+ /*
1031
+ * call-seq:
1032
+ * EnumDescriptor.new(c_only_cookie, ptr) => EnumDescriptor
1033
+ *
1034
+ * Creates a descriptor wrapper object. May only be called from C.
1035
+ */
1036
+ static VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
1037
+ VALUE descriptor_pool, VALUE ptr) {
1038
+ EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
1039
+
1040
+ if (cookie != c_only_cookie) {
1041
+ rb_raise(rb_eRuntimeError,
1042
+ "Descriptor objects may not be created from Ruby.");
1043
+ }
1044
+
1045
+ self->descriptor_pool = descriptor_pool;
1046
+ self->enumdef = (const upb_EnumDef*)NUM2ULL(ptr);
1047
+
1048
+ return Qnil;
1049
+ }
1050
+
1051
+ /*
1052
+ * call-seq:
1053
+ * EnumDescriptor.file_descriptor
1054
+ *
1055
+ * Returns the FileDescriptor object this enum belongs to.
1056
+ */
1057
+ static VALUE EnumDescriptor_file_descriptor(VALUE _self) {
1058
+ EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
1059
+ return get_filedef_obj(self->descriptor_pool,
1060
+ upb_EnumDef_File(self->enumdef));
1061
+ }
1062
+
1063
+ /*
1064
+ * call-seq:
1065
+ * EnumDescriptor.name => name
1066
+ *
1067
+ * Returns the name of this enum type.
1068
+ */
1069
+ static VALUE EnumDescriptor_name(VALUE _self) {
1070
+ EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
1071
+ return rb_str_maybe_null(upb_EnumDef_FullName(self->enumdef));
1072
+ }
1073
+
1074
+ /*
1075
+ * call-seq:
1076
+ * EnumDescriptor.lookup_name(name) => value
1077
+ *
1078
+ * Returns the numeric value corresponding to the given key name (as a Ruby
1079
+ * symbol), or nil if none.
1080
+ */
1081
+ static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
1082
+ EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
1083
+ const char* name_str = rb_id2name(SYM2ID(name));
1084
+ const upb_EnumValueDef *ev =
1085
+ upb_EnumDef_FindValueByName(self->enumdef, name_str);
1086
+ if (ev) {
1087
+ return INT2NUM(upb_EnumValueDef_Number(ev));
1088
+ } else {
1089
+ return Qnil;
1090
+ }
1091
+ }
1092
+
1093
+ /*
1094
+ * call-seq:
1095
+ * EnumDescriptor.lookup_value(name) => value
1096
+ *
1097
+ * Returns the key name (as a Ruby symbol) corresponding to the integer value,
1098
+ * or nil if none.
1099
+ */
1100
+ static VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
1101
+ EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
1102
+ int32_t val = NUM2INT(number);
1103
+ const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNumber(self->enumdef, val);
1104
+ if (ev) {
1105
+ return ID2SYM(rb_intern(upb_EnumValueDef_Name(ev)));
1106
+ } else {
1107
+ return Qnil;
1108
+ }
1109
+ }
1110
+
1111
+ /*
1112
+ * call-seq:
1113
+ * EnumDescriptor.each(&block)
1114
+ *
1115
+ * Iterates over key => value mappings in this enum's definition, yielding to
1116
+ * the block with (key, value) arguments for each one.
1117
+ */
1118
+ static VALUE EnumDescriptor_each(VALUE _self) {
1119
+ EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
1120
+
1121
+ int n = upb_EnumDef_ValueCount(self->enumdef);
1122
+ for (int i = 0; i < n; i++) {
1123
+ const upb_EnumValueDef* ev = upb_EnumDef_Value(self->enumdef, i);
1124
+ VALUE key = ID2SYM(rb_intern(upb_EnumValueDef_Name(ev)));
1125
+ VALUE number = INT2NUM(upb_EnumValueDef_Number(ev));
1126
+ rb_yield_values(2, key, number);
1127
+ }
1128
+
1129
+ return Qnil;
1130
+ }
1131
+
1132
+ /*
1133
+ * call-seq:
1134
+ * EnumDescriptor.enummodule => module
1135
+ *
1136
+ * Returns the Ruby module corresponding to this enum type.
1137
+ */
1138
+ static VALUE EnumDescriptor_enummodule(VALUE _self) {
1139
+ EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
1140
+ if (self->module == Qnil) {
1141
+ self->module = build_module_from_enumdesc(_self);
1142
+ }
1143
+ return self->module;
1144
+ }
1145
+
1146
+ static void EnumDescriptor_register(VALUE module) {
1147
+ VALUE klass = rb_define_class_under(module, "EnumDescriptor", rb_cObject);
1148
+ rb_define_alloc_func(klass, EnumDescriptor_alloc);
1149
+ rb_define_method(klass, "initialize", EnumDescriptor_initialize, 3);
1150
+ rb_define_method(klass, "name", EnumDescriptor_name, 0);
1151
+ rb_define_method(klass, "lookup_name", EnumDescriptor_lookup_name, 1);
1152
+ rb_define_method(klass, "lookup_value", EnumDescriptor_lookup_value, 1);
1153
+ rb_define_method(klass, "each", EnumDescriptor_each, 0);
1154
+ rb_define_method(klass, "enummodule", EnumDescriptor_enummodule, 0);
1155
+ rb_define_method(klass, "file_descriptor", EnumDescriptor_file_descriptor, 0);
1156
+ rb_include_module(klass, rb_mEnumerable);
1157
+ rb_gc_register_address(&cEnumDescriptor);
1158
+ cEnumDescriptor = klass;
1159
+ }
1160
+
1161
+ static VALUE get_def_obj(VALUE _descriptor_pool, const void* ptr, VALUE klass) {
1162
+ DescriptorPool* descriptor_pool = ruby_to_DescriptorPool(_descriptor_pool);
1163
+ VALUE key = ULL2NUM((intptr_t)ptr);
1164
+ VALUE def;
1165
+
1166
+ def = rb_hash_aref(descriptor_pool->def_to_descriptor, key);
1167
+
1168
+ if (ptr == NULL) {
1169
+ return Qnil;
1170
+ }
1171
+
1172
+ if (def == Qnil) {
1173
+ // Lazily create wrapper object.
1174
+ VALUE args[3] = {c_only_cookie, _descriptor_pool, key};
1175
+ def = rb_class_new_instance(3, args, klass);
1176
+ rb_hash_aset(descriptor_pool->def_to_descriptor, key, def);
1177
+ }
1178
+
1179
+ return def;
1180
+ }
1181
+
1182
+ static VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_MessageDef* def) {
1183
+ return get_def_obj(descriptor_pool, def, cDescriptor);
1184
+ }
1185
+
1186
+ static VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_EnumDef* def) {
1187
+ return get_def_obj(descriptor_pool, def, cEnumDescriptor);
1188
+ }
1189
+
1190
+ static VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_FieldDef* def) {
1191
+ return get_def_obj(descriptor_pool, def, cFieldDescriptor);
1192
+ }
1193
+
1194
+ static VALUE get_filedef_obj(VALUE descriptor_pool, const upb_FileDef* def) {
1195
+ return get_def_obj(descriptor_pool, def, cFileDescriptor);
1196
+ }
1197
+
1198
+ static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_OneofDef* def) {
1199
+ return get_def_obj(descriptor_pool, def, cOneofDescriptor);
1200
+ }
1201
+
1202
+ // -----------------------------------------------------------------------------
1203
+ // Shared functions
1204
+ // -----------------------------------------------------------------------------
1205
+
1206
+ // Functions exposed to other modules in defs.h.
1207
+
1208
+ VALUE Descriptor_DefToClass(const upb_MessageDef* m) {
1209
+ const upb_DefPool* symtab = upb_FileDef_Pool(upb_MessageDef_File(m));
1210
+ VALUE pool = ObjectCache_Get(symtab);
1211
+ PBRUBY_ASSERT(pool != Qnil);
1212
+ VALUE desc_rb = get_msgdef_obj(pool, m);
1213
+ const Descriptor* desc = ruby_to_Descriptor(desc_rb);
1214
+ return desc->klass;
1215
+ }
1216
+
1217
+ const upb_MessageDef* Descriptor_GetMsgDef(VALUE desc_rb) {
1218
+ const Descriptor* desc = ruby_to_Descriptor(desc_rb);
1219
+ return desc->msgdef;
1220
+ }
1221
+
1222
+ VALUE TypeInfo_InitArg(int argc, VALUE* argv, int skip_arg) {
1223
+ if (argc > skip_arg) {
1224
+ if (argc > 1 + skip_arg) {
1225
+ rb_raise(rb_eArgError, "Expected a maximum of %d arguments.",
1226
+ skip_arg + 1);
1227
+ }
1228
+ return argv[skip_arg];
1229
+ } else {
1230
+ return Qnil;
1231
+ }
1232
+ }
1233
+
1234
+ TypeInfo TypeInfo_FromClass(int argc, VALUE* argv, int skip_arg,
1235
+ VALUE* type_class, VALUE* init_arg) {
1236
+ TypeInfo ret = {ruby_to_fieldtype(argv[skip_arg])};
1237
+
1238
+ if (ret.type == kUpb_CType_Message || ret.type == kUpb_CType_Enum) {
1239
+ *init_arg = TypeInfo_InitArg(argc, argv, skip_arg + 2);
1240
+
1241
+ if (argc < 2 + skip_arg) {
1242
+ rb_raise(rb_eArgError, "Expected at least %d arguments for message/enum.",
1243
+ 2 + skip_arg);
1244
+ }
1245
+
1246
+ VALUE klass = argv[1 + skip_arg];
1247
+ VALUE desc = MessageOrEnum_GetDescriptor(klass);
1248
+ *type_class = klass;
1249
+
1250
+ if (desc == Qnil) {
1251
+ rb_raise(rb_eArgError,
1252
+ "Type class has no descriptor. Please pass a "
1253
+ "class or enum as returned by the DescriptorPool.");
1254
+ }
1255
+
1256
+ if (ret.type == kUpb_CType_Message) {
1257
+ ret.def.msgdef = ruby_to_Descriptor(desc)->msgdef;
1258
+ Message_CheckClass(klass);
1259
+ } else {
1260
+ PBRUBY_ASSERT(ret.type == kUpb_CType_Enum);
1261
+ ret.def.enumdef = ruby_to_EnumDescriptor(desc)->enumdef;
1262
+ }
1263
+ } else {
1264
+ *init_arg = TypeInfo_InitArg(argc, argv, skip_arg + 1);
1265
+ }
1266
+
1267
+ return ret;
1268
+ }
1269
+
1270
+ void Defs_register(VALUE module) {
1271
+ DescriptorPool_register(module);
1272
+ Descriptor_register(module);
1273
+ FileDescriptor_register(module);
1274
+ FieldDescriptor_register(module);
1275
+ OneofDescriptor_register(module);
1276
+ EnumDescriptor_register(module);
1277
+
1278
+ rb_gc_register_address(&c_only_cookie);
1279
+ c_only_cookie = rb_class_new_instance(0, NULL, rb_cObject);
1280
+ }