google-protobuf 3.19.6-x86-linux → 3.20.0.rc.1-x86-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d39afc53296e3a0837a7c73c4753b53b15e3d67d25d512523597de38c24dae0
-  data.tar.gz: 3e7bb9fcb15f2b3373b7a56caadef4d4c12471f2cbe7e54835db2b5148d75268
+  metadata.gz: 783a0db3f6474937675325eef150420039be17a0db4653047307bc4a3f28d857
+  data.tar.gz: aca98c23e812a5fa04cadad3950cea3349da999fb7f8872e0decfc13d87984d6
 SHA512:
-  metadata.gz: 4f003833417837bca95a679323725157063155bb57138b7461be734146857f5478e18d4b16cb0c270988966ef842d843384870444ee2855534c104568122bde6
-  data.tar.gz: aed2b3d5ae52683556309e61e5d0ee2ab75319fc775ae54dc805c4e63f9084db7c91dc73a498b092a212c8b822f0348a473efa81befef2b53fc0a2b3e884e303
+  metadata.gz: 8eff3b821754bca9e2bf69a77c4d30630f281094ce8773e71256fdaa64c271242dae0e9268d19a5bdd10de8c5103b22b879b08501c4eafe5b40d879c6e36fcca
+  data.tar.gz: 2d495a91f7770d6a14e26a853cedfa49146e7723a4eb6a1819ced92fd601943dc7921dbb73ccf95e68c994732812a86a8082d07c5ad85259c61b27a891d12a45

data/ext/google/protobuf_c/convert.c

@@ -31,7 +31,7 @@
 // -----------------------------------------------------------------------------
 // Ruby <-> upb data conversion functions.
 //
-// This file Also contains a few other assorted algorithms on upb_msgval.
+// This file Also contains a few other assorted algorithms on upb_MessageValue.
 //
 // None of the algorithms in this file require any access to the internal
 // representation of Ruby or upb objects.
@@ -42,10 +42,10 @@
 #include "message.h"
 #include "protobuf.h"
 
-static upb_strview Convert_StringData(VALUE str, upb_arena *arena) {
-  upb_strview ret;
+static upb_StringView Convert_StringData(VALUE str, upb_Arena* arena) {
+  upb_StringView ret;
   if (arena) {
-    char *ptr = upb_arena_malloc(arena, RSTRING_LEN(str));
+    char* ptr = upb_Arena_Malloc(arena, RSTRING_LEN(str));
     memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
     ret.data = ptr;
   } else {
@@ -57,13 +57,11 @@ static upb_strview Convert_StringData(VALUE str, upb_arena *arena) {
 }
 
 static bool is_ruby_num(VALUE value) {
-  return (TYPE(value) == T_FLOAT ||
-          TYPE(value) == T_FIXNUM ||
+  return (TYPE(value) == T_FLOAT || TYPE(value) == T_FIXNUM ||
           TYPE(value) == T_BIGNUM);
 }
 
-static void Convert_CheckInt(const char* name, upb_fieldtype_t type,
-                             VALUE val) {
+static void Convert_CheckInt(const char* name, upb_CType type, VALUE val) {
   if (!is_ruby_num(val)) {
     rb_raise(cTypeError,
              "Expected number type for integral field '%s' (given %s).", name,
@@ -82,7 +80,7 @@ static void Convert_CheckInt(const char* name, upb_fieldtype_t type,
                name, rb_class2name(CLASS_OF(val)));
     }
   }
-  if (type == UPB_TYPE_UINT32 || type == UPB_TYPE_UINT64) {
+  if (type == kUpb_CType_UInt32 || type == kUpb_CType_UInt64) {
     if (NUM2DBL(val) < 0) {
       rb_raise(
           rb_eRangeError,
@@ -93,26 +91,31 @@ static void Convert_CheckInt(const char* name, upb_fieldtype_t type,
 }
 
 static int32_t Convert_ToEnum(VALUE value, const char* name,
-                              const upb_enumdef* e) {
+                              const upb_EnumDef* e) {
   int32_t val;
 
   switch (TYPE(value)) {
     case T_FLOAT:
     case T_FIXNUM:
     case T_BIGNUM:
-      Convert_CheckInt(name, UPB_TYPE_INT32, value);
+      Convert_CheckInt(name, kUpb_CType_Int32, value);
       val = NUM2INT(value);
       break;
-    case T_STRING:
-      if (!upb_enumdef_ntoi(e, RSTRING_PTR(value), RSTRING_LEN(value), &val)) {
-        goto unknownval;
-      }
+    case T_STRING: {
+      const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNameWithSize(
+          e, RSTRING_PTR(value), RSTRING_LEN(value));
+      if (!ev) goto unknownval;
+      val = upb_EnumValueDef_Number(ev);
       break;
-    case T_SYMBOL:
-      if (!upb_enumdef_ntoiz(e, rb_id2name(SYM2ID(value)), &val)) {
+    }
+    case T_SYMBOL: {
+      const upb_EnumValueDef* ev =
+          upb_EnumDef_FindValueByName(e, rb_id2name(SYM2ID(value)));
+      if (!ev)
         goto unknownval;
-      }
+      val = upb_EnumValueDef_Number(ev);
       break;
+    }
     default:
       rb_raise(cTypeError,
                "Expected number or symbol type for enum field '%s'.", name);
@@ -124,47 +127,52 @@ unknownval:
   rb_raise(rb_eRangeError, "Unknown symbol value for enum field '%s'.", name);
 }
 
-upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
-                             upb_arena* arena) {
-  upb_msgval ret;
+upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
+                                   TypeInfo type_info, upb_Arena* arena) {
+  upb_MessageValue ret;
 
   switch (type_info.type) {
-    case UPB_TYPE_FLOAT:
+    case kUpb_CType_Float:
       if (!is_ruby_num(value)) {
-        rb_raise(cTypeError, "Expected number type for float field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+        rb_raise(cTypeError,
+                 "Expected number type for float field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
       ret.float_val = NUM2DBL(value);
       break;
-    case UPB_TYPE_DOUBLE:
+    case kUpb_CType_Double:
       if (!is_ruby_num(value)) {
-        rb_raise(cTypeError, "Expected number type for double field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+        rb_raise(cTypeError,
+                 "Expected number type for double field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
       ret.double_val = NUM2DBL(value);
       break;
-    case UPB_TYPE_BOOL: {
+    case kUpb_CType_Bool: {
       if (value == Qtrue) {
         ret.bool_val = 1;
       } else if (value == Qfalse) {
         ret.bool_val = 0;
       } else {
-        rb_raise(cTypeError, "Invalid argument for boolean field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+        rb_raise(cTypeError,
+                 "Invalid argument for boolean field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
       break;
     }
-    case UPB_TYPE_STRING: {
+    case kUpb_CType_String: {
       VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
-      if (CLASS_OF(value) == rb_cSymbol) {
+      if (rb_obj_class(value) == rb_cSymbol) {
         value = rb_funcall(value, rb_intern("to_s"), 0);
-      } else if (CLASS_OF(value) != rb_cString) {
-        rb_raise(cTypeError, "Invalid argument for string field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+      } else if (rb_obj_class(value) != rb_cString) {
+        rb_raise(cTypeError,
+                 "Invalid argument for string field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
 
       if (rb_obj_encoding(value) != utf8) {
-        // Note: this will not duplicate underlying string data unless necessary.
+        // Note: this will not duplicate underlying string data unless
+        // necessary.
         value = rb_str_encode(value, utf8, 0, Qnil);
 
         if (rb_enc_str_coderange(value) == ENC_CODERANGE_BROKEN) {
@@ -175,15 +183,17 @@ upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
       ret.str_val = Convert_StringData(value, arena);
       break;
     }
-    case UPB_TYPE_BYTES: {
+    case kUpb_CType_Bytes: {
       VALUE bytes = rb_enc_from_encoding(rb_ascii8bit_encoding());
-      if (CLASS_OF(value) != rb_cString) {
-        rb_raise(cTypeError, "Invalid argument for bytes field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+      if (rb_obj_class(value) != rb_cString) {
+        rb_raise(cTypeError,
+                 "Invalid argument for bytes field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
 
       if (rb_obj_encoding(value) != bytes) {
-        // Note: this will not duplicate underlying string data unless necessary.
+        // Note: this will not duplicate underlying string data unless
+        // necessary.
         // TODO(haberman): is this really necessary to get raw bytes?
         value = rb_str_encode(value, bytes, 0, Qnil);
       }
@@ -191,33 +201,33 @@ upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
       ret.str_val = Convert_StringData(value, arena);
       break;
     }
-    case UPB_TYPE_MESSAGE:
+    case kUpb_CType_Message:
       ret.msg_val =
           Message_GetUpbMessage(value, type_info.def.msgdef, name, arena);
       break;
-    case UPB_TYPE_ENUM:
+    case kUpb_CType_Enum:
       ret.int32_val = Convert_ToEnum(value, name, type_info.def.enumdef);
       break;
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_UINT64:
+    case kUpb_CType_Int32:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_UInt64:
       Convert_CheckInt(name, type_info.type, value);
       switch (type_info.type) {
-      case UPB_TYPE_INT32:
-        ret.int32_val = NUM2INT(value);
-        break;
-      case UPB_TYPE_INT64:
-        ret.int64_val = NUM2LL(value);
-        break;
-      case UPB_TYPE_UINT32:
-        ret.uint32_val = NUM2UINT(value);
-        break;
-      case UPB_TYPE_UINT64:
-        ret.uint64_val = NUM2ULL(value);
-        break;
-      default:
-        break;
+        case kUpb_CType_Int32:
+          ret.int32_val = NUM2INT(value);
+          break;
+        case kUpb_CType_Int64:
+          ret.int64_val = NUM2LL(value);
+          break;
+        case kUpb_CType_UInt32:
+          ret.uint32_val = NUM2UINT(value);
+          break;
+        case kUpb_CType_UInt64:
+          ret.uint64_val = NUM2ULL(value);
+          break;
+        default:
+          break;
       }
       break;
     default:
@@ -227,45 +237,46 @@ upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
   return ret;
 }
 
-VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena) {
+VALUE Convert_UpbToRuby(upb_MessageValue upb_val, TypeInfo type_info,
+                        VALUE arena) {
   switch (type_info.type) {
-    case UPB_TYPE_FLOAT:
+    case kUpb_CType_Float:
       return DBL2NUM(upb_val.float_val);
-    case UPB_TYPE_DOUBLE:
+    case kUpb_CType_Double:
       return DBL2NUM(upb_val.double_val);
-    case UPB_TYPE_BOOL:
+    case kUpb_CType_Bool:
       return upb_val.bool_val ? Qtrue : Qfalse;
-    case UPB_TYPE_INT32:
+    case kUpb_CType_Int32:
       return INT2NUM(upb_val.int32_val);
-    case UPB_TYPE_INT64:
+    case kUpb_CType_Int64:
       return LL2NUM(upb_val.int64_val);
-    case UPB_TYPE_UINT32:
+    case kUpb_CType_UInt32:
       return UINT2NUM(upb_val.uint32_val);
-    case UPB_TYPE_UINT64:
+    case kUpb_CType_UInt64:
       return ULL2NUM(upb_val.int64_val);
-    case UPB_TYPE_ENUM: {
-      const char* name =
-          upb_enumdef_iton(type_info.def.enumdef, upb_val.int32_val);
-      if (name) {
-        return ID2SYM(rb_intern(name));
+    case kUpb_CType_Enum: {
+      const upb_EnumValueDef *ev = upb_EnumDef_FindValueByNumber(
+          type_info.def.enumdef, upb_val.int32_val);
+      if (ev) {
+        return ID2SYM(rb_intern(upb_EnumValueDef_Name(ev)));
       } else {
         return INT2NUM(upb_val.int32_val);
       }
     }
-    case UPB_TYPE_STRING: {
+    case kUpb_CType_String: {
       VALUE str_rb = rb_str_new(upb_val.str_val.data, upb_val.str_val.size);
       rb_enc_associate(str_rb, rb_utf8_encoding());
       rb_obj_freeze(str_rb);
       return str_rb;
     }
-    case UPB_TYPE_BYTES: {
+    case kUpb_CType_Bytes: {
       VALUE str_rb = rb_str_new(upb_val.str_val.data, upb_val.str_val.size);
       rb_enc_associate(str_rb, rb_ascii8bit_encoding());
       rb_obj_freeze(str_rb);
       return str_rb;
     }
-    case UPB_TYPE_MESSAGE:
-      return Message_GetRubyWrapper((upb_msg*)upb_val.msg_val,
+    case kUpb_CType_Message:
+      return Message_GetRubyWrapper((upb_Message*)upb_val.msg_val,
                                     type_info.def.msgdef, arena);
     default:
       rb_raise(rb_eRuntimeError, "Convert_UpbToRuby(): Unexpected type %d",
@@ -273,24 +284,24 @@ VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena) {
   }
 }
 
-upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
-                           upb_arena* arena) {
-  upb_msgval new_msgval;
+upb_MessageValue Msgval_DeepCopy(upb_MessageValue msgval, TypeInfo type_info,
+                                 upb_Arena* arena) {
+  upb_MessageValue new_msgval;
 
   switch (type_info.type) {
     default:
       memcpy(&new_msgval, &msgval, sizeof(msgval));
       break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES: {
+    case kUpb_CType_String:
+    case kUpb_CType_Bytes: {
       size_t n = msgval.str_val.size;
-      char *mem = upb_arena_malloc(arena, n);
+      char* mem = upb_Arena_Malloc(arena, n);
       new_msgval.str_val.data = mem;
       new_msgval.str_val.size = n;
       memcpy(mem, msgval.str_val.data, n);
       break;
     }
-    case UPB_TYPE_MESSAGE:
+    case kUpb_CType_Message:
       new_msgval.msg_val =
           Message_deep_copy(msgval.msg_val, type_info.def.msgdef, arena);
       break;
@@ -299,48 +310,50 @@ upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
   return new_msgval;
 }
 
-bool Msgval_IsEqual(upb_msgval val1, upb_msgval val2, TypeInfo type_info) {
+bool Msgval_IsEqual(upb_MessageValue val1, upb_MessageValue val2,
+                    TypeInfo type_info) {
   switch (type_info.type) {
-    case UPB_TYPE_BOOL:
+    case kUpb_CType_Bool:
       return memcmp(&val1, &val2, 1) == 0;
-    case UPB_TYPE_FLOAT:
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_ENUM:
+    case kUpb_CType_Float:
+    case kUpb_CType_Int32:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_Enum:
       return memcmp(&val1, &val2, 4) == 0;
-    case UPB_TYPE_DOUBLE:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT64:
+    case kUpb_CType_Double:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt64:
       return memcmp(&val1, &val2, 8) == 0;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
+    case kUpb_CType_String:
+    case kUpb_CType_Bytes:
       return val1.str_val.size == val2.str_val.size &&
-             memcmp(val1.str_val.data, val2.str_val.data,
-                    val1.str_val.size) == 0;
-    case UPB_TYPE_MESSAGE:
+             memcmp(val1.str_val.data, val2.str_val.data, val1.str_val.size) ==
+                 0;
+    case kUpb_CType_Message:
       return Message_Equal(val1.msg_val, val2.msg_val, type_info.def.msgdef);
     default:
       rb_raise(rb_eRuntimeError, "Internal error, unexpected type");
   }
 }
 
-uint64_t Msgval_GetHash(upb_msgval val, TypeInfo type_info, uint64_t seed) {
+uint64_t Msgval_GetHash(upb_MessageValue val, TypeInfo type_info,
+                        uint64_t seed) {
   switch (type_info.type) {
-    case UPB_TYPE_BOOL:
+    case kUpb_CType_Bool:
       return Wyhash(&val, 1, seed, kWyhashSalt);
-    case UPB_TYPE_FLOAT:
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_ENUM:
+    case kUpb_CType_Float:
+    case kUpb_CType_Int32:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_Enum:
       return Wyhash(&val, 4, seed, kWyhashSalt);
-    case UPB_TYPE_DOUBLE:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT64:
+    case kUpb_CType_Double:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt64:
       return Wyhash(&val, 8, seed, kWyhashSalt);
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
+    case kUpb_CType_String:
+    case kUpb_CType_Bytes:
       return Wyhash(val.str_val.data, val.str_val.size, seed, kWyhashSalt);
-    case UPB_TYPE_MESSAGE:
+    case kUpb_CType_Message:
       return Message_Hash(val.msg_val, type_info.def.msgdef, seed);
     default:
       rb_raise(rb_eRuntimeError, "Internal error, unexpected type");

data/ext/google/protobuf_c/convert.h

@@ -36,7 +36,7 @@
 #include "protobuf.h"
 #include "ruby-upb.h"
 
-// Converts |ruby_val| to a upb_msgval according to |type_info|.
+// Converts |ruby_val| to a upb_MessageValue according to |type_info|.
 //
 // The |arena| parameter indicates the lifetime of the container where this
 // value will be assigned. It is used as follows:
@@ -47,8 +47,8 @@
 // - If type is message and the Ruby value is a message instance, we will fuse
 //   the message's arena into |arena|, to ensure that this message outlives the
 //   container.
-upb_msgval Convert_RubyToUpb(VALUE ruby_val, const char *name,
-                             TypeInfo type_info, upb_arena *arena);
+upb_MessageValue Convert_RubyToUpb(VALUE ruby_val, const char *name,
+                                   TypeInfo type_info, upb_Arena *arena);
 
 // Converts |upb_val| to a Ruby VALUE according to |type_info|. This may involve
 // creating a Ruby wrapper object.
@@ -56,17 +56,20 @@ upb_msgval Convert_RubyToUpb(VALUE ruby_val, const char *name,
 // The |arena| parameter indicates the arena that owns the lifetime of
 // |upb_val|. Any Ruby wrapper object that is created will reference |arena|
 // and ensure it outlives the wrapper.
-VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena);
+VALUE Convert_UpbToRuby(upb_MessageValue upb_val, TypeInfo type_info,
+                        VALUE arena);
 
 // Creates a deep copy of |msgval| in |arena|.
-upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
-                           upb_arena *arena);
+upb_MessageValue Msgval_DeepCopy(upb_MessageValue msgval, TypeInfo type_info,
+                                 upb_Arena *arena);
 
 // Returns true if |val1| and |val2| are equal. Their type is given by
 // |type_info|.
-bool Msgval_IsEqual(upb_msgval val1, upb_msgval val2, TypeInfo type_info);
+bool Msgval_IsEqual(upb_MessageValue val1, upb_MessageValue val2,
+                    TypeInfo type_info);
 
-// Returns a hash value for the given upb_msgval.
-uint64_t Msgval_GetHash(upb_msgval val, TypeInfo type_info, uint64_t seed);
+// Returns a hash value for the given upb_MessageValue.
+uint64_t Msgval_GetHash(upb_MessageValue val, TypeInfo type_info,
+                        uint64_t seed);
 
 #endif  // RUBY_PROTOBUF_CONVERT_H_