194ad621bb
For JSON encoding we provide a new option to decide at encode time whether to use camelCase or original proto field names: json = MapMessage.encode_json(m, :preserve_proto_fieldnames => true)
539 lines
21 KiB
C
539 lines
21 KiB
C
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2014 Google Inc. All rights reserved.
|
|
// https://developers.google.com/protocol-buffers/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#ifndef __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
|
|
#define __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
|
|
|
|
#include <ruby/ruby.h>
|
|
#include <ruby/vm.h>
|
|
#include <ruby/encoding.h>
|
|
|
|
#include "upb.h"
|
|
|
|
// Forward decls.
|
|
struct DescriptorPool;
|
|
struct Descriptor;
|
|
struct FieldDescriptor;
|
|
struct EnumDescriptor;
|
|
struct MessageLayout;
|
|
struct MessageField;
|
|
struct MessageHeader;
|
|
struct MessageBuilderContext;
|
|
struct EnumBuilderContext;
|
|
struct Builder;
|
|
|
|
typedef struct DescriptorPool DescriptorPool;
|
|
typedef struct Descriptor Descriptor;
|
|
typedef struct FieldDescriptor FieldDescriptor;
|
|
typedef struct OneofDescriptor OneofDescriptor;
|
|
typedef struct EnumDescriptor EnumDescriptor;
|
|
typedef struct MessageLayout MessageLayout;
|
|
typedef struct MessageField MessageField;
|
|
typedef struct MessageHeader MessageHeader;
|
|
typedef struct MessageBuilderContext MessageBuilderContext;
|
|
typedef struct OneofBuilderContext OneofBuilderContext;
|
|
typedef struct EnumBuilderContext EnumBuilderContext;
|
|
typedef struct Builder Builder;
|
|
|
|
/*
|
|
It can be a bit confusing how the C structs defined below and the Ruby
|
|
objects interact and hold references to each other. First, a few principles:
|
|
|
|
- Ruby's "TypedData" abstraction lets a Ruby VALUE hold a pointer to a C
|
|
struct (or arbitrary memory chunk), own it, and free it when collected.
|
|
Thus, each struct below will have a corresponding Ruby object
|
|
wrapping/owning it.
|
|
|
|
- To get back from an underlying upb {msg,enum}def to the Ruby object, we
|
|
keep a global hashmap, accessed by get_def_obj/add_def_obj below.
|
|
|
|
The in-memory structure is then something like:
|
|
|
|
Ruby | upb
|
|
|
|
|
DescriptorPool ------------|-----------> upb_symtab____________________
|
|
| | (message types) \
|
|
| v \
|
|
Descriptor ---------------|-----------> upb_msgdef (enum types)|
|
|
|--> msgclass | | ^ |
|
|
| (dynamically built) | | | (submsg fields) |
|
|
|--> MessageLayout | | | /
|
|
|--------------------------|> decoder method| | /
|
|
\--------------------------|> serialize | | /
|
|
| handlers v | /
|
|
FieldDescriptor -----------|-----------> upb_fielddef /
|
|
| | /
|
|
| v (enum fields) /
|
|
EnumDescriptor ------------|-----------> upb_enumdef <----------'
|
|
|
|
|
|
|
|
^ | \___/
|
|
`---------------|-----------------' (get_def_obj map)
|
|
*/
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Ruby class structure definitions.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
struct DescriptorPool {
|
|
upb_symtab* symtab;
|
|
};
|
|
|
|
struct Descriptor {
|
|
const upb_msgdef* msgdef;
|
|
MessageLayout* layout;
|
|
VALUE klass; // begins as nil
|
|
const upb_handlers* fill_handlers;
|
|
const upb_pbdecodermethod* fill_method;
|
|
const upb_json_parsermethod* json_fill_method;
|
|
const upb_handlers* pb_serialize_handlers;
|
|
const upb_handlers* json_serialize_handlers;
|
|
const upb_handlers* json_serialize_handlers_preserve;
|
|
// Handlers hold type class references for sub-message fields directly in some
|
|
// cases. We need to keep these rooted because they might otherwise be
|
|
// collected.
|
|
VALUE typeclass_references;
|
|
};
|
|
|
|
struct FieldDescriptor {
|
|
const upb_fielddef* fielddef;
|
|
};
|
|
|
|
struct OneofDescriptor {
|
|
const upb_oneofdef* oneofdef;
|
|
};
|
|
|
|
struct EnumDescriptor {
|
|
const upb_enumdef* enumdef;
|
|
VALUE module; // begins as nil
|
|
};
|
|
|
|
struct MessageBuilderContext {
|
|
VALUE descriptor;
|
|
VALUE builder;
|
|
};
|
|
|
|
struct OneofBuilderContext {
|
|
VALUE descriptor;
|
|
VALUE builder;
|
|
};
|
|
|
|
struct EnumBuilderContext {
|
|
VALUE enumdesc;
|
|
};
|
|
|
|
struct Builder {
|
|
VALUE pending_list;
|
|
upb_def** defs; // used only while finalizing
|
|
};
|
|
|
|
extern VALUE cDescriptorPool;
|
|
extern VALUE cDescriptor;
|
|
extern VALUE cFieldDescriptor;
|
|
extern VALUE cEnumDescriptor;
|
|
extern VALUE cMessageBuilderContext;
|
|
extern VALUE cOneofBuilderContext;
|
|
extern VALUE cEnumBuilderContext;
|
|
extern VALUE cBuilder;
|
|
|
|
extern VALUE cError;
|
|
extern VALUE cParseError;
|
|
|
|
// We forward-declare all of the Ruby method implementations here because we
|
|
// sometimes call the methods directly across .c files, rather than going
|
|
// through Ruby's method dispatching (e.g. during message parse). It's cleaner
|
|
// to keep the list of object methods together than to split them between
|
|
// static-in-file definitions and header declarations.
|
|
|
|
void DescriptorPool_mark(void* _self);
|
|
void DescriptorPool_free(void* _self);
|
|
VALUE DescriptorPool_alloc(VALUE klass);
|
|
void DescriptorPool_register(VALUE module);
|
|
DescriptorPool* ruby_to_DescriptorPool(VALUE value);
|
|
VALUE DescriptorPool_add(VALUE _self, VALUE def);
|
|
VALUE DescriptorPool_build(VALUE _self);
|
|
VALUE DescriptorPool_lookup(VALUE _self, VALUE name);
|
|
VALUE DescriptorPool_generated_pool(VALUE _self);
|
|
|
|
void Descriptor_mark(void* _self);
|
|
void Descriptor_free(void* _self);
|
|
VALUE Descriptor_alloc(VALUE klass);
|
|
void Descriptor_register(VALUE module);
|
|
Descriptor* ruby_to_Descriptor(VALUE value);
|
|
VALUE Descriptor_name(VALUE _self);
|
|
VALUE Descriptor_name_set(VALUE _self, VALUE str);
|
|
VALUE Descriptor_each(VALUE _self);
|
|
VALUE Descriptor_lookup(VALUE _self, VALUE name);
|
|
VALUE Descriptor_add_field(VALUE _self, VALUE obj);
|
|
VALUE Descriptor_add_oneof(VALUE _self, VALUE obj);
|
|
VALUE Descriptor_each_oneof(VALUE _self);
|
|
VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name);
|
|
VALUE Descriptor_msgclass(VALUE _self);
|
|
extern const rb_data_type_t _Descriptor_type;
|
|
|
|
void FieldDescriptor_mark(void* _self);
|
|
void FieldDescriptor_free(void* _self);
|
|
VALUE FieldDescriptor_alloc(VALUE klass);
|
|
void FieldDescriptor_register(VALUE module);
|
|
FieldDescriptor* ruby_to_FieldDescriptor(VALUE value);
|
|
VALUE FieldDescriptor_name(VALUE _self);
|
|
VALUE FieldDescriptor_name_set(VALUE _self, VALUE str);
|
|
VALUE FieldDescriptor_type(VALUE _self);
|
|
VALUE FieldDescriptor_type_set(VALUE _self, VALUE type);
|
|
VALUE FieldDescriptor_label(VALUE _self);
|
|
VALUE FieldDescriptor_label_set(VALUE _self, VALUE label);
|
|
VALUE FieldDescriptor_number(VALUE _self);
|
|
VALUE FieldDescriptor_number_set(VALUE _self, VALUE number);
|
|
VALUE FieldDescriptor_submsg_name(VALUE _self);
|
|
VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value);
|
|
VALUE FieldDescriptor_subtype(VALUE _self);
|
|
VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb);
|
|
VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value);
|
|
upb_fieldtype_t ruby_to_fieldtype(VALUE type);
|
|
VALUE fieldtype_to_ruby(upb_fieldtype_t type);
|
|
|
|
void OneofDescriptor_mark(void* _self);
|
|
void OneofDescriptor_free(void* _self);
|
|
VALUE OneofDescriptor_alloc(VALUE klass);
|
|
void OneofDescriptor_register(VALUE module);
|
|
OneofDescriptor* ruby_to_OneofDescriptor(VALUE value);
|
|
VALUE OneofDescriptor_name(VALUE _self);
|
|
VALUE OneofDescriptor_name_set(VALUE _self, VALUE value);
|
|
VALUE OneofDescriptor_add_field(VALUE _self, VALUE field);
|
|
VALUE OneofDescriptor_each(VALUE _self, VALUE field);
|
|
|
|
void EnumDescriptor_mark(void* _self);
|
|
void EnumDescriptor_free(void* _self);
|
|
VALUE EnumDescriptor_alloc(VALUE klass);
|
|
void EnumDescriptor_register(VALUE module);
|
|
EnumDescriptor* ruby_to_EnumDescriptor(VALUE value);
|
|
VALUE EnumDescriptor_name(VALUE _self);
|
|
VALUE EnumDescriptor_name_set(VALUE _self, VALUE str);
|
|
VALUE EnumDescriptor_add_value(VALUE _self, VALUE name, VALUE number);
|
|
VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name);
|
|
VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number);
|
|
VALUE EnumDescriptor_each(VALUE _self);
|
|
VALUE EnumDescriptor_enummodule(VALUE _self);
|
|
extern const rb_data_type_t _EnumDescriptor_type;
|
|
|
|
void MessageBuilderContext_mark(void* _self);
|
|
void MessageBuilderContext_free(void* _self);
|
|
VALUE MessageBuilderContext_alloc(VALUE klass);
|
|
void MessageBuilderContext_register(VALUE module);
|
|
MessageBuilderContext* ruby_to_MessageBuilderContext(VALUE value);
|
|
VALUE MessageBuilderContext_initialize(VALUE _self,
|
|
VALUE descriptor,
|
|
VALUE builder);
|
|
VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self);
|
|
VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self);
|
|
VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self);
|
|
VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self);
|
|
VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name);
|
|
|
|
void OneofBuilderContext_mark(void* _self);
|
|
void OneofBuilderContext_free(void* _self);
|
|
VALUE OneofBuilderContext_alloc(VALUE klass);
|
|
void OneofBuilderContext_register(VALUE module);
|
|
OneofBuilderContext* ruby_to_OneofBuilderContext(VALUE value);
|
|
VALUE OneofBuilderContext_initialize(VALUE _self,
|
|
VALUE descriptor,
|
|
VALUE builder);
|
|
VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self);
|
|
|
|
void EnumBuilderContext_mark(void* _self);
|
|
void EnumBuilderContext_free(void* _self);
|
|
VALUE EnumBuilderContext_alloc(VALUE klass);
|
|
void EnumBuilderContext_register(VALUE module);
|
|
EnumBuilderContext* ruby_to_EnumBuilderContext(VALUE value);
|
|
VALUE EnumBuilderContext_initialize(VALUE _self, VALUE enumdesc);
|
|
VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number);
|
|
|
|
void Builder_mark(void* _self);
|
|
void Builder_free(void* _self);
|
|
VALUE Builder_alloc(VALUE klass);
|
|
void Builder_register(VALUE module);
|
|
Builder* ruby_to_Builder(VALUE value);
|
|
VALUE Builder_add_message(VALUE _self, VALUE name);
|
|
VALUE Builder_add_enum(VALUE _self, VALUE name);
|
|
VALUE Builder_finalize_to_pool(VALUE _self, VALUE pool_rb);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Native slot storage abstraction.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#define NATIVE_SLOT_MAX_SIZE sizeof(uint64_t)
|
|
|
|
size_t native_slot_size(upb_fieldtype_t type);
|
|
void native_slot_set(upb_fieldtype_t type,
|
|
VALUE type_class,
|
|
void* memory,
|
|
VALUE value);
|
|
// Atomically (with respect to Ruby VM calls) either update the value and set a
|
|
// oneof case, or do neither. If |case_memory| is null, then no case value is
|
|
// set.
|
|
void native_slot_set_value_and_case(upb_fieldtype_t type,
|
|
VALUE type_class,
|
|
void* memory,
|
|
VALUE value,
|
|
uint32_t* case_memory,
|
|
uint32_t case_number);
|
|
VALUE native_slot_get(upb_fieldtype_t type,
|
|
VALUE type_class,
|
|
const void* memory);
|
|
void native_slot_init(upb_fieldtype_t type, void* memory);
|
|
void native_slot_mark(upb_fieldtype_t type, void* memory);
|
|
void native_slot_dup(upb_fieldtype_t type, void* to, void* from);
|
|
void native_slot_deep_copy(upb_fieldtype_t type, void* to, void* from);
|
|
bool native_slot_eq(upb_fieldtype_t type, void* mem1, void* mem2);
|
|
|
|
void native_slot_validate_string_encoding(upb_fieldtype_t type, VALUE value);
|
|
void native_slot_check_int_range_precision(upb_fieldtype_t type, VALUE value);
|
|
|
|
extern rb_encoding* kRubyStringUtf8Encoding;
|
|
extern rb_encoding* kRubyStringASCIIEncoding;
|
|
extern rb_encoding* kRubyString8bitEncoding;
|
|
|
|
VALUE field_type_class(const upb_fielddef* field);
|
|
|
|
#define MAP_KEY_FIELD 1
|
|
#define MAP_VALUE_FIELD 2
|
|
|
|
// Oneof case slot value to indicate that no oneof case is set. The value `0` is
|
|
// safe because field numbers are used as case identifiers, and no field can
|
|
// have a number of 0.
|
|
#define ONEOF_CASE_NONE 0
|
|
|
|
// These operate on a map field (i.e., a repeated field of submessages whose
|
|
// submessage type is a map-entry msgdef).
|
|
bool is_map_field(const upb_fielddef* field);
|
|
const upb_fielddef* map_field_key(const upb_fielddef* field);
|
|
const upb_fielddef* map_field_value(const upb_fielddef* field);
|
|
|
|
// These operate on a map-entry msgdef.
|
|
const upb_fielddef* map_entry_key(const upb_msgdef* msgdef);
|
|
const upb_fielddef* map_entry_value(const upb_msgdef* msgdef);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Repeated field container type.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
typedef struct {
|
|
upb_fieldtype_t field_type;
|
|
VALUE field_type_class;
|
|
void* elements;
|
|
int size;
|
|
int capacity;
|
|
} RepeatedField;
|
|
|
|
void RepeatedField_mark(void* self);
|
|
void RepeatedField_free(void* self);
|
|
VALUE RepeatedField_alloc(VALUE klass);
|
|
VALUE RepeatedField_init(int argc, VALUE* argv, VALUE self);
|
|
void RepeatedField_register(VALUE module);
|
|
|
|
extern const rb_data_type_t RepeatedField_type;
|
|
extern VALUE cRepeatedField;
|
|
|
|
RepeatedField* ruby_to_RepeatedField(VALUE value);
|
|
|
|
VALUE RepeatedField_each(VALUE _self);
|
|
VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self);
|
|
void* RepeatedField_index_native(VALUE _self, int index);
|
|
VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val);
|
|
void RepeatedField_reserve(RepeatedField* self, int new_size);
|
|
VALUE RepeatedField_push(VALUE _self, VALUE val);
|
|
void RepeatedField_push_native(VALUE _self, void* data);
|
|
VALUE RepeatedField_pop_one(VALUE _self);
|
|
VALUE RepeatedField_insert(int argc, VALUE* argv, VALUE _self);
|
|
VALUE RepeatedField_replace(VALUE _self, VALUE list);
|
|
VALUE RepeatedField_clear(VALUE _self);
|
|
VALUE RepeatedField_length(VALUE _self);
|
|
VALUE RepeatedField_dup(VALUE _self);
|
|
VALUE RepeatedField_deep_copy(VALUE _self);
|
|
VALUE RepeatedField_to_ary(VALUE _self);
|
|
VALUE RepeatedField_eq(VALUE _self, VALUE _other);
|
|
VALUE RepeatedField_hash(VALUE _self);
|
|
VALUE RepeatedField_inspect(VALUE _self);
|
|
VALUE RepeatedField_plus(VALUE _self, VALUE list);
|
|
|
|
// Defined in repeated_field.c; also used by Map.
|
|
void validate_type_class(upb_fieldtype_t type, VALUE klass);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Map container type.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
typedef struct {
|
|
upb_fieldtype_t key_type;
|
|
upb_fieldtype_t value_type;
|
|
VALUE value_type_class;
|
|
upb_strtable table;
|
|
} Map;
|
|
|
|
void Map_mark(void* self);
|
|
void Map_free(void* self);
|
|
VALUE Map_alloc(VALUE klass);
|
|
VALUE Map_init(int argc, VALUE* argv, VALUE self);
|
|
void Map_register(VALUE module);
|
|
|
|
extern const rb_data_type_t Map_type;
|
|
extern VALUE cMap;
|
|
|
|
Map* ruby_to_Map(VALUE value);
|
|
|
|
VALUE Map_each(VALUE _self);
|
|
VALUE Map_keys(VALUE _self);
|
|
VALUE Map_values(VALUE _self);
|
|
VALUE Map_index(VALUE _self, VALUE key);
|
|
VALUE Map_index_set(VALUE _self, VALUE key, VALUE value);
|
|
VALUE Map_has_key(VALUE _self, VALUE key);
|
|
VALUE Map_delete(VALUE _self, VALUE key);
|
|
VALUE Map_clear(VALUE _self);
|
|
VALUE Map_length(VALUE _self);
|
|
VALUE Map_dup(VALUE _self);
|
|
VALUE Map_deep_copy(VALUE _self);
|
|
VALUE Map_eq(VALUE _self, VALUE _other);
|
|
VALUE Map_hash(VALUE _self);
|
|
VALUE Map_inspect(VALUE _self);
|
|
VALUE Map_merge(VALUE _self, VALUE hashmap);
|
|
VALUE Map_merge_into_self(VALUE _self, VALUE hashmap);
|
|
|
|
typedef struct {
|
|
Map* self;
|
|
upb_strtable_iter it;
|
|
} Map_iter;
|
|
|
|
void Map_begin(VALUE _self, Map_iter* iter);
|
|
void Map_next(Map_iter* iter);
|
|
bool Map_done(Map_iter* iter);
|
|
VALUE Map_iter_key(Map_iter* iter);
|
|
VALUE Map_iter_value(Map_iter* iter);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Message layout / storage.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#define MESSAGE_FIELD_NO_CASE ((size_t)-1)
|
|
|
|
struct MessageField {
|
|
size_t offset;
|
|
size_t case_offset; // for oneofs, a uint32. Else, MESSAGE_FIELD_NO_CASE.
|
|
};
|
|
|
|
struct MessageLayout {
|
|
const upb_msgdef* msgdef;
|
|
MessageField* fields;
|
|
size_t size;
|
|
};
|
|
|
|
MessageLayout* create_layout(const upb_msgdef* msgdef);
|
|
void free_layout(MessageLayout* layout);
|
|
VALUE layout_get(MessageLayout* layout,
|
|
const void* storage,
|
|
const upb_fielddef* field);
|
|
void layout_set(MessageLayout* layout,
|
|
void* storage,
|
|
const upb_fielddef* field,
|
|
VALUE val);
|
|
void layout_init(MessageLayout* layout, void* storage);
|
|
void layout_mark(MessageLayout* layout, void* storage);
|
|
void layout_dup(MessageLayout* layout, void* to, void* from);
|
|
void layout_deep_copy(MessageLayout* layout, void* to, void* from);
|
|
VALUE layout_eq(MessageLayout* layout, void* msg1, void* msg2);
|
|
VALUE layout_hash(MessageLayout* layout, void* storage);
|
|
VALUE layout_inspect(MessageLayout* layout, void* storage);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Message class creation.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
struct MessageHeader {
|
|
Descriptor* descriptor; // kept alive by self.class.descriptor reference.
|
|
// Data comes after this.
|
|
};
|
|
|
|
extern rb_data_type_t Message_type;
|
|
|
|
VALUE build_class_from_descriptor(Descriptor* descriptor);
|
|
void* Message_data(void* msg);
|
|
void Message_mark(void* self);
|
|
void Message_free(void* self);
|
|
VALUE Message_alloc(VALUE klass);
|
|
VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self);
|
|
VALUE Message_initialize(int argc, VALUE* argv, VALUE _self);
|
|
VALUE Message_dup(VALUE _self);
|
|
VALUE Message_deep_copy(VALUE _self);
|
|
VALUE Message_eq(VALUE _self, VALUE _other);
|
|
VALUE Message_hash(VALUE _self);
|
|
VALUE Message_inspect(VALUE _self);
|
|
VALUE Message_index(VALUE _self, VALUE field_name);
|
|
VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value);
|
|
VALUE Message_descriptor(VALUE klass);
|
|
VALUE Message_decode(VALUE klass, VALUE data);
|
|
VALUE Message_encode(VALUE klass, VALUE msg_rb);
|
|
VALUE Message_decode_json(VALUE klass, VALUE data);
|
|
VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass);
|
|
|
|
VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj);
|
|
|
|
VALUE build_module_from_enumdesc(EnumDescriptor* enumdef);
|
|
VALUE enum_lookup(VALUE self, VALUE number);
|
|
VALUE enum_resolve(VALUE self, VALUE sym);
|
|
|
|
const upb_pbdecodermethod *new_fillmsg_decodermethod(
|
|
Descriptor* descriptor, const void *owner);
|
|
|
|
// Maximum depth allowed during encoding, to avoid stack overflows due to
|
|
// cycles.
|
|
#define ENCODE_MAX_NESTING 63
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Global map from upb {msg,enum}defs to wrapper Descriptor/EnumDescriptor
|
|
// instances.
|
|
// -----------------------------------------------------------------------------
|
|
void add_def_obj(const void* def, VALUE value);
|
|
VALUE get_def_obj(const void* def);
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Utilities.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void check_upb_status(const upb_status* status, const char* msg);
|
|
|
|
#define CHECK_UPB(code, msg) do { \
|
|
upb_status status = UPB_STATUS_INIT; \
|
|
code; \
|
|
check_upb_status(&status, msg); \
|
|
} while (0)
|
|
|
|
extern ID descriptor_instancevar_interned;
|
|
|
|
#endif // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
|