| OLD | NEW |
|---|
| (Empty) |
| 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 #ifndef __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__ | |
| 32 #define __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__ | |
| 33 | |
| 34 #include <ruby/ruby.h> | |
| 35 #include <ruby/vm.h> | |
| 36 #include <ruby/encoding.h> | |
| 37 | |
| 38 #include "upb.h" | |
| 39 | |
| 40 // Forward decls. | |
| 41 struct DescriptorPool; | |
| 42 struct Descriptor; | |
| 43 struct FieldDescriptor; | |
| 44 struct EnumDescriptor; | |
| 45 struct MessageLayout; | |
| 46 struct MessageField; | |
| 47 struct MessageHeader; | |
| 48 struct MessageBuilderContext; | |
| 49 struct EnumBuilderContext; | |
| 50 struct Builder; | |
| 51 | |
| 52 typedef struct DescriptorPool DescriptorPool; | |
| 53 typedef struct Descriptor Descriptor; | |
| 54 typedef struct FieldDescriptor FieldDescriptor; | |
| 55 typedef struct OneofDescriptor OneofDescriptor; | |
| 56 typedef struct EnumDescriptor EnumDescriptor; | |
| 57 typedef struct MessageLayout MessageLayout; | |
| 58 typedef struct MessageField MessageField; | |
| 59 typedef struct MessageHeader MessageHeader; | |
| 60 typedef struct MessageBuilderContext MessageBuilderContext; | |
| 61 typedef struct OneofBuilderContext OneofBuilderContext; | |
| 62 typedef struct EnumBuilderContext EnumBuilderContext; | |
| 63 typedef struct Builder Builder; | |
| 64 | |
| 65 /* | |
| 66 It can be a bit confusing how the C structs defined below and the Ruby | |
| 67 objects interact and hold references to each other. First, a few principles: | |
| 68 | |
| 69 - Ruby's "TypedData" abstraction lets a Ruby VALUE hold a pointer to a C | |
| 70 struct (or arbitrary memory chunk), own it, and free it when collected. | |
| 71 Thus, each struct below will have a corresponding Ruby object | |
| 72 wrapping/owning it. | |
| 73 | |
| 74 - To get back from an underlying upb {msg,enum}def to the Ruby object, we | |
| 75 keep a global hashmap, accessed by get_def_obj/add_def_obj below. | |
| 76 | |
| 77 The in-memory structure is then something like: | |
| 78 | |
| 79 Ruby | upb | |
| 80 | | |
| 81 DescriptorPool ------------|-----------> upb_symtab____________________ | |
| 82 | | (message types) \ | |
| 83 | v \ | |
| 84 Descriptor ---------------|-----------> upb_msgdef (enum types)| | |
| 85 |--> msgclass | | ^ | | |
| 86 | (dynamically built) | | | (submsg fields) | | |
| 87 |--> MessageLayout | | | / | |
| 88 |--------------------------|> decoder method| | / | |
| 89 \--------------------------|> serialize | | / | |
| 90 | handlers v | / | |
| 91 FieldDescriptor -----------|-----------> upb_fielddef / | |
| 92 | | / | |
| 93 | v (enum fields) / | |
| 94 EnumDescriptor ------------|-----------> upb_enumdef <----------' | |
| 95 | | |
| 96 | | |
| 97 ^ | \___/ | |
| 98 `---------------|-----------------' (get_def_obj map) | |
| 99 */ | |
| 100 | |
| 101 // ----------------------------------------------------------------------------- | |
| 102 // Ruby class structure definitions. | |
| 103 // ----------------------------------------------------------------------------- | |
| 104 | |
| 105 struct DescriptorPool { | |
| 106 upb_symtab* symtab; | |
| 107 }; | |
| 108 | |
| 109 struct Descriptor { | |
| 110 const upb_msgdef* msgdef; | |
| 111 MessageLayout* layout; | |
| 112 VALUE klass; // begins as nil | |
| 113 const upb_handlers* fill_handlers; | |
| 114 const upb_pbdecodermethod* fill_method; | |
| 115 const upb_handlers* pb_serialize_handlers; | |
| 116 const upb_handlers* json_serialize_handlers; | |
| 117 // Handlers hold type class references for sub-message fields directly in some | |
| 118 // cases. We need to keep these rooted because they might otherwise be | |
| 119 // collected. | |
| 120 VALUE typeclass_references; | |
| 121 }; | |
| 122 | |
| 123 struct FieldDescriptor { | |
| 124 const upb_fielddef* fielddef; | |
| 125 }; | |
| 126 | |
| 127 struct OneofDescriptor { | |
| 128 const upb_oneofdef* oneofdef; | |
| 129 }; | |
| 130 | |
| 131 struct EnumDescriptor { | |
| 132 const upb_enumdef* enumdef; | |
| 133 VALUE module; // begins as nil | |
| 134 }; | |
| 135 | |
| 136 struct MessageBuilderContext { | |
| 137 VALUE descriptor; | |
| 138 VALUE builder; | |
| 139 }; | |
| 140 | |
| 141 struct OneofBuilderContext { | |
| 142 VALUE descriptor; | |
| 143 VALUE builder; | |
| 144 }; | |
| 145 | |
| 146 struct EnumBuilderContext { | |
| 147 VALUE enumdesc; | |
| 148 }; | |
| 149 | |
| 150 struct Builder { | |
| 151 VALUE pending_list; | |
| 152 upb_def** defs; // used only while finalizing | |
| 153 }; | |
| 154 | |
| 155 extern VALUE cDescriptorPool; | |
| 156 extern VALUE cDescriptor; | |
| 157 extern VALUE cFieldDescriptor; | |
| 158 extern VALUE cEnumDescriptor; | |
| 159 extern VALUE cMessageBuilderContext; | |
| 160 extern VALUE cOneofBuilderContext; | |
| 161 extern VALUE cEnumBuilderContext; | |
| 162 extern VALUE cBuilder; | |
| 163 | |
| 164 extern VALUE cError; | |
| 165 extern VALUE cParseError; | |
| 166 | |
| 167 // We forward-declare all of the Ruby method implementations here because we | |
| 168 // sometimes call the methods directly across .c files, rather than going | |
| 169 // through Ruby's method dispatching (e.g. during message parse). It's cleaner | |
| 170 // to keep the list of object methods together than to split them between | |
| 171 // static-in-file definitions and header declarations. | |
| 172 | |
| 173 void DescriptorPool_mark(void* _self); | |
| 174 void DescriptorPool_free(void* _self); | |
| 175 VALUE DescriptorPool_alloc(VALUE klass); | |
| 176 void DescriptorPool_register(VALUE module); | |
| 177 DescriptorPool* ruby_to_DescriptorPool(VALUE value); | |
| 178 VALUE DescriptorPool_add(VALUE _self, VALUE def); | |
| 179 VALUE DescriptorPool_build(VALUE _self); | |
| 180 VALUE DescriptorPool_lookup(VALUE _self, VALUE name); | |
| 181 VALUE DescriptorPool_generated_pool(VALUE _self); | |
| 182 | |
| 183 void Descriptor_mark(void* _self); | |
| 184 void Descriptor_free(void* _self); | |
| 185 VALUE Descriptor_alloc(VALUE klass); | |
| 186 void Descriptor_register(VALUE module); | |
| 187 Descriptor* ruby_to_Descriptor(VALUE value); | |
| 188 VALUE Descriptor_name(VALUE _self); | |
| 189 VALUE Descriptor_name_set(VALUE _self, VALUE str); | |
| 190 VALUE Descriptor_each(VALUE _self); | |
| 191 VALUE Descriptor_lookup(VALUE _self, VALUE name); | |
| 192 VALUE Descriptor_add_field(VALUE _self, VALUE obj); | |
| 193 VALUE Descriptor_add_oneof(VALUE _self, VALUE obj); | |
| 194 VALUE Descriptor_each_oneof(VALUE _self); | |
| 195 VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name); | |
| 196 VALUE Descriptor_msgclass(VALUE _self); | |
| 197 extern const rb_data_type_t _Descriptor_type; | |
| 198 | |
| 199 void FieldDescriptor_mark(void* _self); | |
| 200 void FieldDescriptor_free(void* _self); | |
| 201 VALUE FieldDescriptor_alloc(VALUE klass); | |
| 202 void FieldDescriptor_register(VALUE module); | |
| 203 FieldDescriptor* ruby_to_FieldDescriptor(VALUE value); | |
| 204 VALUE FieldDescriptor_name(VALUE _self); | |
| 205 VALUE FieldDescriptor_name_set(VALUE _self, VALUE str); | |
| 206 VALUE FieldDescriptor_type(VALUE _self); | |
| 207 VALUE FieldDescriptor_type_set(VALUE _self, VALUE type); | |
| 208 VALUE FieldDescriptor_label(VALUE _self); | |
| 209 VALUE FieldDescriptor_label_set(VALUE _self, VALUE label); | |
| 210 VALUE FieldDescriptor_number(VALUE _self); | |
| 211 VALUE FieldDescriptor_number_set(VALUE _self, VALUE number); | |
| 212 VALUE FieldDescriptor_submsg_name(VALUE _self); | |
| 213 VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value); | |
| 214 VALUE FieldDescriptor_subtype(VALUE _self); | |
| 215 VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb); | |
| 216 VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value); | |
| 217 upb_fieldtype_t ruby_to_fieldtype(VALUE type); | |
| 218 VALUE fieldtype_to_ruby(upb_fieldtype_t type); | |
| 219 | |
| 220 void OneofDescriptor_mark(void* _self); | |
| 221 void OneofDescriptor_free(void* _self); | |
| 222 VALUE OneofDescriptor_alloc(VALUE klass); | |
| 223 void OneofDescriptor_register(VALUE module); | |
| 224 OneofDescriptor* ruby_to_OneofDescriptor(VALUE value); | |
| 225 VALUE OneofDescriptor_name(VALUE _self); | |
| 226 VALUE OneofDescriptor_name_set(VALUE _self, VALUE value); | |
| 227 VALUE OneofDescriptor_add_field(VALUE _self, VALUE field); | |
| 228 VALUE OneofDescriptor_each(VALUE _self, VALUE field); | |
| 229 | |
| 230 void EnumDescriptor_mark(void* _self); | |
| 231 void EnumDescriptor_free(void* _self); | |
| 232 VALUE EnumDescriptor_alloc(VALUE klass); | |
| 233 void EnumDescriptor_register(VALUE module); | |
| 234 EnumDescriptor* ruby_to_EnumDescriptor(VALUE value); | |
| 235 VALUE EnumDescriptor_name(VALUE _self); | |
| 236 VALUE EnumDescriptor_name_set(VALUE _self, VALUE str); | |
| 237 VALUE EnumDescriptor_add_value(VALUE _self, VALUE name, VALUE number); | |
| 238 VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name); | |
| 239 VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number); | |
| 240 VALUE EnumDescriptor_each(VALUE _self); | |
| 241 VALUE EnumDescriptor_enummodule(VALUE _self); | |
| 242 extern const rb_data_type_t _EnumDescriptor_type; | |
| 243 | |
| 244 void MessageBuilderContext_mark(void* _self); | |
| 245 void MessageBuilderContext_free(void* _self); | |
| 246 VALUE MessageBuilderContext_alloc(VALUE klass); | |
| 247 void MessageBuilderContext_register(VALUE module); | |
| 248 MessageBuilderContext* ruby_to_MessageBuilderContext(VALUE value); | |
| 249 VALUE MessageBuilderContext_initialize(VALUE _self, | |
| 250 VALUE descriptor, | |
| 251 VALUE builder); | |
| 252 VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self); | |
| 253 VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self); | |
| 254 VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self); | |
| 255 VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self); | |
| 256 VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name); | |
| 257 | |
| 258 void OneofBuilderContext_mark(void* _self); | |
| 259 void OneofBuilderContext_free(void* _self); | |
| 260 VALUE OneofBuilderContext_alloc(VALUE klass); | |
| 261 void OneofBuilderContext_register(VALUE module); | |
| 262 OneofBuilderContext* ruby_to_OneofBuilderContext(VALUE value); | |
| 263 VALUE OneofBuilderContext_initialize(VALUE _self, | |
| 264 VALUE descriptor, | |
| 265 VALUE builder); | |
| 266 VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self); | |
| 267 | |
| 268 void EnumBuilderContext_mark(void* _self); | |
| 269 void EnumBuilderContext_free(void* _self); | |
| 270 VALUE EnumBuilderContext_alloc(VALUE klass); | |
| 271 void EnumBuilderContext_register(VALUE module); | |
| 272 EnumBuilderContext* ruby_to_EnumBuilderContext(VALUE value); | |
| 273 VALUE EnumBuilderContext_initialize(VALUE _self, VALUE enumdesc); | |
| 274 VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number); | |
| 275 | |
| 276 void Builder_mark(void* _self); | |
| 277 void Builder_free(void* _self); | |
| 278 VALUE Builder_alloc(VALUE klass); | |
| 279 void Builder_register(VALUE module); | |
| 280 Builder* ruby_to_Builder(VALUE value); | |
| 281 VALUE Builder_add_message(VALUE _self, VALUE name); | |
| 282 VALUE Builder_add_enum(VALUE _self, VALUE name); | |
| 283 VALUE Builder_finalize_to_pool(VALUE _self, VALUE pool_rb); | |
| 284 | |
| 285 // ----------------------------------------------------------------------------- | |
| 286 // Native slot storage abstraction. | |
| 287 // ----------------------------------------------------------------------------- | |
| 288 | |
| 289 #define NATIVE_SLOT_MAX_SIZE sizeof(uint64_t) | |
| 290 | |
| 291 size_t native_slot_size(upb_fieldtype_t type); | |
| 292 void native_slot_set(upb_fieldtype_t type, | |
| 293 VALUE type_class, | |
| 294 void* memory, | |
| 295 VALUE value); | |
| 296 // Atomically (with respect to Ruby VM calls) either update the value and set a | |
| 297 // oneof case, or do neither. If |case_memory| is null, then no case value is | |
| 298 // set. | |
| 299 void native_slot_set_value_and_case(upb_fieldtype_t type, | |
| 300 VALUE type_class, | |
| 301 void* memory, | |
| 302 VALUE value, | |
| 303 uint32_t* case_memory, | |
| 304 uint32_t case_number); | |
| 305 VALUE native_slot_get(upb_fieldtype_t type, | |
| 306 VALUE type_class, | |
| 307 const void* memory); | |
| 308 void native_slot_init(upb_fieldtype_t type, void* memory); | |
| 309 void native_slot_mark(upb_fieldtype_t type, void* memory); | |
| 310 void native_slot_dup(upb_fieldtype_t type, void* to, void* from); | |
| 311 void native_slot_deep_copy(upb_fieldtype_t type, void* to, void* from); | |
| 312 bool native_slot_eq(upb_fieldtype_t type, void* mem1, void* mem2); | |
| 313 | |
| 314 void native_slot_validate_string_encoding(upb_fieldtype_t type, VALUE value); | |
| 315 void native_slot_check_int_range_precision(upb_fieldtype_t type, VALUE value); | |
| 316 | |
| 317 extern rb_encoding* kRubyStringUtf8Encoding; | |
| 318 extern rb_encoding* kRubyStringASCIIEncoding; | |
| 319 extern rb_encoding* kRubyString8bitEncoding; | |
| 320 | |
| 321 VALUE field_type_class(const upb_fielddef* field); | |
| 322 | |
| 323 #define MAP_KEY_FIELD 1 | |
| 324 #define MAP_VALUE_FIELD 2 | |
| 325 | |
| 326 // Oneof case slot value to indicate that no oneof case is set. The value `0` is | |
| 327 // safe because field numbers are used as case identifiers, and no field can | |
| 328 // have a number of 0. | |
| 329 #define ONEOF_CASE_NONE 0 | |
| 330 | |
| 331 // These operate on a map field (i.e., a repeated field of submessages whose | |
| 332 // submessage type is a map-entry msgdef). | |
| 333 bool is_map_field(const upb_fielddef* field); | |
| 334 const upb_fielddef* map_field_key(const upb_fielddef* field); | |
| 335 const upb_fielddef* map_field_value(const upb_fielddef* field); | |
| 336 | |
| 337 // These operate on a map-entry msgdef. | |
| 338 const upb_fielddef* map_entry_key(const upb_msgdef* msgdef); | |
| 339 const upb_fielddef* map_entry_value(const upb_msgdef* msgdef); | |
| 340 | |
| 341 // ----------------------------------------------------------------------------- | |
| 342 // Repeated field container type. | |
| 343 // ----------------------------------------------------------------------------- | |
| 344 | |
| 345 typedef struct { | |
| 346 upb_fieldtype_t field_type; | |
| 347 VALUE field_type_class; | |
| 348 void* elements; | |
| 349 int size; | |
| 350 int capacity; | |
| 351 } RepeatedField; | |
| 352 | |
| 353 void RepeatedField_mark(void* self); | |
| 354 void RepeatedField_free(void* self); | |
| 355 VALUE RepeatedField_alloc(VALUE klass); | |
| 356 VALUE RepeatedField_init(int argc, VALUE* argv, VALUE self); | |
| 357 void RepeatedField_register(VALUE module); | |
| 358 | |
| 359 extern const rb_data_type_t RepeatedField_type; | |
| 360 extern VALUE cRepeatedField; | |
| 361 | |
| 362 RepeatedField* ruby_to_RepeatedField(VALUE value); | |
| 363 | |
| 364 VALUE RepeatedField_each(VALUE _self); | |
| 365 VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self); | |
| 366 void* RepeatedField_index_native(VALUE _self, int index); | |
| 367 VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val); | |
| 368 void RepeatedField_reserve(RepeatedField* self, int new_size); | |
| 369 VALUE RepeatedField_push(VALUE _self, VALUE val); | |
| 370 void RepeatedField_push_native(VALUE _self, void* data); | |
| 371 VALUE RepeatedField_pop_one(VALUE _self); | |
| 372 VALUE RepeatedField_insert(int argc, VALUE* argv, VALUE _self); | |
| 373 VALUE RepeatedField_replace(VALUE _self, VALUE list); | |
| 374 VALUE RepeatedField_clear(VALUE _self); | |
| 375 VALUE RepeatedField_length(VALUE _self); | |
| 376 VALUE RepeatedField_dup(VALUE _self); | |
| 377 VALUE RepeatedField_deep_copy(VALUE _self); | |
| 378 VALUE RepeatedField_to_ary(VALUE _self); | |
| 379 VALUE RepeatedField_eq(VALUE _self, VALUE _other); | |
| 380 VALUE RepeatedField_hash(VALUE _self); | |
| 381 VALUE RepeatedField_inspect(VALUE _self); | |
| 382 VALUE RepeatedField_plus(VALUE _self, VALUE list); | |
| 383 | |
| 384 // Defined in repeated_field.c; also used by Map. | |
| 385 void validate_type_class(upb_fieldtype_t type, VALUE klass); | |
| 386 | |
| 387 // ----------------------------------------------------------------------------- | |
| 388 // Map container type. | |
| 389 // ----------------------------------------------------------------------------- | |
| 390 | |
| 391 typedef struct { | |
| 392 upb_fieldtype_t key_type; | |
| 393 upb_fieldtype_t value_type; | |
| 394 VALUE value_type_class; | |
| 395 upb_strtable table; | |
| 396 } Map; | |
| 397 | |
| 398 void Map_mark(void* self); | |
| 399 void Map_free(void* self); | |
| 400 VALUE Map_alloc(VALUE klass); | |
| 401 VALUE Map_init(int argc, VALUE* argv, VALUE self); | |
| 402 void Map_register(VALUE module); | |
| 403 | |
| 404 extern const rb_data_type_t Map_type; | |
| 405 extern VALUE cMap; | |
| 406 | |
| 407 Map* ruby_to_Map(VALUE value); | |
| 408 | |
| 409 VALUE Map_each(VALUE _self); | |
| 410 VALUE Map_keys(VALUE _self); | |
| 411 VALUE Map_values(VALUE _self); | |
| 412 VALUE Map_index(VALUE _self, VALUE key); | |
| 413 VALUE Map_index_set(VALUE _self, VALUE key, VALUE value); | |
| 414 VALUE Map_has_key(VALUE _self, VALUE key); | |
| 415 VALUE Map_delete(VALUE _self, VALUE key); | |
| 416 VALUE Map_clear(VALUE _self); | |
| 417 VALUE Map_length(VALUE _self); | |
| 418 VALUE Map_dup(VALUE _self); | |
| 419 VALUE Map_deep_copy(VALUE _self); | |
| 420 VALUE Map_eq(VALUE _self, VALUE _other); | |
| 421 VALUE Map_hash(VALUE _self); | |
| 422 VALUE Map_inspect(VALUE _self); | |
| 423 VALUE Map_merge(VALUE _self, VALUE hashmap); | |
| 424 VALUE Map_merge_into_self(VALUE _self, VALUE hashmap); | |
| 425 | |
| 426 typedef struct { | |
| 427 Map* self; | |
| 428 upb_strtable_iter it; | |
| 429 } Map_iter; | |
| 430 | |
| 431 void Map_begin(VALUE _self, Map_iter* iter); | |
| 432 void Map_next(Map_iter* iter); | |
| 433 bool Map_done(Map_iter* iter); | |
| 434 VALUE Map_iter_key(Map_iter* iter); | |
| 435 VALUE Map_iter_value(Map_iter* iter); | |
| 436 | |
| 437 // ----------------------------------------------------------------------------- | |
| 438 // Message layout / storage. | |
| 439 // ----------------------------------------------------------------------------- | |
| 440 | |
| 441 #define MESSAGE_FIELD_NO_CASE ((size_t)-1) | |
| 442 | |
| 443 struct MessageField { | |
| 444 size_t offset; | |
| 445 size_t case_offset; // for oneofs, a uint32. Else, MESSAGE_FIELD_NO_CASE. | |
| 446 }; | |
| 447 | |
| 448 struct MessageLayout { | |
| 449 const upb_msgdef* msgdef; | |
| 450 MessageField* fields; | |
| 451 size_t size; | |
| 452 }; | |
| 453 | |
| 454 MessageLayout* create_layout(const upb_msgdef* msgdef); | |
| 455 void free_layout(MessageLayout* layout); | |
| 456 VALUE layout_get(MessageLayout* layout, | |
| 457 const void* storage, | |
| 458 const upb_fielddef* field); | |
| 459 void layout_set(MessageLayout* layout, | |
| 460 void* storage, | |
| 461 const upb_fielddef* field, | |
| 462 VALUE val); | |
| 463 void layout_init(MessageLayout* layout, void* storage); | |
| 464 void layout_mark(MessageLayout* layout, void* storage); | |
| 465 void layout_dup(MessageLayout* layout, void* to, void* from); | |
| 466 void layout_deep_copy(MessageLayout* layout, void* to, void* from); | |
| 467 VALUE layout_eq(MessageLayout* layout, void* msg1, void* msg2); | |
| 468 VALUE layout_hash(MessageLayout* layout, void* storage); | |
| 469 VALUE layout_inspect(MessageLayout* layout, void* storage); | |
| 470 | |
| 471 // ----------------------------------------------------------------------------- | |
| 472 // Message class creation. | |
| 473 // ----------------------------------------------------------------------------- | |
| 474 | |
| 475 struct MessageHeader { | |
| 476 Descriptor* descriptor; // kept alive by self.class.descriptor reference. | |
| 477 // Data comes after this. | |
| 478 }; | |
| 479 | |
| 480 extern rb_data_type_t Message_type; | |
| 481 | |
| 482 VALUE build_class_from_descriptor(Descriptor* descriptor); | |
| 483 void* Message_data(void* msg); | |
| 484 void Message_mark(void* self); | |
| 485 void Message_free(void* self); | |
| 486 VALUE Message_alloc(VALUE klass); | |
| 487 VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self); | |
| 488 VALUE Message_initialize(int argc, VALUE* argv, VALUE _self); | |
| 489 VALUE Message_dup(VALUE _self); | |
| 490 VALUE Message_deep_copy(VALUE _self); | |
| 491 VALUE Message_eq(VALUE _self, VALUE _other); | |
| 492 VALUE Message_hash(VALUE _self); | |
| 493 VALUE Message_inspect(VALUE _self); | |
| 494 VALUE Message_index(VALUE _self, VALUE field_name); | |
| 495 VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value); | |
| 496 VALUE Message_descriptor(VALUE klass); | |
| 497 VALUE Message_decode(VALUE klass, VALUE data); | |
| 498 VALUE Message_encode(VALUE klass, VALUE msg_rb); | |
| 499 VALUE Message_decode_json(VALUE klass, VALUE data); | |
| 500 VALUE Message_encode_json(VALUE klass, VALUE msg_rb); | |
| 501 | |
| 502 VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj); | |
| 503 | |
| 504 VALUE build_module_from_enumdesc(EnumDescriptor* enumdef); | |
| 505 VALUE enum_lookup(VALUE self, VALUE number); | |
| 506 VALUE enum_resolve(VALUE self, VALUE sym); | |
| 507 | |
| 508 const upb_pbdecodermethod *new_fillmsg_decodermethod( | |
| 509 Descriptor* descriptor, const void *owner); | |
| 510 | |
| 511 // Maximum depth allowed during encoding, to avoid stack overflows due to | |
| 512 // cycles. | |
| 513 #define ENCODE_MAX_NESTING 63 | |
| 514 | |
| 515 // ----------------------------------------------------------------------------- | |
| 516 // Global map from upb {msg,enum}defs to wrapper Descriptor/EnumDescriptor | |
| 517 // instances. | |
| 518 // ----------------------------------------------------------------------------- | |
| 519 void add_def_obj(const void* def, VALUE value); | |
| 520 VALUE get_def_obj(const void* def); | |
| 521 | |
| 522 // ----------------------------------------------------------------------------- | |
| 523 // Utilities. | |
| 524 // ----------------------------------------------------------------------------- | |
| 525 | |
| 526 void check_upb_status(const upb_status* status, const char* msg); | |
| 527 | |
| 528 #define CHECK_UPB(code, msg) do { \ | |
| 529 upb_status status = UPB_STATUS_INIT; \ | |
| 530 code; \ | |
| 531 check_upb_status(&status, msg); \ | |
| 532 } while (0) | |
| 533 | |
| 534 extern ID descriptor_instancevar_interned; | |
| 535 | |
| 536 #endif // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1322483002:
Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master