google-protobuf 4.31.1-java → 4.32.0.rc.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 801a14007485edfbc640324ff3b09c39c44d44c62ac7b1094bf527000ecc9f28
-  data.tar.gz: a45f822d4b2ec341122a231150988a467530ffae1220cf8379a5c1e19b946410
+  metadata.gz: 1409c414d01e032ec4b2a251fe55d77f10413d27f0a427fafa70f3f9d5080144
+  data.tar.gz: 5bc4ded6f387aa0558a4310be8feecf3d3ea63b2075ec1d28f10de225828c38b
 SHA512:
-  metadata.gz: 71a2a33c4e71717b5bb432f1b636a46e43bbaf634af2975a60f22e4705407b25f25349bee0127e2bc31fa7b3a8b51c93117d3c05476383cc692e1c359fe40b99
-  data.tar.gz: 25c7c642ab4829b748149b2bed60b65da20e1789e9ff74dfb03360b5e8c107211782bb9a21b70a2aa0f0497aa3c1943d202d8530c3d516035e599b0d159dce52
+  metadata.gz: 5f1d0ebba8102a2254c33e0f218bf8d97f4c1a01276f15fc5ebea3aab21945701810c9b01ab45754a82f748214ed22a92116b43f68a22f43c019c77e4a7b116b
+  data.tar.gz: fe6b2f548e0ec061a3f80c26b7430705ad8f38aca6fa8a806c8cc4fd5ed4389c22c910ced1ec20a4fa84fd204b6543ca03242cf61977eee61b5d9915be9d997e

data/ext/google/protobuf_c/message.c

@@ -420,11 +420,10 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
 }
 
 /*
- * call-seq:
- *     Message.method_missing(*args)
+ * ruby-doc: AbstractMessage
  *
- * Provides accessors and setters and methods to clear and check for presence of
- * message fields according to their field names.
+ * The {AbstractMessage} class is the parent class for all Protobuf messages,
+ * and is generated from C code.
  *
  * For any field whose name does not conflict with a built-in method, an
  * accessor is provided with the same name as the field, and a setter is
@@ -653,16 +652,12 @@ void Message_InitFromValue(upb_Message* msg, const upb_MessageDef* m, VALUE val,
 }
 
 /*
- * call-seq:
- *     Message.new(kwargs) => new_message
+ * ruby-doc: AbstractMessage#initialize
  *
  * Creates a new instance of the given message class. Keyword arguments may be
  * provided with keywords corresponding to field names.
  *
- * Note that no literal Message class exists. Only concrete classes per message
- * type exist, as provided by the #msgclass method on Descriptors after they
- * have been added to a pool. The method definitions described here on the
- * Message class are provided on each concrete message class.
+ * @param kwargs the list of field keys and values.
  */
 static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -684,10 +679,11 @@ static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.dup => new_message
+ * ruby-doc: AbstractMessage#dup
  *
  * Performs a shallow copy of this message and returns the new copy.
+ *
+ * @return [AbstractMessage]
  */
 static VALUE Message_dup(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -700,13 +696,15 @@ static VALUE Message_dup(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.==(other) => boolean
+ * ruby-doc: AbstractMessage#==
  *
  * Performs a deep comparison of this message with another. Messages are equal
  * if they have the same type and if each field is equal according to the :==
  * method's semantics (a more efficient comparison may actually be done if the
  * field is of a primitive type).
+ *
+ * @param other [AbstractMessage]
+ * @return [Boolean]
  */
 static VALUE Message_eq(VALUE _self, VALUE _other) {
   if (CLASS_OF(_self) != CLASS_OF(_other)) return Qfalse;
@@ -735,10 +733,11 @@ uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
 }
 
 /*
- * call-seq:
- *     Message.hash => hash_value
+ * ruby-doc: AbstractMessage#hash
  *
  * Returns a hash value that represents this message's field values.
+ *
+ * @return [Integer]
  */
 static VALUE Message_hash(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -749,12 +748,13 @@ static VALUE Message_hash(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.inspect => string
+ * ruby-doc: AbstractMessage#inspect
  *
  * Returns a human-readable string representing this message. It will be
  * formatted as "<MessageType: field1: value1, field2: value2, ...>". Each
  * field's value is represented according to its own #inspect method.
+ *
+ * @return [String]
  */
 static VALUE Message_inspect(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -830,10 +830,11 @@ VALUE Scalar_CreateHash(upb_MessageValue msgval, TypeInfo type_info) {
 }
 
 /*
- * call-seq:
- *     Message.to_h => {}
+ * ruby-doc: AbstractMessage#to_h
  *
  * Returns the message as a Ruby Hash object, with keys as symbols.
+ *
+ * @return [Hash]
  */
 static VALUE Message_to_h(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -841,12 +842,13 @@ static VALUE Message_to_h(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.frozen? => bool
+ * ruby-doc: AbstractMessage#frozen?
  *
  * Returns true if the message is frozen in either Ruby or the underlying
  * representation. Freezes the Ruby message object if it is not already frozen
  * in Ruby but it is frozen in the underlying representation.
+ *
+ * @return [Boolean]
  */
 VALUE Message_frozen(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -861,11 +863,12 @@ VALUE Message_frozen(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.freeze => self
+ * ruby-doc: AbstractMessage#freeze
  *
  * Freezes the message object. We have to intercept this so we can freeze the
  * underlying representation, not just the Ruby wrapper.
+ *
+ * @return [self]
  */
 VALUE Message_freeze(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -882,11 +885,13 @@ VALUE Message_freeze(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.[](index) => value
+ * ruby-doc: AbstractMessage#[]
  *
  * Accesses a field's value by field name. The provided field name should be a
  * string.
+ *
+ * @param index [Integer]
+ * @return [Object]
  */
 static VALUE Message_index(VALUE _self, VALUE field_name) {
   Message* self = ruby_to_Message(_self);
@@ -903,11 +908,14 @@ static VALUE Message_index(VALUE _self, VALUE field_name) {
 }
 
 /*
- * call-seq:
- *     Message.[]=(index, value)
+ * ruby-doc: AbstractMessage#[]=
  *
  * Sets a field's value by field name. The provided field name should be a
  * string.
+ *
+ * @param index [Integer]
+ * @param value [Object]
+ * @return [nil]
  */
 static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
   Message* self = ruby_to_Message(_self);
@@ -929,14 +937,16 @@ static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
 }
 
 /*
- * call-seq:
- *     MessageClass.decode(data, options) => message
+ * ruby-doc: AbstractMessage.decode
  *
  * Decodes the given data (as a string containing bytes in protocol buffers wire
  * format) under the interpretation given by this message class's definition
  * and returns a message object with the corresponding field values.
- * @param options [Hash] options for the decoder
- *  recursion_limit: set to maximum decoding depth for message (default is 64)
+ * @param data [String]
+ * @param options [Hash]
+ * @option recursion_limit [Integer] set to maximum decoding depth for message
+ * (default is 64)
+ * @return [AbstractMessage]
  */
 static VALUE Message_decode(int argc, VALUE* argv, VALUE klass) {
   VALUE data = argv[0];
@@ -989,16 +999,17 @@ VALUE Message_decode_bytes(int size, const char* bytes, int options,
 }
 
 /*
- * call-seq:
- *     MessageClass.decode_json(data, options = {}) => message
+ * ruby-doc: AbstractMessage.decode_json
  *
  * Decodes the given data (as a string containing bytes in protocol buffers wire
  * format) under the interpretration given by this message class's definition
  * and returns a message object with the corresponding field values.
  *
- *  @param options [Hash] options for the decoder
- *   ignore_unknown_fields: set true to ignore unknown fields (default is to
- *   raise an error)
+ * @param data [String]
+ * @param options [Hash]
+ * @option ignore_unknown_fields [Boolean] set true to ignore unknown fields
+ * (default is to raise an error)
+ * @return [AbstractMessage]
  */
 static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
   VALUE data = argv[0];
@@ -1057,13 +1068,16 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     MessageClass.encode(msg, options) => bytes
+ * ruby-doc: AbstractMessage.encode
  *
  * Encodes the given message object to its serialized form in protocol buffers
  * wire format.
- * @param options [Hash] options for the encoder
- *  recursion_limit: set to maximum encoding depth for message (default is 64)
+ *
+ * @param msg [AbstractMessage]
+ * @param options [Hash]
+ * @option recursion_limit [Integer] set to maximum encoding depth for message
+ * (default is 64)
+ * @return [String]
  */
 static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
   Message* msg = ruby_to_Message(argv[0]);
@@ -1110,14 +1124,17 @@ static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     MessageClass.encode_json(msg, options = {}) => json_string
+ * ruby-doc: AbstractMessage.encode_json
  *
  * Encodes the given message object into its serialized JSON representation.
- * @param options [Hash] options for the decoder
- *  preserve_proto_fieldnames: set true to use original fieldnames (default is
- * to camelCase) emit_defaults: set true to emit 0/false values (default is to
- * omit them)
+ *
+ * @param msg [AbstractMessage]
+ * @param options [Hash]
+ * @option preserve_proto_fieldnames [Boolean] set true to use original
+ * fieldnames (default is to camelCase)
+ * @option emit_defaults [Boolean] set true to emit 0/false values (default is
+ * to omit them)
+ * @return [String]
  */
 static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
   Message* msg = ruby_to_Message(argv[0]);
@@ -1185,11 +1202,12 @@ static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     Message.descriptor => descriptor
+ * ruby-doc: AbstractMessage.descriptor
  *
  * Class method that returns the Descriptor instance corresponding to this
  * message class's type.
+ *
+ * @return [Descriptor]
  */
 static VALUE Message_descriptor(VALUE klass) {
   return rb_ivar_get(klass, descriptor_instancevar_interned);
@@ -1212,12 +1230,26 @@ VALUE build_class_from_descriptor(VALUE descriptor) {
   return klass;
 }
 
+/* ruby-doc: Enum
+ *
+ * There isn't really a concrete `Enum` module generated by Protobuf. Instead,
+ * you can use this documentation as an indicator of methods that are defined on
+ * each `Enum` module that is generated. E.g. if you have:
+ *
+ *   enum my_enum_type
+ *
+ * in your Proto file and generate Ruby code, a module
+ * called `MyEnumType` will be generated with the following methods available.
+ */
+
 /*
- * call-seq:
- *     Enum.lookup(number) => name
+ * ruby-doc: Enum.lookup
  *
  * This module method, provided on each generated enum module, looks up an enum
  * value by number and returns its name as a Ruby symbol, or nil if not found.
+ *
+ * @param number [Integer]
+ * @return [String]
  */
 static VALUE enum_lookup(VALUE self, VALUE number) {
   int32_t num = NUM2INT(number);
@@ -1232,11 +1264,13 @@ static VALUE enum_lookup(VALUE self, VALUE number) {
 }
 
 /*
- * call-seq:
- *     Enum.resolve(name) => number
+ * ruby-doc: Enum.resolve
  *
  * This module method, provided on each generated enum module, looks up an enum
  * value by name (as a Ruby symbol) and returns its name, or nil if not found.
+ *
+ * @param name [String]
+ * @return [Integer]
  */
 static VALUE enum_resolve(VALUE self, VALUE sym) {
   const char* name = rb_id2name(SYM2ID(sym));
@@ -1251,11 +1285,13 @@ static VALUE enum_resolve(VALUE self, VALUE sym) {
 }
 
 /*
- * call-seq:
- *     Enum.descriptor
+ * ruby-doc: Enum.descriptor
  *
  * This module method, provided on each generated enum module, returns the
- * EnumDescriptor corresponding to this enum type.
+ * {EnumDescriptor} corresponding to this enum type.
+ *
+ * @return [EnumDescriptor]
+ *
  */
 static VALUE enum_descriptor(VALUE self) {
   return rb_ivar_get(self, descriptor_instancevar_interned);

data/ext/google/protobuf_c/protobuf.c

@@ -183,7 +183,7 @@ const rb_data_type_t Arena_type = {
 };
 
 static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
-                                size_t size) {
+                                size_t size, size_t *actual_size) {
   if (size == 0) {
     xfree(ptr);
     return NULL;

data/ext/google/protobuf_c/protobuf.h

@@ -97,6 +97,4 @@ void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen);
 
 #define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y))
 
-#define UPB_UNUSED(var) (void)var
-
 #endif  // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__