google-protobuf 3.7.0 → 3.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccf067952a9422bea3dc504041dd23154129f98f88edf9e67e67d7cdbb6ce23c
-  data.tar.gz: bd608b44e34348a66d1040480ad5a8e61664649c8b2158b38eb006e7662f993e
+  metadata.gz: 92bce6793f49890e0a5bf68cc233de1e6fea67d72f3ca7f335bee1bcb81061a3
+  data.tar.gz: '008e84cf532d86eb4ee6bb4a913be6d75fdffd18190759acf57ef0133e33989b'
 SHA512:
-  metadata.gz: 0711aff149212f90045fece5a507918cd1fb5d61abaa0556928c21fc69e7fe968e55d26c0123cba986005d5e28f79c655bfff02e02723d42b36d71f37a27ff13
-  data.tar.gz: 2077de0e04653c161e5389ab0e450bcd63dcdb054a62dd9cb33a16df1e755a3cec82eca57190bd93a45774b66feb6faf457c1fe5b0dbeadac9f3bdaddc4cea82
+  metadata.gz: 7869abdbcc35d74152ed52fae04a763bd866a8b04cd2eb212f07ba37cf83bb92ac2fdaa4a06d4aa9dcf55c6ac6d13e0ecb0be3fc724947f5233a84e12180263d
+  data.tar.gz: 1d735c91494688d289c57852f7d7b4e015394851bad5fa7ddaf4ba3f5f6dd0395fd8b549c0bf5106ad370a7d324b876b66f3fe94fad8f0d4d2945d3f68d3aaed

data/ext/google/protobuf_c/convert.c

@@ -0,0 +1,349 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 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.
+
+// -----------------------------------------------------------------------------
+// Ruby <-> upb data conversion functions.
+//
+// This file Also contains a few other assorted algorithms on upb_msgval.
+//
+// None of the algorithms in this file require any access to the internal
+// representation of Ruby or upb objects.
+// -----------------------------------------------------------------------------
+
+#include "convert.h"
+
+#include "message.h"
+#include "protobuf.h"
+#include "third_party/wyhash/wyhash.h"
+
+static upb_strview Convert_StringData(VALUE str, upb_arena *arena) {
+  upb_strview ret;
+  if (arena) {
+    char *ptr = upb_arena_malloc(arena, RSTRING_LEN(str));
+    memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
+    ret.data = ptr;
+  } else {
+    // Data is only needed temporarily (within map lookup).
+    ret.data = RSTRING_PTR(str);
+  }
+  ret.size = RSTRING_LEN(str);
+  return ret;
+}
+
+static bool is_ruby_num(VALUE value) {
+  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) {
+  if (!is_ruby_num(val)) {
+    rb_raise(cTypeError,
+             "Expected number type for integral field '%s' (given %s).", name,
+             rb_class2name(CLASS_OF(val)));
+  }
+
+  // NUM2{INT,UINT,LL,ULL} macros do the appropriate range checks on upper
+  // bound; we just need to do precision checks (i.e., disallow rounding) and
+  // check for < 0 on unsigned types.
+  if (TYPE(val) == T_FLOAT) {
+    double dbl_val = NUM2DBL(val);
+    if (floor(dbl_val) != dbl_val) {
+      rb_raise(rb_eRangeError,
+               "Non-integral floating point value assigned to integer field "
+               "'%s' (given %s).",
+               name, rb_class2name(CLASS_OF(val)));
+    }
+  }
+  if (type == UPB_TYPE_UINT32 || type == UPB_TYPE_UINT64) {
+    if (NUM2DBL(val) < 0) {
+      rb_raise(
+          rb_eRangeError,
+          "Assigning negative value to unsigned integer field '%s' (given %s).",
+          name, rb_class2name(CLASS_OF(val)));
+    }
+  }
+}
+
+static int32_t Convert_ToEnum(VALUE value, const char* name,
+                              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);
+      val = NUM2INT(value);
+      break;
+    case T_STRING:
+      if (!upb_enumdef_ntoi(e, RSTRING_PTR(value), RSTRING_LEN(value), &val)) {
+        goto unknownval;
+      }
+      break;
+    case T_SYMBOL:
+      if (!upb_enumdef_ntoiz(e, rb_id2name(SYM2ID(value)), &val)) {
+        goto unknownval;
+      }
+      break;
+    default:
+      rb_raise(cTypeError,
+               "Expected number or symbol type for enum field '%s'.", name);
+  }
+
+  return val;
+
+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;
+
+  switch (type_info.type) {
+    case UPB_TYPE_FLOAT:
+      if (!is_ruby_num(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:
+      if (!is_ruby_num(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: {
+      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)));
+      }
+      break;
+    }
+    case UPB_TYPE_STRING: {
+      VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
+      if (CLASS_OF(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)));
+      }
+
+      if (rb_obj_encoding(value) != utf8) {
+        // 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) {
+          rb_raise(rb_eEncodingError, "String is invalid UTF-8");
+        }
+      }
+
+      ret.str_val = Convert_StringData(value, arena);
+      break;
+    }
+    case UPB_TYPE_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_encoding(value) != bytes) {
+        // 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);
+      }
+
+      ret.str_val = Convert_StringData(value, arena);
+      break;
+    }
+    case UPB_TYPE_MESSAGE:
+      ret.msg_val =
+          Message_GetUpbMessage(value, type_info.def.msgdef, name, arena);
+      break;
+    case UPB_TYPE_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:
+      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;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena) {
+  switch (type_info.type) {
+    case UPB_TYPE_FLOAT:
+      return DBL2NUM(upb_val.float_val);
+    case UPB_TYPE_DOUBLE:
+      return DBL2NUM(upb_val.double_val);
+    case UPB_TYPE_BOOL:
+      return upb_val.bool_val ? Qtrue : Qfalse;
+    case UPB_TYPE_INT32:
+      return INT2NUM(upb_val.int32_val);
+    case UPB_TYPE_INT64:
+      return LL2NUM(upb_val.int64_val);
+    case UPB_TYPE_UINT32:
+      return UINT2NUM(upb_val.uint32_val);
+    case UPB_TYPE_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));
+      } else {
+        return INT2NUM(upb_val.int32_val);
+      }
+    }
+    case UPB_TYPE_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: {
+      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,
+                                    type_info.def.msgdef, arena);
+    default:
+      rb_raise(rb_eRuntimeError, "Convert_UpbToRuby(): Unexpected type %d",
+               (int)type_info.type);
+  }
+}
+
+upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
+                           upb_arena* arena) {
+  upb_msgval new_msgval;
+
+  switch (type_info.type) {
+    default:
+      memcpy(&new_msgval, &msgval, sizeof(msgval));
+      break;
+    case UPB_TYPE_STRING:
+    case UPB_TYPE_BYTES: {
+      size_t n = msgval.str_val.size;
+      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:
+      new_msgval.msg_val =
+          Message_deep_copy(msgval.msg_val, type_info.def.msgdef, arena);
+      break;
+  }
+
+  return new_msgval;
+}
+
+bool Msgval_IsEqual(upb_msgval val1, upb_msgval val2, TypeInfo type_info) {
+  switch (type_info.type) {
+    case UPB_TYPE_BOOL:
+      return memcmp(&val1, &val2, 1) == 0;
+    case UPB_TYPE_FLOAT:
+    case UPB_TYPE_INT32:
+    case UPB_TYPE_UINT32:
+    case UPB_TYPE_ENUM:
+      return memcmp(&val1, &val2, 4) == 0;
+    case UPB_TYPE_DOUBLE:
+    case UPB_TYPE_INT64:
+    case UPB_TYPE_UINT64:
+      return memcmp(&val1, &val2, 8) == 0;
+    case UPB_TYPE_STRING:
+    case UPB_TYPE_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:
+      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) {
+  switch (type_info.type) {
+    case UPB_TYPE_BOOL:
+      return wyhash(&val, 1, seed, _wyp);
+    case UPB_TYPE_FLOAT:
+    case UPB_TYPE_INT32:
+    case UPB_TYPE_UINT32:
+    case UPB_TYPE_ENUM:
+      return wyhash(&val, 4, seed, _wyp);
+    case UPB_TYPE_DOUBLE:
+    case UPB_TYPE_INT64:
+    case UPB_TYPE_UINT64:
+      return wyhash(&val, 8, seed, _wyp);
+    case UPB_TYPE_STRING:
+    case UPB_TYPE_BYTES:
+      return wyhash(val.str_val.data, val.str_val.size, seed, _wyp);
+    case UPB_TYPE_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

@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 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 RUBY_PROTOBUF_CONVERT_H_
+#define RUBY_PROTOBUF_CONVERT_H_
+
+#include <ruby/ruby.h>
+
+#include "protobuf.h"
+#include "ruby-upb.h"
+
+// Converts |ruby_val| to a upb_msgval according to |type_info|.
+//
+// The |arena| parameter indicates the lifetime of the container where this
+// value will be assigned. It is used as follows:
+// - If type is string or bytes, the string data will be copied into |arena|.
+// - If type is message, and we need to auto-construct a message due to implicit
+//   conversions (eg. Time -> Google::Protobuf::Timestamp), the new message
+//   will be created in |arena|.
+// - 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);
+
+// Converts |upb_val| to a Ruby VALUE according to |type_info|. This may involve
+// creating a Ruby wrapper object.
+//
+// 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);
+
+// Creates a deep copy of |msgval| in |arena|.
+upb_msgval Msgval_DeepCopy(upb_msgval 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);
+
+// Returns a hash value for the given upb_msgval.
+uint64_t Msgval_GetHash(upb_msgval val, TypeInfo type_info, uint64_t seed);
+
+#endif  // RUBY_PROTOBUF_CONVERT_H_