google-protobuf 3.21.0.rc.2-x64-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6de19b62824cf3ce53a8008651e273b0fd4fb90ed327c757776b33067954cce2
+  data.tar.gz: 0bb0a0e2a1379b6619cd2d356b8ff68a051a8141d2367c7b3d4e805a984c56da
+SHA512:
+  metadata.gz: 34ce0f8244e4a7faa23fea45215e7aae0a43f68d890379b780560badf45f940ccf2e3e466976b95d5d4a427834b3012fabcbf789c67fbf5347d492abe70ee158
+  data.tar.gz: 9914d8b108babbc1e714debd9b870952158b75dfa65392894e9bc5483490375f8d5fb38e10b7c8df2358fee31b350cbfc6738e3bf6fc49064d1fea15c35ae0d9

data/ext/google/protobuf_c/convert.c

@@ -0,0 +1,361 @@
+// 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_MessageValue.
+//
+// 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"
+
+static upb_StringView Convert_StringData(VALUE str, upb_Arena* arena) {
+  upb_StringView 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_CType 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 == kUpb_CType_UInt32 || type == kUpb_CType_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, kUpb_CType_Int32, value);
+      val = NUM2INT(value);
+      break;
+    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: {
+      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);
+  }
+
+  return val;
+
+unknownval:
+  rb_raise(rb_eRangeError, "Unknown symbol value for enum field '%s'.", name);
+}
+
+upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
+                                   TypeInfo type_info, upb_Arena* arena) {
+  upb_MessageValue ret;
+
+  switch (type_info.type) {
+    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)));
+      }
+      ret.float_val = NUM2DBL(value);
+      break;
+    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)));
+      }
+      ret.double_val = NUM2DBL(value);
+      break;
+    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)));
+      }
+      break;
+    }
+    case kUpb_CType_String: {
+      VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
+      if (rb_obj_class(value) == rb_cSymbol) {
+        value = rb_funcall(value, rb_intern("to_s"), 0);
+      } 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.
+        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 kUpb_CType_Bytes: {
+      VALUE bytes = rb_enc_from_encoding(rb_ascii8bit_encoding());
+      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.
+        // 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 kUpb_CType_Message:
+      ret.msg_val =
+          Message_GetUpbMessage(value, type_info.def.msgdef, name, arena);
+      break;
+    case kUpb_CType_Enum:
+      ret.int32_val = Convert_ToEnum(value, name, type_info.def.enumdef);
+      break;
+    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 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:
+      break;
+  }
+
+  return ret;
+}
+
+VALUE Convert_UpbToRuby(upb_MessageValue upb_val, TypeInfo type_info,
+                        VALUE arena) {
+  switch (type_info.type) {
+    case kUpb_CType_Float:
+      return DBL2NUM(upb_val.float_val);
+    case kUpb_CType_Double:
+      return DBL2NUM(upb_val.double_val);
+    case kUpb_CType_Bool:
+      return upb_val.bool_val ? Qtrue : Qfalse;
+    case kUpb_CType_Int32:
+      return INT2NUM(upb_val.int32_val);
+    case kUpb_CType_Int64:
+      return LL2NUM(upb_val.int64_val);
+    case kUpb_CType_UInt32:
+      return UINT2NUM(upb_val.uint32_val);
+    case kUpb_CType_UInt64:
+      return ULL2NUM(upb_val.int64_val);
+    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 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 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 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",
+               (int)type_info.type);
+  }
+}
+
+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 kUpb_CType_String:
+    case kUpb_CType_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 kUpb_CType_Message:
+      new_msgval.msg_val =
+          Message_deep_copy(msgval.msg_val, type_info.def.msgdef, arena);
+      break;
+  }
+
+  return new_msgval;
+}
+
+bool Msgval_IsEqual(upb_MessageValue val1, upb_MessageValue val2,
+                    TypeInfo type_info) {
+  switch (type_info.type) {
+    case kUpb_CType_Bool:
+      return memcmp(&val1, &val2, 1) == 0;
+    case kUpb_CType_Float:
+    case kUpb_CType_Int32:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_Enum:
+      return memcmp(&val1, &val2, 4) == 0;
+    case kUpb_CType_Double:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt64:
+      return memcmp(&val1, &val2, 8) == 0;
+    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 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_MessageValue val, TypeInfo type_info,
+                        uint64_t seed) {
+  switch (type_info.type) {
+    case kUpb_CType_Bool:
+      return _upb_Hash(&val, 1, seed);
+    case kUpb_CType_Float:
+    case kUpb_CType_Int32:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_Enum:
+      return _upb_Hash(&val, 4, seed);
+    case kUpb_CType_Double:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt64:
+      return _upb_Hash(&val, 8, seed);
+    case kUpb_CType_String:
+    case kUpb_CType_Bytes:
+      return _upb_Hash(val.str_val.data, val.str_val.size, seed);
+    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

@@ -0,0 +1,75 @@
+// 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_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:
+// - 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_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.
+//
+// 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_MessageValue upb_val, TypeInfo type_info,
+                        VALUE arena);
+
+// Creates a deep copy of |msgval| in |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_MessageValue val1, upb_MessageValue val2,
+                    TypeInfo type_info);
+
+// 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_