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.
- checksums.yaml +7 -0
- data/ext/google/protobuf_c/convert.c +361 -0
- data/ext/google/protobuf_c/convert.h +75 -0
- data/ext/google/protobuf_c/defs.c +1280 -0
- data/ext/google/protobuf_c/defs.h +107 -0
- data/ext/google/protobuf_c/extconf.rb +27 -0
- data/ext/google/protobuf_c/map.c +687 -0
- data/ext/google/protobuf_c/map.h +66 -0
- data/ext/google/protobuf_c/message.c +1426 -0
- data/ext/google/protobuf_c/message.h +104 -0
- data/ext/google/protobuf_c/protobuf.c +480 -0
- data/ext/google/protobuf_c/protobuf.h +120 -0
- data/ext/google/protobuf_c/repeated_field.c +657 -0
- data/ext/google/protobuf_c/repeated_field.h +63 -0
- data/ext/google/protobuf_c/ruby-upb.c +13926 -0
- data/ext/google/protobuf_c/ruby-upb.h +10673 -0
- data/ext/google/protobuf_c/third_party/utf8_range/LICENSE +22 -0
- data/ext/google/protobuf_c/third_party/utf8_range/naive.c +92 -0
- data/ext/google/protobuf_c/third_party/utf8_range/range2-neon.c +157 -0
- data/ext/google/protobuf_c/third_party/utf8_range/range2-sse.c +170 -0
- data/ext/google/protobuf_c/third_party/utf8_range/utf8_range.h +21 -0
- data/ext/google/protobuf_c/wrap_memcpy.c +52 -0
- data/lib/google/2.6/protobuf_c.bundle +0 -0
- data/lib/google/2.7/protobuf_c.bundle +0 -0
- data/lib/google/3.0/protobuf_c.bundle +0 -0
- data/lib/google/3.1/protobuf_c.bundle +0 -0
- data/lib/google/3.2/protobuf_c.bundle +0 -0
- data/lib/google/protobuf/any_pb.rb +19 -0
- data/lib/google/protobuf/api_pb.rb +42 -0
- data/lib/google/protobuf/descriptor_dsl.rb +465 -0
- data/lib/google/protobuf/descriptor_pb.rb +298 -0
- data/lib/google/protobuf/duration_pb.rb +19 -0
- data/lib/google/protobuf/empty_pb.rb +17 -0
- data/lib/google/protobuf/field_mask_pb.rb +18 -0
- data/lib/google/protobuf/message_exts.rb +58 -0
- data/lib/google/protobuf/plugin_pb.rb +50 -0
- data/lib/google/protobuf/repeated_field.rb +201 -0
- data/lib/google/protobuf/source_context_pb.rb +18 -0
- data/lib/google/protobuf/struct_pb.rb +37 -0
- data/lib/google/protobuf/timestamp_pb.rb +19 -0
- data/lib/google/protobuf/type_pb.rb +92 -0
- data/lib/google/protobuf/well_known_types.rb +240 -0
- data/lib/google/protobuf/wrappers_pb.rb +50 -0
- data/lib/google/protobuf.rb +79 -0
- metadata +137 -0
@@ -0,0 +1,1426 @@
|
|
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 "message.h"
|
32
|
+
|
33
|
+
#include "convert.h"
|
34
|
+
#include "defs.h"
|
35
|
+
#include "map.h"
|
36
|
+
#include "protobuf.h"
|
37
|
+
#include "repeated_field.h"
|
38
|
+
|
39
|
+
static VALUE cParseError = Qnil;
|
40
|
+
static VALUE cAbstractMessage = Qnil;
|
41
|
+
static ID descriptor_instancevar_interned;
|
42
|
+
|
43
|
+
static VALUE initialize_rb_class_with_no_args(VALUE klass) {
|
44
|
+
return rb_funcall(klass, rb_intern("new"), 0);
|
45
|
+
}
|
46
|
+
|
47
|
+
VALUE MessageOrEnum_GetDescriptor(VALUE klass) {
|
48
|
+
return rb_ivar_get(klass, descriptor_instancevar_interned);
|
49
|
+
}
|
50
|
+
|
51
|
+
// -----------------------------------------------------------------------------
|
52
|
+
// Class/module creation from msgdefs and enumdefs, respectively.
|
53
|
+
// -----------------------------------------------------------------------------
|
54
|
+
|
55
|
+
typedef struct {
|
56
|
+
VALUE arena;
|
57
|
+
const upb_Message* msg; // Can get as mutable when non-frozen.
|
58
|
+
const upb_MessageDef*
|
59
|
+
msgdef; // kept alive by self.class.descriptor reference.
|
60
|
+
} Message;
|
61
|
+
|
62
|
+
static void Message_mark(void* _self) {
|
63
|
+
Message* self = (Message*)_self;
|
64
|
+
rb_gc_mark(self->arena);
|
65
|
+
}
|
66
|
+
|
67
|
+
static rb_data_type_t Message_type = {
|
68
|
+
"Message",
|
69
|
+
{Message_mark, RUBY_DEFAULT_FREE, NULL},
|
70
|
+
.flags = RUBY_TYPED_FREE_IMMEDIATELY,
|
71
|
+
};
|
72
|
+
|
73
|
+
static Message* ruby_to_Message(VALUE msg_rb) {
|
74
|
+
Message* msg;
|
75
|
+
TypedData_Get_Struct(msg_rb, Message, &Message_type, msg);
|
76
|
+
return msg;
|
77
|
+
}
|
78
|
+
|
79
|
+
static VALUE Message_alloc(VALUE klass) {
|
80
|
+
VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
|
81
|
+
Message* msg = ALLOC(Message);
|
82
|
+
VALUE ret;
|
83
|
+
|
84
|
+
msg->msgdef = Descriptor_GetMsgDef(descriptor);
|
85
|
+
msg->arena = Qnil;
|
86
|
+
msg->msg = NULL;
|
87
|
+
|
88
|
+
ret = TypedData_Wrap_Struct(klass, &Message_type, msg);
|
89
|
+
rb_ivar_set(ret, descriptor_instancevar_interned, descriptor);
|
90
|
+
|
91
|
+
return ret;
|
92
|
+
}
|
93
|
+
|
94
|
+
const upb_Message* Message_Get(VALUE msg_rb, const upb_MessageDef** m) {
|
95
|
+
Message* msg = ruby_to_Message(msg_rb);
|
96
|
+
if (m) *m = msg->msgdef;
|
97
|
+
return msg->msg;
|
98
|
+
}
|
99
|
+
|
100
|
+
upb_Message* Message_GetMutable(VALUE msg_rb, const upb_MessageDef** m) {
|
101
|
+
rb_check_frozen(msg_rb);
|
102
|
+
return (upb_Message*)Message_Get(msg_rb, m);
|
103
|
+
}
|
104
|
+
|
105
|
+
void Message_InitPtr(VALUE self_, upb_Message* msg, VALUE arena) {
|
106
|
+
Message* self = ruby_to_Message(self_);
|
107
|
+
self->msg = msg;
|
108
|
+
self->arena = arena;
|
109
|
+
ObjectCache_Add(msg, self_);
|
110
|
+
}
|
111
|
+
|
112
|
+
VALUE Message_GetArena(VALUE msg_rb) {
|
113
|
+
Message* msg = ruby_to_Message(msg_rb);
|
114
|
+
return msg->arena;
|
115
|
+
}
|
116
|
+
|
117
|
+
void Message_CheckClass(VALUE klass) {
|
118
|
+
if (rb_get_alloc_func(klass) != &Message_alloc) {
|
119
|
+
rb_raise(rb_eArgError,
|
120
|
+
"Message class was not returned by the DescriptorPool.");
|
121
|
+
}
|
122
|
+
}
|
123
|
+
|
124
|
+
VALUE Message_GetRubyWrapper(upb_Message* msg, const upb_MessageDef* m,
|
125
|
+
VALUE arena) {
|
126
|
+
if (msg == NULL) return Qnil;
|
127
|
+
|
128
|
+
VALUE val = ObjectCache_Get(msg);
|
129
|
+
|
130
|
+
if (val == Qnil) {
|
131
|
+
VALUE klass = Descriptor_DefToClass(m);
|
132
|
+
val = Message_alloc(klass);
|
133
|
+
Message_InitPtr(val, msg, arena);
|
134
|
+
}
|
135
|
+
|
136
|
+
return val;
|
137
|
+
}
|
138
|
+
|
139
|
+
void Message_PrintMessage(StringBuilder* b, const upb_Message* msg,
|
140
|
+
const upb_MessageDef* m) {
|
141
|
+
bool first = true;
|
142
|
+
int n = upb_MessageDef_FieldCount(m);
|
143
|
+
VALUE klass = Descriptor_DefToClass(m);
|
144
|
+
StringBuilder_Printf(b, "<%s: ", rb_class2name(klass));
|
145
|
+
|
146
|
+
for (int i = 0; i < n; i++) {
|
147
|
+
const upb_FieldDef* field = upb_MessageDef_Field(m, i);
|
148
|
+
|
149
|
+
if (upb_FieldDef_HasPresence(field) &&
|
150
|
+
!upb_Message_HasFieldByDef(msg, field)) {
|
151
|
+
continue;
|
152
|
+
}
|
153
|
+
|
154
|
+
if (!first) {
|
155
|
+
StringBuilder_Printf(b, ", ");
|
156
|
+
} else {
|
157
|
+
first = false;
|
158
|
+
}
|
159
|
+
|
160
|
+
upb_MessageValue msgval = upb_Message_GetFieldByDef(msg, field);
|
161
|
+
|
162
|
+
StringBuilder_Printf(b, "%s: ", upb_FieldDef_Name(field));
|
163
|
+
|
164
|
+
if (upb_FieldDef_IsMap(field)) {
|
165
|
+
const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(field);
|
166
|
+
const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry_m, 1);
|
167
|
+
const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
|
168
|
+
TypeInfo val_info = TypeInfo_get(val_f);
|
169
|
+
Map_Inspect(b, msgval.map_val, upb_FieldDef_CType(key_f), val_info);
|
170
|
+
} else if (upb_FieldDef_IsRepeated(field)) {
|
171
|
+
RepeatedField_Inspect(b, msgval.array_val, TypeInfo_get(field));
|
172
|
+
} else {
|
173
|
+
StringBuilder_PrintMsgval(b, msgval, TypeInfo_get(field));
|
174
|
+
}
|
175
|
+
}
|
176
|
+
|
177
|
+
StringBuilder_Printf(b, ">");
|
178
|
+
}
|
179
|
+
|
180
|
+
// Helper functions for #method_missing ////////////////////////////////////////
|
181
|
+
|
182
|
+
enum {
|
183
|
+
METHOD_UNKNOWN = 0,
|
184
|
+
METHOD_GETTER = 1,
|
185
|
+
METHOD_SETTER = 2,
|
186
|
+
METHOD_CLEAR = 3,
|
187
|
+
METHOD_PRESENCE = 4,
|
188
|
+
METHOD_ENUM_GETTER = 5,
|
189
|
+
METHOD_WRAPPER_GETTER = 6,
|
190
|
+
METHOD_WRAPPER_SETTER = 7
|
191
|
+
};
|
192
|
+
|
193
|
+
// Check if the field is a well known wrapper type
|
194
|
+
static bool IsWrapper(const upb_MessageDef* m) {
|
195
|
+
if (!m) return false;
|
196
|
+
switch (upb_MessageDef_WellKnownType(m)) {
|
197
|
+
case kUpb_WellKnown_DoubleValue:
|
198
|
+
case kUpb_WellKnown_FloatValue:
|
199
|
+
case kUpb_WellKnown_Int64Value:
|
200
|
+
case kUpb_WellKnown_UInt64Value:
|
201
|
+
case kUpb_WellKnown_Int32Value:
|
202
|
+
case kUpb_WellKnown_UInt32Value:
|
203
|
+
case kUpb_WellKnown_StringValue:
|
204
|
+
case kUpb_WellKnown_BytesValue:
|
205
|
+
case kUpb_WellKnown_BoolValue:
|
206
|
+
return true;
|
207
|
+
default:
|
208
|
+
return false;
|
209
|
+
}
|
210
|
+
}
|
211
|
+
|
212
|
+
static bool IsFieldWrapper(const upb_FieldDef* f) {
|
213
|
+
return IsWrapper(upb_FieldDef_MessageSubDef(f));
|
214
|
+
}
|
215
|
+
|
216
|
+
static bool Match(const upb_MessageDef* m, const char* name,
|
217
|
+
const upb_FieldDef** f, const upb_OneofDef** o,
|
218
|
+
const char* prefix, const char* suffix) {
|
219
|
+
size_t sp = strlen(prefix);
|
220
|
+
size_t ss = strlen(suffix);
|
221
|
+
size_t sn = strlen(name);
|
222
|
+
|
223
|
+
if (sn <= sp + ss) return false;
|
224
|
+
|
225
|
+
if (memcmp(name, prefix, sp) != 0 ||
|
226
|
+
memcmp(name + sn - ss, suffix, ss) != 0) {
|
227
|
+
return false;
|
228
|
+
}
|
229
|
+
|
230
|
+
return upb_MessageDef_FindByNameWithSize(m, name + sp, sn - sp - ss, f, o);
|
231
|
+
}
|
232
|
+
|
233
|
+
static int extract_method_call(VALUE method_name, Message* self,
|
234
|
+
const upb_FieldDef** f, const upb_OneofDef** o) {
|
235
|
+
const upb_MessageDef* m = self->msgdef;
|
236
|
+
const char* name;
|
237
|
+
|
238
|
+
Check_Type(method_name, T_SYMBOL);
|
239
|
+
name = rb_id2name(SYM2ID(method_name));
|
240
|
+
|
241
|
+
if (Match(m, name, f, o, "", "")) return METHOD_GETTER;
|
242
|
+
if (Match(m, name, f, o, "", "=")) return METHOD_SETTER;
|
243
|
+
if (Match(m, name, f, o, "clear_", "")) return METHOD_CLEAR;
|
244
|
+
if (Match(m, name, f, o, "has_", "?") &&
|
245
|
+
(*o || (*f && upb_FieldDef_HasPresence(*f)))) {
|
246
|
+
return METHOD_PRESENCE;
|
247
|
+
}
|
248
|
+
if (Match(m, name, f, o, "", "_as_value") && *f &&
|
249
|
+
!upb_FieldDef_IsRepeated(*f) && IsFieldWrapper(*f)) {
|
250
|
+
return METHOD_WRAPPER_GETTER;
|
251
|
+
}
|
252
|
+
if (Match(m, name, f, o, "", "_as_value=") && *f &&
|
253
|
+
!upb_FieldDef_IsRepeated(*f) && IsFieldWrapper(*f)) {
|
254
|
+
return METHOD_WRAPPER_SETTER;
|
255
|
+
}
|
256
|
+
if (Match(m, name, f, o, "", "_const") && *f &&
|
257
|
+
upb_FieldDef_CType(*f) == kUpb_CType_Enum) {
|
258
|
+
return METHOD_ENUM_GETTER;
|
259
|
+
}
|
260
|
+
|
261
|
+
return METHOD_UNKNOWN;
|
262
|
+
}
|
263
|
+
|
264
|
+
static VALUE Message_oneof_accessor(VALUE _self, const upb_OneofDef* o,
|
265
|
+
int accessor_type) {
|
266
|
+
Message* self = ruby_to_Message(_self);
|
267
|
+
const upb_FieldDef* oneof_field = upb_Message_WhichOneof(self->msg, o);
|
268
|
+
|
269
|
+
switch (accessor_type) {
|
270
|
+
case METHOD_PRESENCE:
|
271
|
+
return oneof_field == NULL ? Qfalse : Qtrue;
|
272
|
+
case METHOD_CLEAR:
|
273
|
+
if (oneof_field != NULL) {
|
274
|
+
upb_Message_ClearFieldByDef(Message_GetMutable(_self, NULL),
|
275
|
+
oneof_field);
|
276
|
+
}
|
277
|
+
return Qnil;
|
278
|
+
case METHOD_GETTER:
|
279
|
+
return oneof_field == NULL
|
280
|
+
? Qnil
|
281
|
+
: ID2SYM(rb_intern(upb_FieldDef_Name(oneof_field)));
|
282
|
+
case METHOD_SETTER:
|
283
|
+
rb_raise(rb_eRuntimeError, "Oneof accessors are read-only.");
|
284
|
+
}
|
285
|
+
rb_raise(rb_eRuntimeError, "Invalid access of oneof field.");
|
286
|
+
}
|
287
|
+
|
288
|
+
static void Message_setfield(upb_Message* msg, const upb_FieldDef* f, VALUE val,
|
289
|
+
upb_Arena* arena) {
|
290
|
+
upb_MessageValue msgval;
|
291
|
+
if (upb_FieldDef_IsMap(f)) {
|
292
|
+
msgval.map_val = Map_GetUpbMap(val, f, arena);
|
293
|
+
} else if (upb_FieldDef_IsRepeated(f)) {
|
294
|
+
msgval.array_val = RepeatedField_GetUpbArray(val, f, arena);
|
295
|
+
} else {
|
296
|
+
if (val == Qnil &&
|
297
|
+
(upb_FieldDef_IsSubMessage(f) || upb_FieldDef_RealContainingOneof(f))) {
|
298
|
+
upb_Message_ClearFieldByDef(msg, f);
|
299
|
+
return;
|
300
|
+
}
|
301
|
+
msgval =
|
302
|
+
Convert_RubyToUpb(val, upb_FieldDef_Name(f), TypeInfo_get(f), arena);
|
303
|
+
}
|
304
|
+
upb_Message_SetFieldByDef(msg, f, msgval, arena);
|
305
|
+
}
|
306
|
+
|
307
|
+
VALUE Message_getfield(VALUE _self, const upb_FieldDef* f) {
|
308
|
+
Message* self = ruby_to_Message(_self);
|
309
|
+
// This is a special-case: upb_Message_Mutable() for map & array are logically
|
310
|
+
// const (they will not change what is serialized) but physically
|
311
|
+
// non-const, as they do allocate a repeated field or map. The logical
|
312
|
+
// constness means it's ok to do even if the message is frozen.
|
313
|
+
upb_Message* msg = (upb_Message*)self->msg;
|
314
|
+
upb_Arena* arena = Arena_get(self->arena);
|
315
|
+
if (upb_FieldDef_IsMap(f)) {
|
316
|
+
upb_Map* map = upb_Message_Mutable(msg, f, arena).map;
|
317
|
+
const upb_FieldDef* key_f = map_field_key(f);
|
318
|
+
const upb_FieldDef* val_f = map_field_value(f);
|
319
|
+
upb_CType key_type = upb_FieldDef_CType(key_f);
|
320
|
+
TypeInfo value_type_info = TypeInfo_get(val_f);
|
321
|
+
return Map_GetRubyWrapper(map, key_type, value_type_info, self->arena);
|
322
|
+
} else if (upb_FieldDef_IsRepeated(f)) {
|
323
|
+
upb_Array* arr = upb_Message_Mutable(msg, f, arena).array;
|
324
|
+
return RepeatedField_GetRubyWrapper(arr, TypeInfo_get(f), self->arena);
|
325
|
+
} else if (upb_FieldDef_IsSubMessage(f)) {
|
326
|
+
if (!upb_Message_HasFieldByDef(self->msg, f)) return Qnil;
|
327
|
+
upb_Message* submsg = upb_Message_Mutable(msg, f, arena).msg;
|
328
|
+
const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
|
329
|
+
return Message_GetRubyWrapper(submsg, m, self->arena);
|
330
|
+
} else {
|
331
|
+
upb_MessageValue msgval = upb_Message_GetFieldByDef(self->msg, f);
|
332
|
+
return Convert_UpbToRuby(msgval, TypeInfo_get(f), self->arena);
|
333
|
+
}
|
334
|
+
}
|
335
|
+
|
336
|
+
static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
|
337
|
+
int accessor_type, int argc, VALUE* argv) {
|
338
|
+
upb_Arena* arena = Arena_get(Message_GetArena(_self));
|
339
|
+
|
340
|
+
switch (accessor_type) {
|
341
|
+
case METHOD_SETTER:
|
342
|
+
Message_setfield(Message_GetMutable(_self, NULL), f, argv[1], arena);
|
343
|
+
return Qnil;
|
344
|
+
case METHOD_CLEAR:
|
345
|
+
upb_Message_ClearFieldByDef(Message_GetMutable(_self, NULL), f);
|
346
|
+
return Qnil;
|
347
|
+
case METHOD_PRESENCE:
|
348
|
+
if (!upb_FieldDef_HasPresence(f)) {
|
349
|
+
rb_raise(rb_eRuntimeError, "Field does not have presence.");
|
350
|
+
}
|
351
|
+
return upb_Message_HasFieldByDef(Message_Get(_self, NULL), f);
|
352
|
+
case METHOD_WRAPPER_GETTER: {
|
353
|
+
Message* self = ruby_to_Message(_self);
|
354
|
+
if (upb_Message_HasFieldByDef(self->msg, f)) {
|
355
|
+
PBRUBY_ASSERT(upb_FieldDef_IsSubMessage(f) &&
|
356
|
+
!upb_FieldDef_IsRepeated(f));
|
357
|
+
upb_MessageValue wrapper = upb_Message_GetFieldByDef(self->msg, f);
|
358
|
+
const upb_MessageDef* wrapper_m = upb_FieldDef_MessageSubDef(f);
|
359
|
+
const upb_FieldDef* value_f =
|
360
|
+
upb_MessageDef_FindFieldByNumber(wrapper_m, 1);
|
361
|
+
upb_MessageValue value =
|
362
|
+
upb_Message_GetFieldByDef(wrapper.msg_val, value_f);
|
363
|
+
return Convert_UpbToRuby(value, TypeInfo_get(value_f), self->arena);
|
364
|
+
} else {
|
365
|
+
return Qnil;
|
366
|
+
}
|
367
|
+
}
|
368
|
+
case METHOD_WRAPPER_SETTER: {
|
369
|
+
upb_Message* msg = Message_GetMutable(_self, NULL);
|
370
|
+
if (argv[1] == Qnil) {
|
371
|
+
upb_Message_ClearFieldByDef(msg, f);
|
372
|
+
} else {
|
373
|
+
const upb_FieldDef* val_f =
|
374
|
+
upb_MessageDef_FindFieldByNumber(upb_FieldDef_MessageSubDef(f), 1);
|
375
|
+
upb_MessageValue msgval = Convert_RubyToUpb(
|
376
|
+
argv[1], upb_FieldDef_Name(f), TypeInfo_get(val_f), arena);
|
377
|
+
upb_Message* wrapper = upb_Message_Mutable(msg, f, arena).msg;
|
378
|
+
upb_Message_SetFieldByDef(wrapper, val_f, msgval, arena);
|
379
|
+
}
|
380
|
+
return Qnil;
|
381
|
+
}
|
382
|
+
case METHOD_ENUM_GETTER: {
|
383
|
+
upb_MessageValue msgval =
|
384
|
+
upb_Message_GetFieldByDef(Message_Get(_self, NULL), f);
|
385
|
+
|
386
|
+
if (upb_FieldDef_Label(f) == kUpb_Label_Repeated) {
|
387
|
+
// Map repeated fields to a new type with ints
|
388
|
+
VALUE arr = rb_ary_new();
|
389
|
+
size_t i, n = upb_Array_Size(msgval.array_val);
|
390
|
+
for (i = 0; i < n; i++) {
|
391
|
+
upb_MessageValue elem = upb_Array_Get(msgval.array_val, i);
|
392
|
+
rb_ary_push(arr, INT2NUM(elem.int32_val));
|
393
|
+
}
|
394
|
+
return arr;
|
395
|
+
} else {
|
396
|
+
return INT2NUM(msgval.int32_val);
|
397
|
+
}
|
398
|
+
}
|
399
|
+
case METHOD_GETTER:
|
400
|
+
return Message_getfield(_self, f);
|
401
|
+
default:
|
402
|
+
rb_raise(rb_eRuntimeError, "Internal error, no such accessor: %d",
|
403
|
+
accessor_type);
|
404
|
+
}
|
405
|
+
}
|
406
|
+
|
407
|
+
/*
|
408
|
+
* call-seq:
|
409
|
+
* Message.method_missing(*args)
|
410
|
+
*
|
411
|
+
* Provides accessors and setters and methods to clear and check for presence of
|
412
|
+
* message fields according to their field names.
|
413
|
+
*
|
414
|
+
* For any field whose name does not conflict with a built-in method, an
|
415
|
+
* accessor is provided with the same name as the field, and a setter is
|
416
|
+
* provided with the name of the field plus the '=' suffix. Thus, given a
|
417
|
+
* message instance 'msg' with field 'foo', the following code is valid:
|
418
|
+
*
|
419
|
+
* msg.foo = 42
|
420
|
+
* puts msg.foo
|
421
|
+
*
|
422
|
+
* This method also provides read-only accessors for oneofs. If a oneof exists
|
423
|
+
* with name 'my_oneof', then msg.my_oneof will return a Ruby symbol equal to
|
424
|
+
* the name of the field in that oneof that is currently set, or nil if none.
|
425
|
+
*
|
426
|
+
* It also provides methods of the form 'clear_fieldname' to clear the value
|
427
|
+
* of the field 'fieldname'. For basic data types, this will set the default
|
428
|
+
* value of the field.
|
429
|
+
*
|
430
|
+
* Additionally, it provides methods of the form 'has_fieldname?', which returns
|
431
|
+
* true if the field 'fieldname' is set in the message object, else false. For
|
432
|
+
* 'proto3' syntax, calling this for a basic type field will result in an error.
|
433
|
+
*/
|
434
|
+
static VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self) {
|
435
|
+
Message* self = ruby_to_Message(_self);
|
436
|
+
const upb_OneofDef* o;
|
437
|
+
const upb_FieldDef* f;
|
438
|
+
int accessor_type;
|
439
|
+
|
440
|
+
if (argc < 1) {
|
441
|
+
rb_raise(rb_eArgError, "Expected method name as first argument.");
|
442
|
+
}
|
443
|
+
|
444
|
+
accessor_type = extract_method_call(argv[0], self, &f, &o);
|
445
|
+
|
446
|
+
if (accessor_type == METHOD_UNKNOWN) return rb_call_super(argc, argv);
|
447
|
+
|
448
|
+
// Validate argument count.
|
449
|
+
switch (accessor_type) {
|
450
|
+
case METHOD_SETTER:
|
451
|
+
case METHOD_WRAPPER_SETTER:
|
452
|
+
if (argc != 2) {
|
453
|
+
rb_raise(rb_eArgError, "Expected 2 arguments, received %d", argc);
|
454
|
+
}
|
455
|
+
rb_check_frozen(_self);
|
456
|
+
break;
|
457
|
+
default:
|
458
|
+
if (argc != 1) {
|
459
|
+
rb_raise(rb_eArgError, "Expected 1 argument, received %d", argc);
|
460
|
+
}
|
461
|
+
break;
|
462
|
+
}
|
463
|
+
|
464
|
+
// Dispatch accessor.
|
465
|
+
if (o != NULL) {
|
466
|
+
return Message_oneof_accessor(_self, o, accessor_type);
|
467
|
+
} else {
|
468
|
+
return Message_field_accessor(_self, f, accessor_type, argc, argv);
|
469
|
+
}
|
470
|
+
}
|
471
|
+
|
472
|
+
static VALUE Message_respond_to_missing(int argc, VALUE* argv, VALUE _self) {
|
473
|
+
Message* self = ruby_to_Message(_self);
|
474
|
+
const upb_OneofDef* o;
|
475
|
+
const upb_FieldDef* f;
|
476
|
+
int accessor_type;
|
477
|
+
|
478
|
+
if (argc < 1) {
|
479
|
+
rb_raise(rb_eArgError, "Expected method name as first argument.");
|
480
|
+
}
|
481
|
+
|
482
|
+
accessor_type = extract_method_call(argv[0], self, &f, &o);
|
483
|
+
|
484
|
+
if (accessor_type == METHOD_UNKNOWN) {
|
485
|
+
return rb_call_super(argc, argv);
|
486
|
+
} else if (o != NULL) {
|
487
|
+
return accessor_type == METHOD_SETTER ? Qfalse : Qtrue;
|
488
|
+
} else {
|
489
|
+
return Qtrue;
|
490
|
+
}
|
491
|
+
}
|
492
|
+
|
493
|
+
void Message_InitFromValue(upb_Message* msg, const upb_MessageDef* m, VALUE val,
|
494
|
+
upb_Arena* arena);
|
495
|
+
|
496
|
+
typedef struct {
|
497
|
+
upb_Map* map;
|
498
|
+
TypeInfo key_type;
|
499
|
+
TypeInfo val_type;
|
500
|
+
upb_Arena* arena;
|
501
|
+
} MapInit;
|
502
|
+
|
503
|
+
static int Map_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
|
504
|
+
MapInit* map_init = (MapInit*)_self;
|
505
|
+
upb_MessageValue k, v;
|
506
|
+
k = Convert_RubyToUpb(key, "", map_init->key_type, NULL);
|
507
|
+
|
508
|
+
if (map_init->val_type.type == kUpb_CType_Message && TYPE(val) == T_HASH) {
|
509
|
+
upb_MiniTable* t = upb_MessageDef_MiniTable(map_init->val_type.def.msgdef);
|
510
|
+
upb_Message* msg = upb_Message_New(t, map_init->arena);
|
511
|
+
Message_InitFromValue(msg, map_init->val_type.def.msgdef, val,
|
512
|
+
map_init->arena);
|
513
|
+
v.msg_val = msg;
|
514
|
+
} else {
|
515
|
+
v = Convert_RubyToUpb(val, "", map_init->val_type, map_init->arena);
|
516
|
+
}
|
517
|
+
upb_Map_Set(map_init->map, k, v, map_init->arena);
|
518
|
+
return ST_CONTINUE;
|
519
|
+
}
|
520
|
+
|
521
|
+
static void Map_InitFromValue(upb_Map* map, const upb_FieldDef* f, VALUE val,
|
522
|
+
upb_Arena* arena) {
|
523
|
+
const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(f);
|
524
|
+
const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry_m, 1);
|
525
|
+
const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
|
526
|
+
if (TYPE(val) != T_HASH) {
|
527
|
+
rb_raise(rb_eArgError,
|
528
|
+
"Expected Hash object as initializer value for map field '%s' "
|
529
|
+
"(given %s).",
|
530
|
+
upb_FieldDef_Name(f), rb_class2name(CLASS_OF(val)));
|
531
|
+
}
|
532
|
+
MapInit map_init = {map, TypeInfo_get(key_f), TypeInfo_get(val_f), arena};
|
533
|
+
rb_hash_foreach(val, Map_initialize_kwarg, (VALUE)&map_init);
|
534
|
+
}
|
535
|
+
|
536
|
+
static upb_MessageValue MessageValue_FromValue(VALUE val, TypeInfo info,
|
537
|
+
upb_Arena* arena) {
|
538
|
+
if (info.type == kUpb_CType_Message) {
|
539
|
+
upb_MessageValue msgval;
|
540
|
+
upb_MiniTable* t = upb_MessageDef_MiniTable(info.def.msgdef);
|
541
|
+
upb_Message* msg = upb_Message_New(t, arena);
|
542
|
+
Message_InitFromValue(msg, info.def.msgdef, val, arena);
|
543
|
+
msgval.msg_val = msg;
|
544
|
+
return msgval;
|
545
|
+
} else {
|
546
|
+
return Convert_RubyToUpb(val, "", info, arena);
|
547
|
+
}
|
548
|
+
}
|
549
|
+
|
550
|
+
static void RepeatedField_InitFromValue(upb_Array* arr, const upb_FieldDef* f,
|
551
|
+
VALUE val, upb_Arena* arena) {
|
552
|
+
TypeInfo type_info = TypeInfo_get(f);
|
553
|
+
|
554
|
+
if (TYPE(val) != T_ARRAY) {
|
555
|
+
rb_raise(rb_eArgError,
|
556
|
+
"Expected array as initializer value for repeated field '%s' "
|
557
|
+
"(given %s).",
|
558
|
+
upb_FieldDef_Name(f), rb_class2name(CLASS_OF(val)));
|
559
|
+
}
|
560
|
+
|
561
|
+
for (int i = 0; i < RARRAY_LEN(val); i++) {
|
562
|
+
VALUE entry = rb_ary_entry(val, i);
|
563
|
+
upb_MessageValue msgval;
|
564
|
+
if (upb_FieldDef_IsSubMessage(f) && TYPE(entry) == T_HASH) {
|
565
|
+
msgval = MessageValue_FromValue(entry, type_info, arena);
|
566
|
+
} else {
|
567
|
+
msgval = Convert_RubyToUpb(entry, upb_FieldDef_Name(f), type_info, arena);
|
568
|
+
}
|
569
|
+
upb_Array_Append(arr, msgval, arena);
|
570
|
+
}
|
571
|
+
}
|
572
|
+
|
573
|
+
static void Message_InitFieldFromValue(upb_Message* msg, const upb_FieldDef* f,
|
574
|
+
VALUE val, upb_Arena* arena) {
|
575
|
+
if (TYPE(val) == T_NIL) return;
|
576
|
+
|
577
|
+
if (upb_FieldDef_IsMap(f)) {
|
578
|
+
upb_Map* map = upb_Message_Mutable(msg, f, arena).map;
|
579
|
+
Map_InitFromValue(map, f, val, arena);
|
580
|
+
} else if (upb_FieldDef_Label(f) == kUpb_Label_Repeated) {
|
581
|
+
upb_Array* arr = upb_Message_Mutable(msg, f, arena).array;
|
582
|
+
RepeatedField_InitFromValue(arr, f, val, arena);
|
583
|
+
} else if (upb_FieldDef_IsSubMessage(f)) {
|
584
|
+
if (TYPE(val) == T_HASH) {
|
585
|
+
upb_Message* submsg = upb_Message_Mutable(msg, f, arena).msg;
|
586
|
+
Message_InitFromValue(submsg, upb_FieldDef_MessageSubDef(f), val, arena);
|
587
|
+
} else {
|
588
|
+
Message_setfield(msg, f, val, arena);
|
589
|
+
}
|
590
|
+
} else {
|
591
|
+
upb_MessageValue msgval =
|
592
|
+
Convert_RubyToUpb(val, upb_FieldDef_Name(f), TypeInfo_get(f), arena);
|
593
|
+
upb_Message_SetFieldByDef(msg, f, msgval, arena);
|
594
|
+
}
|
595
|
+
}
|
596
|
+
|
597
|
+
typedef struct {
|
598
|
+
upb_Message* msg;
|
599
|
+
const upb_MessageDef* msgdef;
|
600
|
+
upb_Arena* arena;
|
601
|
+
} MsgInit;
|
602
|
+
|
603
|
+
static int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
|
604
|
+
MsgInit* msg_init = (MsgInit*)_self;
|
605
|
+
const char* name;
|
606
|
+
|
607
|
+
if (TYPE(key) == T_STRING) {
|
608
|
+
name = RSTRING_PTR(key);
|
609
|
+
} else if (TYPE(key) == T_SYMBOL) {
|
610
|
+
name = RSTRING_PTR(rb_id2str(SYM2ID(key)));
|
611
|
+
} else {
|
612
|
+
rb_raise(rb_eArgError,
|
613
|
+
"Expected string or symbols as hash keys when initializing proto "
|
614
|
+
"from hash.");
|
615
|
+
}
|
616
|
+
|
617
|
+
const upb_FieldDef* f =
|
618
|
+
upb_MessageDef_FindFieldByName(msg_init->msgdef, name);
|
619
|
+
|
620
|
+
if (f == NULL) {
|
621
|
+
rb_raise(rb_eArgError,
|
622
|
+
"Unknown field name '%s' in initialization map entry.", name);
|
623
|
+
}
|
624
|
+
|
625
|
+
Message_InitFieldFromValue(msg_init->msg, f, val, msg_init->arena);
|
626
|
+
return ST_CONTINUE;
|
627
|
+
}
|
628
|
+
|
629
|
+
void Message_InitFromValue(upb_Message* msg, const upb_MessageDef* m, VALUE val,
|
630
|
+
upb_Arena* arena) {
|
631
|
+
MsgInit msg_init = {msg, m, arena};
|
632
|
+
if (TYPE(val) == T_HASH) {
|
633
|
+
rb_hash_foreach(val, Message_initialize_kwarg, (VALUE)&msg_init);
|
634
|
+
} else {
|
635
|
+
rb_raise(rb_eArgError, "Expected hash arguments or message, not %s",
|
636
|
+
rb_class2name(CLASS_OF(val)));
|
637
|
+
}
|
638
|
+
}
|
639
|
+
|
640
|
+
/*
|
641
|
+
* call-seq:
|
642
|
+
* Message.new(kwargs) => new_message
|
643
|
+
*
|
644
|
+
* Creates a new instance of the given message class. Keyword arguments may be
|
645
|
+
* provided with keywords corresponding to field names.
|
646
|
+
*
|
647
|
+
* Note that no literal Message class exists. Only concrete classes per message
|
648
|
+
* type exist, as provided by the #msgclass method on Descriptors after they
|
649
|
+
* have been added to a pool. The method definitions described here on the
|
650
|
+
* Message class are provided on each concrete message class.
|
651
|
+
*/
|
652
|
+
static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
|
653
|
+
Message* self = ruby_to_Message(_self);
|
654
|
+
VALUE arena_rb = Arena_new();
|
655
|
+
upb_Arena* arena = Arena_get(arena_rb);
|
656
|
+
upb_MiniTable* t = upb_MessageDef_MiniTable(self->msgdef);
|
657
|
+
upb_Message* msg = upb_Message_New(t, arena);
|
658
|
+
|
659
|
+
Message_InitPtr(_self, msg, arena_rb);
|
660
|
+
|
661
|
+
if (argc == 0) {
|
662
|
+
return Qnil;
|
663
|
+
}
|
664
|
+
if (argc != 1) {
|
665
|
+
rb_raise(rb_eArgError, "Expected 0 or 1 arguments.");
|
666
|
+
}
|
667
|
+
Message_InitFromValue((upb_Message*)self->msg, self->msgdef, argv[0], arena);
|
668
|
+
return Qnil;
|
669
|
+
}
|
670
|
+
|
671
|
+
/*
|
672
|
+
* call-seq:
|
673
|
+
* Message.dup => new_message
|
674
|
+
*
|
675
|
+
* Performs a shallow copy of this message and returns the new copy.
|
676
|
+
*/
|
677
|
+
static VALUE Message_dup(VALUE _self) {
|
678
|
+
Message* self = ruby_to_Message(_self);
|
679
|
+
VALUE new_msg = rb_class_new_instance(0, NULL, CLASS_OF(_self));
|
680
|
+
Message* new_msg_self = ruby_to_Message(new_msg);
|
681
|
+
size_t size = upb_MessageDef_MiniTable(self->msgdef)->size;
|
682
|
+
|
683
|
+
// TODO(copy unknown fields?)
|
684
|
+
// TODO(use official upb msg copy function)
|
685
|
+
memcpy((upb_Message*)new_msg_self->msg, self->msg, size);
|
686
|
+
Arena_fuse(self->arena, Arena_get(new_msg_self->arena));
|
687
|
+
return new_msg;
|
688
|
+
}
|
689
|
+
|
690
|
+
// Support function for Message_eq, and also used by other #eq functions.
|
691
|
+
bool Message_Equal(const upb_Message* m1, const upb_Message* m2,
|
692
|
+
const upb_MessageDef* m) {
|
693
|
+
if (m1 == m2) return true;
|
694
|
+
|
695
|
+
size_t size1, size2;
|
696
|
+
int encode_opts =
|
697
|
+
kUpb_EncodeOption_SkipUnknown | kUpb_EncodeOption_Deterministic;
|
698
|
+
upb_Arena* arena_tmp = upb_Arena_New();
|
699
|
+
const upb_MiniTable* layout = upb_MessageDef_MiniTable(m);
|
700
|
+
|
701
|
+
// Compare deterministically serialized payloads with no unknown fields.
|
702
|
+
char* data1;
|
703
|
+
char* data2;
|
704
|
+
upb_EncodeStatus status1 =
|
705
|
+
upb_Encode(m1, layout, encode_opts, arena_tmp, &data1, &size1);
|
706
|
+
upb_EncodeStatus status2 =
|
707
|
+
upb_Encode(m2, layout, encode_opts, arena_tmp, &data2, &size2);
|
708
|
+
|
709
|
+
if (status1 == kUpb_EncodeStatus_Ok && status2 == kUpb_EncodeStatus_Ok) {
|
710
|
+
bool ret = (size1 == size2) && (memcmp(data1, data2, size1) == 0);
|
711
|
+
upb_Arena_Free(arena_tmp);
|
712
|
+
return ret;
|
713
|
+
} else {
|
714
|
+
upb_Arena_Free(arena_tmp);
|
715
|
+
rb_raise(cParseError, "Error comparing messages");
|
716
|
+
}
|
717
|
+
}
|
718
|
+
|
719
|
+
/*
|
720
|
+
* call-seq:
|
721
|
+
* Message.==(other) => boolean
|
722
|
+
*
|
723
|
+
* Performs a deep comparison of this message with another. Messages are equal
|
724
|
+
* if they have the same type and if each field is equal according to the :==
|
725
|
+
* method's semantics (a more efficient comparison may actually be done if the
|
726
|
+
* field is of a primitive type).
|
727
|
+
*/
|
728
|
+
static VALUE Message_eq(VALUE _self, VALUE _other) {
|
729
|
+
if (CLASS_OF(_self) != CLASS_OF(_other)) return Qfalse;
|
730
|
+
|
731
|
+
Message* self = ruby_to_Message(_self);
|
732
|
+
Message* other = ruby_to_Message(_other);
|
733
|
+
assert(self->msgdef == other->msgdef);
|
734
|
+
|
735
|
+
return Message_Equal(self->msg, other->msg, self->msgdef) ? Qtrue : Qfalse;
|
736
|
+
}
|
737
|
+
|
738
|
+
uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
|
739
|
+
uint64_t seed) {
|
740
|
+
upb_Arena* arena = upb_Arena_New();
|
741
|
+
char* data;
|
742
|
+
size_t size;
|
743
|
+
|
744
|
+
// Hash a deterministically serialized payloads with no unknown fields.
|
745
|
+
upb_EncodeStatus status = upb_Encode(
|
746
|
+
msg, upb_MessageDef_MiniTable(m),
|
747
|
+
kUpb_EncodeOption_SkipUnknown | kUpb_EncodeOption_Deterministic, arena,
|
748
|
+
&data, &size);
|
749
|
+
|
750
|
+
if (status == kUpb_EncodeStatus_Ok) {
|
751
|
+
uint64_t ret = _upb_Hash(data, size, seed);
|
752
|
+
upb_Arena_Free(arena);
|
753
|
+
return ret;
|
754
|
+
} else {
|
755
|
+
upb_Arena_Free(arena);
|
756
|
+
rb_raise(cParseError, "Error calculating hash");
|
757
|
+
}
|
758
|
+
}
|
759
|
+
|
760
|
+
/*
|
761
|
+
* call-seq:
|
762
|
+
* Message.hash => hash_value
|
763
|
+
*
|
764
|
+
* Returns a hash value that represents this message's field values.
|
765
|
+
*/
|
766
|
+
static VALUE Message_hash(VALUE _self) {
|
767
|
+
Message* self = ruby_to_Message(_self);
|
768
|
+
uint64_t hash_value = Message_Hash(self->msg, self->msgdef, 0);
|
769
|
+
// RUBY_FIXNUM_MAX should be one less than a power of 2.
|
770
|
+
assert((RUBY_FIXNUM_MAX & (RUBY_FIXNUM_MAX + 1)) == 0);
|
771
|
+
return INT2FIX(hash_value & RUBY_FIXNUM_MAX);
|
772
|
+
}
|
773
|
+
|
774
|
+
/*
|
775
|
+
* call-seq:
|
776
|
+
* Message.inspect => string
|
777
|
+
*
|
778
|
+
* Returns a human-readable string representing this message. It will be
|
779
|
+
* formatted as "<MessageType: field1: value1, field2: value2, ...>". Each
|
780
|
+
* field's value is represented according to its own #inspect method.
|
781
|
+
*/
|
782
|
+
static VALUE Message_inspect(VALUE _self) {
|
783
|
+
Message* self = ruby_to_Message(_self);
|
784
|
+
|
785
|
+
StringBuilder* builder = StringBuilder_New();
|
786
|
+
Message_PrintMessage(builder, self->msg, self->msgdef);
|
787
|
+
VALUE ret = StringBuilder_ToRubyString(builder);
|
788
|
+
StringBuilder_Free(builder);
|
789
|
+
return ret;
|
790
|
+
}
|
791
|
+
|
792
|
+
// Support functions for Message_to_h //////////////////////////////////////////
|
793
|
+
|
794
|
+
static VALUE RepeatedField_CreateArray(const upb_Array* arr,
|
795
|
+
TypeInfo type_info) {
|
796
|
+
int size = arr ? upb_Array_Size(arr) : 0;
|
797
|
+
VALUE ary = rb_ary_new2(size);
|
798
|
+
|
799
|
+
for (int i = 0; i < size; i++) {
|
800
|
+
upb_MessageValue msgval = upb_Array_Get(arr, i);
|
801
|
+
VALUE val = Scalar_CreateHash(msgval, type_info);
|
802
|
+
rb_ary_push(ary, val);
|
803
|
+
}
|
804
|
+
|
805
|
+
return ary;
|
806
|
+
}
|
807
|
+
|
808
|
+
static VALUE Message_CreateHash(const upb_Message* msg,
|
809
|
+
const upb_MessageDef* m) {
|
810
|
+
if (!msg) return Qnil;
|
811
|
+
|
812
|
+
VALUE hash = rb_hash_new();
|
813
|
+
int n = upb_MessageDef_FieldCount(m);
|
814
|
+
bool is_proto2;
|
815
|
+
|
816
|
+
// We currently have a few behaviors that are specific to proto2.
|
817
|
+
// This is unfortunate, we should key behaviors off field attributes (like
|
818
|
+
// whether a field has presence), not proto2 vs. proto3. We should see if we
|
819
|
+
// can change this without breaking users.
|
820
|
+
is_proto2 = upb_MessageDef_Syntax(m) == kUpb_Syntax_Proto2;
|
821
|
+
|
822
|
+
for (int i = 0; i < n; i++) {
|
823
|
+
const upb_FieldDef* field = upb_MessageDef_Field(m, i);
|
824
|
+
TypeInfo type_info = TypeInfo_get(field);
|
825
|
+
upb_MessageValue msgval;
|
826
|
+
VALUE msg_value;
|
827
|
+
VALUE msg_key;
|
828
|
+
|
829
|
+
if (!is_proto2 && upb_FieldDef_IsSubMessage(field) &&
|
830
|
+
!upb_FieldDef_IsRepeated(field) &&
|
831
|
+
!upb_Message_HasFieldByDef(msg, field)) {
|
832
|
+
// TODO: Legacy behavior, remove when we fix the is_proto2 differences.
|
833
|
+
msg_key = ID2SYM(rb_intern(upb_FieldDef_Name(field)));
|
834
|
+
rb_hash_aset(hash, msg_key, Qnil);
|
835
|
+
continue;
|
836
|
+
}
|
837
|
+
|
838
|
+
// Do not include fields that are not present (oneof or optional fields).
|
839
|
+
if (is_proto2 && upb_FieldDef_HasPresence(field) &&
|
840
|
+
!upb_Message_HasFieldByDef(msg, field)) {
|
841
|
+
continue;
|
842
|
+
}
|
843
|
+
|
844
|
+
msg_key = ID2SYM(rb_intern(upb_FieldDef_Name(field)));
|
845
|
+
msgval = upb_Message_GetFieldByDef(msg, field);
|
846
|
+
|
847
|
+
// Proto2 omits empty map/repeated filds also.
|
848
|
+
|
849
|
+
if (upb_FieldDef_IsMap(field)) {
|
850
|
+
const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(field);
|
851
|
+
const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry_m, 1);
|
852
|
+
const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
|
853
|
+
upb_CType key_type = upb_FieldDef_CType(key_f);
|
854
|
+
msg_value = Map_CreateHash(msgval.map_val, key_type, TypeInfo_get(val_f));
|
855
|
+
} else if (upb_FieldDef_IsRepeated(field)) {
|
856
|
+
if (is_proto2 &&
|
857
|
+
(!msgval.array_val || upb_Array_Size(msgval.array_val) == 0)) {
|
858
|
+
continue;
|
859
|
+
}
|
860
|
+
msg_value = RepeatedField_CreateArray(msgval.array_val, type_info);
|
861
|
+
} else {
|
862
|
+
msg_value = Scalar_CreateHash(msgval, type_info);
|
863
|
+
}
|
864
|
+
|
865
|
+
rb_hash_aset(hash, msg_key, msg_value);
|
866
|
+
}
|
867
|
+
|
868
|
+
return hash;
|
869
|
+
}
|
870
|
+
|
871
|
+
VALUE Scalar_CreateHash(upb_MessageValue msgval, TypeInfo type_info) {
|
872
|
+
if (type_info.type == kUpb_CType_Message) {
|
873
|
+
return Message_CreateHash(msgval.msg_val, type_info.def.msgdef);
|
874
|
+
} else {
|
875
|
+
return Convert_UpbToRuby(msgval, type_info, Qnil);
|
876
|
+
}
|
877
|
+
}
|
878
|
+
|
879
|
+
/*
|
880
|
+
* call-seq:
|
881
|
+
* Message.to_h => {}
|
882
|
+
*
|
883
|
+
* Returns the message as a Ruby Hash object, with keys as symbols.
|
884
|
+
*/
|
885
|
+
static VALUE Message_to_h(VALUE _self) {
|
886
|
+
Message* self = ruby_to_Message(_self);
|
887
|
+
return Message_CreateHash(self->msg, self->msgdef);
|
888
|
+
}
|
889
|
+
|
890
|
+
/*
|
891
|
+
* call-seq:
|
892
|
+
* Message.freeze => self
|
893
|
+
*
|
894
|
+
* Freezes the message object. We have to intercept this so we can pin the
|
895
|
+
* Ruby object into memory so we don't forget it's frozen.
|
896
|
+
*/
|
897
|
+
static VALUE Message_freeze(VALUE _self) {
|
898
|
+
Message* self = ruby_to_Message(_self);
|
899
|
+
if (!RB_OBJ_FROZEN(_self)) {
|
900
|
+
Arena_Pin(self->arena, _self);
|
901
|
+
RB_OBJ_FREEZE(_self);
|
902
|
+
}
|
903
|
+
return _self;
|
904
|
+
}
|
905
|
+
|
906
|
+
/*
|
907
|
+
* call-seq:
|
908
|
+
* Message.[](index) => value
|
909
|
+
*
|
910
|
+
* Accesses a field's value by field name. The provided field name should be a
|
911
|
+
* string.
|
912
|
+
*/
|
913
|
+
static VALUE Message_index(VALUE _self, VALUE field_name) {
|
914
|
+
Message* self = ruby_to_Message(_self);
|
915
|
+
const upb_FieldDef* field;
|
916
|
+
|
917
|
+
Check_Type(field_name, T_STRING);
|
918
|
+
field = upb_MessageDef_FindFieldByName(self->msgdef, RSTRING_PTR(field_name));
|
919
|
+
|
920
|
+
if (field == NULL) {
|
921
|
+
return Qnil;
|
922
|
+
}
|
923
|
+
|
924
|
+
return Message_getfield(_self, field);
|
925
|
+
}
|
926
|
+
|
927
|
+
/*
|
928
|
+
* call-seq:
|
929
|
+
* Message.[]=(index, value)
|
930
|
+
*
|
931
|
+
* Sets a field's value by field name. The provided field name should be a
|
932
|
+
* string.
|
933
|
+
*/
|
934
|
+
static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
|
935
|
+
Message* self = ruby_to_Message(_self);
|
936
|
+
const upb_FieldDef* f;
|
937
|
+
upb_MessageValue val;
|
938
|
+
upb_Arena* arena = Arena_get(self->arena);
|
939
|
+
|
940
|
+
Check_Type(field_name, T_STRING);
|
941
|
+
f = upb_MessageDef_FindFieldByName(self->msgdef, RSTRING_PTR(field_name));
|
942
|
+
|
943
|
+
if (f == NULL) {
|
944
|
+
rb_raise(rb_eArgError, "Unknown field: %s", RSTRING_PTR(field_name));
|
945
|
+
}
|
946
|
+
|
947
|
+
val = Convert_RubyToUpb(value, upb_FieldDef_Name(f), TypeInfo_get(f), arena);
|
948
|
+
upb_Message_SetFieldByDef(Message_GetMutable(_self, NULL), f, val, arena);
|
949
|
+
|
950
|
+
return Qnil;
|
951
|
+
}
|
952
|
+
|
953
|
+
/*
|
954
|
+
* call-seq:
|
955
|
+
* MessageClass.decode(data, options) => message
|
956
|
+
*
|
957
|
+
* Decodes the given data (as a string containing bytes in protocol buffers wire
|
958
|
+
* format) under the interpretration given by this message class's definition
|
959
|
+
* and returns a message object with the corresponding field values.
|
960
|
+
* @param options [Hash] options for the decoder
|
961
|
+
* recursion_limit: set to maximum decoding depth for message (default is 64)
|
962
|
+
*/
|
963
|
+
static VALUE Message_decode(int argc, VALUE* argv, VALUE klass) {
|
964
|
+
VALUE data = argv[0];
|
965
|
+
int options = 0;
|
966
|
+
|
967
|
+
if (argc < 1 || argc > 2) {
|
968
|
+
rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
|
969
|
+
}
|
970
|
+
|
971
|
+
if (argc == 2) {
|
972
|
+
VALUE hash_args = argv[1];
|
973
|
+
if (TYPE(hash_args) != T_HASH) {
|
974
|
+
rb_raise(rb_eArgError, "Expected hash arguments.");
|
975
|
+
}
|
976
|
+
|
977
|
+
VALUE depth =
|
978
|
+
rb_hash_lookup(hash_args, ID2SYM(rb_intern("recursion_limit")));
|
979
|
+
|
980
|
+
if (depth != Qnil && TYPE(depth) == T_FIXNUM) {
|
981
|
+
options |= UPB_DECODE_MAXDEPTH(FIX2INT(depth));
|
982
|
+
}
|
983
|
+
}
|
984
|
+
|
985
|
+
if (TYPE(data) != T_STRING) {
|
986
|
+
rb_raise(rb_eArgError, "Expected string for binary protobuf data.");
|
987
|
+
}
|
988
|
+
|
989
|
+
VALUE msg_rb = initialize_rb_class_with_no_args(klass);
|
990
|
+
Message* msg = ruby_to_Message(msg_rb);
|
991
|
+
|
992
|
+
upb_DecodeStatus status =
|
993
|
+
upb_Decode(RSTRING_PTR(data), RSTRING_LEN(data), (upb_Message*)msg->msg,
|
994
|
+
upb_MessageDef_MiniTable(msg->msgdef), NULL, options,
|
995
|
+
Arena_get(msg->arena));
|
996
|
+
|
997
|
+
if (status != kUpb_DecodeStatus_Ok) {
|
998
|
+
rb_raise(cParseError, "Error occurred during parsing");
|
999
|
+
}
|
1000
|
+
|
1001
|
+
return msg_rb;
|
1002
|
+
}
|
1003
|
+
|
1004
|
+
/*
|
1005
|
+
* call-seq:
|
1006
|
+
* MessageClass.decode_json(data, options = {}) => message
|
1007
|
+
*
|
1008
|
+
* Decodes the given data (as a string containing bytes in protocol buffers wire
|
1009
|
+
* format) under the interpretration given by this message class's definition
|
1010
|
+
* and returns a message object with the corresponding field values.
|
1011
|
+
*
|
1012
|
+
* @param options [Hash] options for the decoder
|
1013
|
+
* ignore_unknown_fields: set true to ignore unknown fields (default is to
|
1014
|
+
* raise an error)
|
1015
|
+
*/
|
1016
|
+
static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
|
1017
|
+
VALUE data = argv[0];
|
1018
|
+
int options = 0;
|
1019
|
+
upb_Status status;
|
1020
|
+
|
1021
|
+
// TODO(haberman): use this message's pool instead.
|
1022
|
+
const upb_DefPool* symtab = DescriptorPool_GetSymtab(generated_pool);
|
1023
|
+
|
1024
|
+
if (argc < 1 || argc > 2) {
|
1025
|
+
rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
|
1026
|
+
}
|
1027
|
+
|
1028
|
+
if (argc == 2) {
|
1029
|
+
VALUE hash_args = argv[1];
|
1030
|
+
if (TYPE(hash_args) != T_HASH) {
|
1031
|
+
rb_raise(rb_eArgError, "Expected hash arguments.");
|
1032
|
+
}
|
1033
|
+
|
1034
|
+
if (RTEST(rb_hash_lookup2(
|
1035
|
+
hash_args, ID2SYM(rb_intern("ignore_unknown_fields")), Qfalse))) {
|
1036
|
+
options |= upb_JsonDecode_IgnoreUnknown;
|
1037
|
+
}
|
1038
|
+
}
|
1039
|
+
|
1040
|
+
if (TYPE(data) != T_STRING) {
|
1041
|
+
rb_raise(rb_eArgError, "Expected string for JSON data.");
|
1042
|
+
}
|
1043
|
+
|
1044
|
+
// TODO(cfallin): Check and respect string encoding. If not UTF-8, we need to
|
1045
|
+
// convert, because string handlers pass data directly to message string
|
1046
|
+
// fields.
|
1047
|
+
|
1048
|
+
VALUE msg_rb = initialize_rb_class_with_no_args(klass);
|
1049
|
+
Message* msg = ruby_to_Message(msg_rb);
|
1050
|
+
|
1051
|
+
// We don't allow users to decode a wrapper type directly.
|
1052
|
+
if (IsWrapper(msg->msgdef)) {
|
1053
|
+
rb_raise(rb_eRuntimeError, "Cannot parse a wrapper directly.");
|
1054
|
+
}
|
1055
|
+
|
1056
|
+
upb_Status_Clear(&status);
|
1057
|
+
if (!upb_JsonDecode(RSTRING_PTR(data), RSTRING_LEN(data),
|
1058
|
+
(upb_Message*)msg->msg, msg->msgdef, symtab, options,
|
1059
|
+
Arena_get(msg->arena), &status)) {
|
1060
|
+
rb_raise(cParseError, "Error occurred during parsing: %s",
|
1061
|
+
upb_Status_ErrorMessage(&status));
|
1062
|
+
}
|
1063
|
+
|
1064
|
+
return msg_rb;
|
1065
|
+
}
|
1066
|
+
|
1067
|
+
/*
|
1068
|
+
* call-seq:
|
1069
|
+
* MessageClass.encode(msg, options) => bytes
|
1070
|
+
*
|
1071
|
+
* Encodes the given message object to its serialized form in protocol buffers
|
1072
|
+
* wire format.
|
1073
|
+
* @param options [Hash] options for the encoder
|
1074
|
+
* recursion_limit: set to maximum encoding depth for message (default is 64)
|
1075
|
+
*/
|
1076
|
+
static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
|
1077
|
+
Message* msg = ruby_to_Message(argv[0]);
|
1078
|
+
int options = 0;
|
1079
|
+
char* data;
|
1080
|
+
size_t size;
|
1081
|
+
|
1082
|
+
if (CLASS_OF(argv[0]) != klass) {
|
1083
|
+
rb_raise(rb_eArgError, "Message of wrong type.");
|
1084
|
+
}
|
1085
|
+
|
1086
|
+
if (argc < 1 || argc > 2) {
|
1087
|
+
rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
|
1088
|
+
}
|
1089
|
+
|
1090
|
+
if (argc == 2) {
|
1091
|
+
VALUE hash_args = argv[1];
|
1092
|
+
if (TYPE(hash_args) != T_HASH) {
|
1093
|
+
rb_raise(rb_eArgError, "Expected hash arguments.");
|
1094
|
+
}
|
1095
|
+
VALUE depth =
|
1096
|
+
rb_hash_lookup(hash_args, ID2SYM(rb_intern("recursion_limit")));
|
1097
|
+
|
1098
|
+
if (depth != Qnil && TYPE(depth) == T_FIXNUM) {
|
1099
|
+
options |= UPB_DECODE_MAXDEPTH(FIX2INT(depth));
|
1100
|
+
}
|
1101
|
+
}
|
1102
|
+
|
1103
|
+
upb_Arena* arena = upb_Arena_New();
|
1104
|
+
|
1105
|
+
upb_EncodeStatus status =
|
1106
|
+
upb_Encode(msg->msg, upb_MessageDef_MiniTable(msg->msgdef), options,
|
1107
|
+
arena, &data, &size);
|
1108
|
+
|
1109
|
+
if (status == kUpb_EncodeStatus_Ok) {
|
1110
|
+
VALUE ret = rb_str_new(data, size);
|
1111
|
+
rb_enc_associate(ret, rb_ascii8bit_encoding());
|
1112
|
+
upb_Arena_Free(arena);
|
1113
|
+
return ret;
|
1114
|
+
} else {
|
1115
|
+
upb_Arena_Free(arena);
|
1116
|
+
rb_raise(rb_eRuntimeError, "Exceeded maximum depth (possibly cycle)");
|
1117
|
+
}
|
1118
|
+
}
|
1119
|
+
|
1120
|
+
/*
|
1121
|
+
* call-seq:
|
1122
|
+
* MessageClass.encode_json(msg, options = {}) => json_string
|
1123
|
+
*
|
1124
|
+
* Encodes the given message object into its serialized JSON representation.
|
1125
|
+
* @param options [Hash] options for the decoder
|
1126
|
+
* preserve_proto_fieldnames: set true to use original fieldnames (default is
|
1127
|
+
* to camelCase) emit_defaults: set true to emit 0/false values (default is to
|
1128
|
+
* omit them)
|
1129
|
+
*/
|
1130
|
+
static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
|
1131
|
+
Message* msg = ruby_to_Message(argv[0]);
|
1132
|
+
int options = 0;
|
1133
|
+
char buf[1024];
|
1134
|
+
size_t size;
|
1135
|
+
upb_Status status;
|
1136
|
+
|
1137
|
+
// TODO(haberman): use this message's pool instead.
|
1138
|
+
const upb_DefPool* symtab = DescriptorPool_GetSymtab(generated_pool);
|
1139
|
+
|
1140
|
+
if (argc < 1 || argc > 2) {
|
1141
|
+
rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
|
1142
|
+
}
|
1143
|
+
|
1144
|
+
if (argc == 2) {
|
1145
|
+
VALUE hash_args = argv[1];
|
1146
|
+
if (TYPE(hash_args) != T_HASH) {
|
1147
|
+
if (RTEST(rb_funcall(hash_args, rb_intern("respond_to?"), 1,
|
1148
|
+
rb_str_new2("to_h")))) {
|
1149
|
+
hash_args = rb_funcall(hash_args, rb_intern("to_h"), 0);
|
1150
|
+
} else {
|
1151
|
+
rb_raise(rb_eArgError, "Expected hash arguments.");
|
1152
|
+
}
|
1153
|
+
}
|
1154
|
+
|
1155
|
+
if (RTEST(rb_hash_lookup2(hash_args,
|
1156
|
+
ID2SYM(rb_intern("preserve_proto_fieldnames")),
|
1157
|
+
Qfalse))) {
|
1158
|
+
options |= upb_JsonEncode_UseProtoNames;
|
1159
|
+
}
|
1160
|
+
|
1161
|
+
if (RTEST(rb_hash_lookup2(hash_args, ID2SYM(rb_intern("emit_defaults")),
|
1162
|
+
Qfalse))) {
|
1163
|
+
options |= upb_JsonEncode_EmitDefaults;
|
1164
|
+
}
|
1165
|
+
}
|
1166
|
+
|
1167
|
+
upb_Status_Clear(&status);
|
1168
|
+
size = upb_JsonEncode(msg->msg, msg->msgdef, symtab, options, buf,
|
1169
|
+
sizeof(buf), &status);
|
1170
|
+
|
1171
|
+
if (!upb_Status_IsOk(&status)) {
|
1172
|
+
rb_raise(cParseError, "Error occurred during encoding: %s",
|
1173
|
+
upb_Status_ErrorMessage(&status));
|
1174
|
+
}
|
1175
|
+
|
1176
|
+
VALUE ret;
|
1177
|
+
if (size >= sizeof(buf)) {
|
1178
|
+
char* buf2 = malloc(size + 1);
|
1179
|
+
upb_JsonEncode(msg->msg, msg->msgdef, symtab, options, buf2, size + 1,
|
1180
|
+
&status);
|
1181
|
+
ret = rb_str_new(buf2, size);
|
1182
|
+
free(buf2);
|
1183
|
+
} else {
|
1184
|
+
ret = rb_str_new(buf, size);
|
1185
|
+
}
|
1186
|
+
|
1187
|
+
rb_enc_associate(ret, rb_utf8_encoding());
|
1188
|
+
return ret;
|
1189
|
+
}
|
1190
|
+
|
1191
|
+
/*
|
1192
|
+
* call-seq:
|
1193
|
+
* Message.descriptor => descriptor
|
1194
|
+
*
|
1195
|
+
* Class method that returns the Descriptor instance corresponding to this
|
1196
|
+
* message class's type.
|
1197
|
+
*/
|
1198
|
+
static VALUE Message_descriptor(VALUE klass) {
|
1199
|
+
return rb_ivar_get(klass, descriptor_instancevar_interned);
|
1200
|
+
}
|
1201
|
+
|
1202
|
+
VALUE build_class_from_descriptor(VALUE descriptor) {
|
1203
|
+
const char* name;
|
1204
|
+
VALUE klass;
|
1205
|
+
|
1206
|
+
name = upb_MessageDef_FullName(Descriptor_GetMsgDef(descriptor));
|
1207
|
+
if (name == NULL) {
|
1208
|
+
rb_raise(rb_eRuntimeError, "Descriptor does not have assigned name.");
|
1209
|
+
}
|
1210
|
+
|
1211
|
+
klass = rb_define_class_id(
|
1212
|
+
// Docs say this parameter is ignored. User will assign return value to
|
1213
|
+
// their own toplevel constant class name.
|
1214
|
+
rb_intern("Message"), cAbstractMessage);
|
1215
|
+
rb_ivar_set(klass, descriptor_instancevar_interned, descriptor);
|
1216
|
+
return klass;
|
1217
|
+
}
|
1218
|
+
|
1219
|
+
/*
|
1220
|
+
* call-seq:
|
1221
|
+
* Enum.lookup(number) => name
|
1222
|
+
*
|
1223
|
+
* This module method, provided on each generated enum module, looks up an enum
|
1224
|
+
* value by number and returns its name as a Ruby symbol, or nil if not found.
|
1225
|
+
*/
|
1226
|
+
static VALUE enum_lookup(VALUE self, VALUE number) {
|
1227
|
+
int32_t num = NUM2INT(number);
|
1228
|
+
VALUE desc = rb_ivar_get(self, descriptor_instancevar_interned);
|
1229
|
+
const upb_EnumDef* e = EnumDescriptor_GetEnumDef(desc);
|
1230
|
+
const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNumber(e, num);
|
1231
|
+
if (ev) {
|
1232
|
+
return ID2SYM(rb_intern(upb_EnumValueDef_Name(ev)));
|
1233
|
+
} else {
|
1234
|
+
return Qnil;
|
1235
|
+
}
|
1236
|
+
}
|
1237
|
+
|
1238
|
+
/*
|
1239
|
+
* call-seq:
|
1240
|
+
* Enum.resolve(name) => number
|
1241
|
+
*
|
1242
|
+
* This module method, provided on each generated enum module, looks up an enum
|
1243
|
+
* value by name (as a Ruby symbol) and returns its name, or nil if not found.
|
1244
|
+
*/
|
1245
|
+
static VALUE enum_resolve(VALUE self, VALUE sym) {
|
1246
|
+
const char* name = rb_id2name(SYM2ID(sym));
|
1247
|
+
VALUE desc = rb_ivar_get(self, descriptor_instancevar_interned);
|
1248
|
+
const upb_EnumDef* e = EnumDescriptor_GetEnumDef(desc);
|
1249
|
+
const upb_EnumValueDef* ev = upb_EnumDef_FindValueByName(e, name);
|
1250
|
+
if (ev) {
|
1251
|
+
return INT2NUM(upb_EnumValueDef_Number(ev));
|
1252
|
+
} else {
|
1253
|
+
return Qnil;
|
1254
|
+
}
|
1255
|
+
}
|
1256
|
+
|
1257
|
+
/*
|
1258
|
+
* call-seq:
|
1259
|
+
* Enum.descriptor
|
1260
|
+
*
|
1261
|
+
* This module method, provided on each generated enum module, returns the
|
1262
|
+
* EnumDescriptor corresponding to this enum type.
|
1263
|
+
*/
|
1264
|
+
static VALUE enum_descriptor(VALUE self) {
|
1265
|
+
return rb_ivar_get(self, descriptor_instancevar_interned);
|
1266
|
+
}
|
1267
|
+
|
1268
|
+
VALUE build_module_from_enumdesc(VALUE _enumdesc) {
|
1269
|
+
const upb_EnumDef* e = EnumDescriptor_GetEnumDef(_enumdesc);
|
1270
|
+
VALUE mod = rb_define_module_id(rb_intern(upb_EnumDef_FullName(e)));
|
1271
|
+
|
1272
|
+
int n = upb_EnumDef_ValueCount(e);
|
1273
|
+
for (int i = 0; i < n; i++) {
|
1274
|
+
const upb_EnumValueDef* ev = upb_EnumDef_Value(e, i);
|
1275
|
+
upb_Arena* arena = upb_Arena_New();
|
1276
|
+
const char* src_name = upb_EnumValueDef_Name(ev);
|
1277
|
+
char* name = upb_strdup2(src_name, strlen(src_name), arena);
|
1278
|
+
int32_t value = upb_EnumValueDef_Number(ev);
|
1279
|
+
if (name[0] < 'A' || name[0] > 'Z') {
|
1280
|
+
if (name[0] >= 'a' && name[0] <= 'z') {
|
1281
|
+
name[0] -= 32; // auto capitalize
|
1282
|
+
} else {
|
1283
|
+
rb_warn(
|
1284
|
+
"Enum value '%s' does not start with an uppercase letter "
|
1285
|
+
"as is required for Ruby constants.",
|
1286
|
+
name);
|
1287
|
+
}
|
1288
|
+
}
|
1289
|
+
rb_define_const(mod, name, INT2NUM(value));
|
1290
|
+
upb_Arena_Free(arena);
|
1291
|
+
}
|
1292
|
+
|
1293
|
+
rb_define_singleton_method(mod, "lookup", enum_lookup, 1);
|
1294
|
+
rb_define_singleton_method(mod, "resolve", enum_resolve, 1);
|
1295
|
+
rb_define_singleton_method(mod, "descriptor", enum_descriptor, 0);
|
1296
|
+
rb_ivar_set(mod, descriptor_instancevar_interned, _enumdesc);
|
1297
|
+
|
1298
|
+
return mod;
|
1299
|
+
}
|
1300
|
+
|
1301
|
+
// Internal to the library; used by Google::Protobuf.deep_copy.
|
1302
|
+
upb_Message* Message_deep_copy(const upb_Message* msg, const upb_MessageDef* m,
|
1303
|
+
upb_Arena* arena) {
|
1304
|
+
// Serialize and parse.
|
1305
|
+
upb_Arena* tmp_arena = upb_Arena_New();
|
1306
|
+
const upb_MiniTable* layout = upb_MessageDef_MiniTable(m);
|
1307
|
+
size_t size;
|
1308
|
+
|
1309
|
+
upb_Message* new_msg = upb_Message_New(layout, arena);
|
1310
|
+
char* data;
|
1311
|
+
|
1312
|
+
if (upb_Encode(msg, layout, 0, tmp_arena, &data, &size) !=
|
1313
|
+
kUpb_EncodeStatus_Ok ||
|
1314
|
+
upb_Decode(data, size, new_msg, layout, NULL, 0, arena) !=
|
1315
|
+
kUpb_DecodeStatus_Ok) {
|
1316
|
+
upb_Arena_Free(tmp_arena);
|
1317
|
+
rb_raise(cParseError, "Error occurred copying proto");
|
1318
|
+
}
|
1319
|
+
|
1320
|
+
upb_Arena_Free(tmp_arena);
|
1321
|
+
return new_msg;
|
1322
|
+
}
|
1323
|
+
|
1324
|
+
const upb_Message* Message_GetUpbMessage(VALUE value, const upb_MessageDef* m,
|
1325
|
+
const char* name, upb_Arena* arena) {
|
1326
|
+
if (value == Qnil) {
|
1327
|
+
rb_raise(cTypeError, "nil message not allowed here.");
|
1328
|
+
}
|
1329
|
+
|
1330
|
+
VALUE klass = CLASS_OF(value);
|
1331
|
+
VALUE desc_rb = rb_ivar_get(klass, descriptor_instancevar_interned);
|
1332
|
+
const upb_MessageDef* val_m =
|
1333
|
+
desc_rb == Qnil ? NULL : Descriptor_GetMsgDef(desc_rb);
|
1334
|
+
|
1335
|
+
if (val_m != m) {
|
1336
|
+
// Check for possible implicit conversions
|
1337
|
+
// TODO: hash conversion?
|
1338
|
+
|
1339
|
+
switch (upb_MessageDef_WellKnownType(m)) {
|
1340
|
+
case kUpb_WellKnown_Timestamp: {
|
1341
|
+
// Time -> Google::Protobuf::Timestamp
|
1342
|
+
const upb_MiniTable* t = upb_MessageDef_MiniTable(m);
|
1343
|
+
upb_Message* msg = upb_Message_New(t, arena);
|
1344
|
+
upb_MessageValue sec, nsec;
|
1345
|
+
struct timespec time;
|
1346
|
+
const upb_FieldDef* sec_f = upb_MessageDef_FindFieldByNumber(m, 1);
|
1347
|
+
const upb_FieldDef* nsec_f = upb_MessageDef_FindFieldByNumber(m, 2);
|
1348
|
+
|
1349
|
+
if (!rb_obj_is_kind_of(value, rb_cTime)) goto badtype;
|
1350
|
+
|
1351
|
+
time = rb_time_timespec(value);
|
1352
|
+
sec.int64_val = time.tv_sec;
|
1353
|
+
nsec.int32_val = time.tv_nsec;
|
1354
|
+
upb_Message_SetFieldByDef(msg, sec_f, sec, arena);
|
1355
|
+
upb_Message_SetFieldByDef(msg, nsec_f, nsec, arena);
|
1356
|
+
return msg;
|
1357
|
+
}
|
1358
|
+
case kUpb_WellKnown_Duration: {
|
1359
|
+
// Numeric -> Google::Protobuf::Duration
|
1360
|
+
const upb_MiniTable* t = upb_MessageDef_MiniTable(m);
|
1361
|
+
upb_Message* msg = upb_Message_New(t, arena);
|
1362
|
+
upb_MessageValue sec, nsec;
|
1363
|
+
const upb_FieldDef* sec_f = upb_MessageDef_FindFieldByNumber(m, 1);
|
1364
|
+
const upb_FieldDef* nsec_f = upb_MessageDef_FindFieldByNumber(m, 2);
|
1365
|
+
|
1366
|
+
if (!rb_obj_is_kind_of(value, rb_cNumeric)) goto badtype;
|
1367
|
+
|
1368
|
+
sec.int64_val = NUM2LL(value);
|
1369
|
+
nsec.int32_val = round((NUM2DBL(value) - NUM2LL(value)) * 1000000000);
|
1370
|
+
upb_Message_SetFieldByDef(msg, sec_f, sec, arena);
|
1371
|
+
upb_Message_SetFieldByDef(msg, nsec_f, nsec, arena);
|
1372
|
+
return msg;
|
1373
|
+
}
|
1374
|
+
default:
|
1375
|
+
badtype:
|
1376
|
+
rb_raise(cTypeError,
|
1377
|
+
"Invalid type %s to assign to submessage field '%s'.",
|
1378
|
+
rb_class2name(CLASS_OF(value)), name);
|
1379
|
+
}
|
1380
|
+
}
|
1381
|
+
|
1382
|
+
Message* self = ruby_to_Message(value);
|
1383
|
+
Arena_fuse(self->arena, arena);
|
1384
|
+
|
1385
|
+
return self->msg;
|
1386
|
+
}
|
1387
|
+
|
1388
|
+
static void Message_define_class(VALUE klass) {
|
1389
|
+
rb_define_alloc_func(klass, Message_alloc);
|
1390
|
+
|
1391
|
+
rb_require("google/protobuf/message_exts");
|
1392
|
+
rb_define_method(klass, "method_missing", Message_method_missing, -1);
|
1393
|
+
rb_define_method(klass, "respond_to_missing?", Message_respond_to_missing,
|
1394
|
+
-1);
|
1395
|
+
rb_define_method(klass, "initialize", Message_initialize, -1);
|
1396
|
+
rb_define_method(klass, "dup", Message_dup, 0);
|
1397
|
+
// Also define #clone so that we don't inherit Object#clone.
|
1398
|
+
rb_define_method(klass, "clone", Message_dup, 0);
|
1399
|
+
rb_define_method(klass, "==", Message_eq, 1);
|
1400
|
+
rb_define_method(klass, "eql?", Message_eq, 1);
|
1401
|
+
rb_define_method(klass, "freeze", Message_freeze, 0);
|
1402
|
+
rb_define_method(klass, "hash", Message_hash, 0);
|
1403
|
+
rb_define_method(klass, "to_h", Message_to_h, 0);
|
1404
|
+
rb_define_method(klass, "inspect", Message_inspect, 0);
|
1405
|
+
rb_define_method(klass, "to_s", Message_inspect, 0);
|
1406
|
+
rb_define_method(klass, "[]", Message_index, 1);
|
1407
|
+
rb_define_method(klass, "[]=", Message_index_set, 2);
|
1408
|
+
rb_define_singleton_method(klass, "decode", Message_decode, -1);
|
1409
|
+
rb_define_singleton_method(klass, "encode", Message_encode, -1);
|
1410
|
+
rb_define_singleton_method(klass, "decode_json", Message_decode_json, -1);
|
1411
|
+
rb_define_singleton_method(klass, "encode_json", Message_encode_json, -1);
|
1412
|
+
rb_define_singleton_method(klass, "descriptor", Message_descriptor, 0);
|
1413
|
+
}
|
1414
|
+
|
1415
|
+
void Message_register(VALUE protobuf) {
|
1416
|
+
cParseError = rb_const_get(protobuf, rb_intern("ParseError"));
|
1417
|
+
cAbstractMessage =
|
1418
|
+
rb_define_class_under(protobuf, "AbstractMessage", rb_cObject);
|
1419
|
+
Message_define_class(cAbstractMessage);
|
1420
|
+
rb_gc_register_address(&cAbstractMessage);
|
1421
|
+
|
1422
|
+
// Ruby-interned string: "descriptor". We use this identifier to store an
|
1423
|
+
// instance variable on message classes we create in order to link them back
|
1424
|
+
// to their descriptors.
|
1425
|
+
descriptor_instancevar_interned = rb_intern("@descriptor");
|
1426
|
+
}
|