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 |