sparsam 0.2.3 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4b9246d1a569e7fa72c9f97015e0f9031b31249a
-  data.tar.gz: ba92cae518e5606f8c7273fb32519f307163b72c
+SHA256:
+  metadata.gz: 8d2c1375a7b3b2819de7f3ee0ad85fa964fc86345ab6ae109e18a033be94178c
+  data.tar.gz: f47b19af1fc8810c9e06864a11c6bbfd6b78635c430c9ba2e10d578d4f3f01c4
 SHA512:
-  metadata.gz: 268c577839d6ba4ff96b19dfdf9d09e6b903a72ef298a4cba763ed13dd4723181b85bf213e0a974ffa0abdf0a5ac131b6ef51f3fe8b42ae753ac4f3d48378afe
-  data.tar.gz: 83b7f8c97f0feea55491958a67ae0db8805a080a0e874c27e7046211f49f74cd6b39e0f67ac1014b27a70734247ca38173dd1ece94b6dd11bf41ca0b435c9646
+  metadata.gz: 978c4060ced319ba2d1a24462d1c3bc917bd42f049ea591f67023631895467df7c1917734b461b9ec7c2f210f014cce5b9cd95a820a74e9d432492c80ec133fa
+  data.tar.gz: 948ae683123165a6e4c85537b252f882fd10e1c6f481b3641799d0635067804aaf47743aecfaca267a764bd2a4ca4ec3495a5a294871e65ab7c953efd8d6d2cb

data/ext/ruby_hooks.c

@@ -1,6 +1,7 @@
+#include <ruby.h>
+#include <ruby/intern.h>
 #include "serializer.h"
 #include "stdio.h"
-#include <ruby.h>
 
 VALUE Sparsam = Qnil;
 VALUE static_zero_array;
@@ -10,10 +11,10 @@ ID intern_for_DEFAULT_VALUES;
 ID intern_for_assign_defaults;
 ID intern_for_assign_from_arg;
 
-static void deallocate(void *data) { serializer_free(data); }
+static void deallocate(void* data) { serializer_free(data); }
 
 static VALUE allocate(VALUE klass) {
-  void *data = serializer_create();
+  void* data = serializer_create();
   return Data_Wrap_Struct(klass, NULL, deallocate, data);
 }
 
@@ -23,8 +24,8 @@ static VALUE sparsam_init_bang(VALUE self) {
 }
 
 static VALUE initialize(VALUE self, VALUE type_arg, VALUE str_arg) {
-  void *self_data = NULL;
-  void *input_string = NULL;
+  void* self_data = NULL;
+  void* input_string = NULL;
 
   Check_Type(type_arg, T_FIXNUM);
   int prot = NUM2INT(type_arg);
@@ -37,7 +38,7 @@ static VALUE initialize(VALUE self, VALUE type_arg, VALUE str_arg) {
     memcpy(input_string, StringValuePtr(str_arg), len);
   }
 
-  Data_Get_Struct(self, void *, self_data);
+  Data_Get_Struct(self, void*, self_data);
   serializer_init(self_data, prot, input_string, len);
 
   return self;
@@ -45,7 +46,8 @@ static VALUE initialize(VALUE self, VALUE type_arg, VALUE str_arg) {
 
 VALUE sparsam_struct_initialize(int argc, VALUE* argv, VALUE self) {
   if (argc > 1) {
-    rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 0..1)", argc);
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (given %d, expected 0..1)", argc);
   }
 
   VALUE defaults = rb_const_get(rb_obj_class(self), intern_for_DEFAULT_VALUES);
@@ -69,13 +71,16 @@ void Init_sparsam_native() {
   Sparsam = rb_define_module("Sparsam");
   rb_define_singleton_method(Sparsam, "init!", sparsam_init_bang, 0);
   rb_define_singleton_method(Sparsam, "cache_fields", cache_fields, 1);
-  VALUE SparsamSerializer = rb_define_class_under(Sparsam, "Serializer", rb_cObject);
+  VALUE SparsamSerializer =
+      rb_define_class_under(Sparsam, "Serializer", rb_cObject);
   SparsamNativeError =
       rb_define_class_under(Sparsam, "Exception", rb_eStandardError);
   rb_define_alloc_func(SparsamSerializer, allocate);
   rb_define_method(SparsamSerializer, "initialize", initialize, 2);
   rb_define_method(SparsamSerializer, "serialize", serializer_writeStruct, 2);
   rb_define_method(SparsamSerializer, "deserialize", serializer_readStruct, 1);
+  rb_define_method(SparsamSerializer, "deserializeUnion", serializer_readUnion,
+                   1);
   rb_define_const(Sparsam, "CompactProtocol", INT2FIX(compact));
   rb_define_const(Sparsam, "BinaryProtocol", INT2FIX(binary));
   rb_define_const(Sparsam, "UNION", INT2FIX(t_union));
@@ -88,8 +93,9 @@ void Init_sparsam_native() {
   intern_for_assign_defaults = rb_intern("assign_defaults");
   intern_for_assign_from_arg = rb_intern("assign_from_arg");
 
-
-  VALUE SparsamStructInitialization = rb_define_module_under(Sparsam, "StructInitialization");
-  rb_define_method(SparsamStructInitialization, "initialize", sparsam_struct_initialize, -1);
+  VALUE SparsamStructInitialization =
+      rb_define_module_under(Sparsam, "StructInitialization");
+  rb_define_method(SparsamStructInitialization, "initialize",
+                   sparsam_struct_initialize, -1);
   initialize_constants();
 }

data/ext/serializer.cpp

@@ -1,12 +1,16 @@
-#include "serializer.h"
-#include <functional>
-#include <map>
+extern "C" {
+#include <ruby.h>
+#include <ruby/intern.h>
+}
 #include <ruby/encoding.h>
 #include <stdio.h>
 #include <thrift/protocol/TBinaryProtocol.h>
 #include <thrift/protocol/TCompactProtocol.h>
 #include <boost/make_shared.hpp>
+#include <functional>
+#include <map>
 #include <vector>
+#include "serializer.h"
 
 using namespace std;
 using ::apache::thrift::protocol::TType;
@@ -44,7 +48,7 @@ VALUE SparsamUnknownTypeException;
 
 VALUE SetClass;
 
-KlassFieldsCache klassCache; // consider the memory leaked.
+KlassFieldsCache klassCache;  // consider the memory leaked.
 std::unordered_set<VALUE> unions;
 
 void *serializer_create() { return (void *)(new ThriftSerializer()); }
@@ -79,8 +83,10 @@ void initialize_constants() {
 
 void initialize_runtime_constants() {
   klass_for_union = rb_const_get_at(Sparsam, rb_intern("Union"));
-  SparsamMissingMandatory = rb_const_get_at(Sparsam, rb_intern("MissingMandatory"));
-  SparsamTypeMismatchError = rb_const_get_at(Sparsam, rb_intern("TypeMismatch"));
+  SparsamMissingMandatory =
+      rb_const_get_at(Sparsam, rb_intern("MissingMandatory"));
+  SparsamTypeMismatchError =
+      rb_const_get_at(Sparsam, rb_intern("TypeMismatch"));
   SparsamUnionException = rb_const_get_at(Sparsam, rb_intern("UnionException"));
   SparsamUnknownTypeException =
       rb_const_get_at(Sparsam, rb_intern("UnknownTypeException"));
@@ -89,19 +95,16 @@ void initialize_runtime_constants() {
 
 void serializer_init(void *serializer, int protocol, void *str_arg1,
                      uint32_t len) {
-  using ::boost::shared_ptr;
-  using ::apache::thrift::protocol::TProtocol;
   using ::apache::thrift::protocol::TBinaryProtocol;
   using ::apache::thrift::protocol::TCompactProtocol;
+  using ::apache::thrift::protocol::TProtocol;
+  using ::boost::shared_ptr;
 
   ThriftSerializer *ts = (ThriftSerializer *)(serializer);
   shared_ptr<TMemoryBuffer> strBuffer;
   if (str_arg1 != NULL) {
     strBuffer = boost::make_shared<TMemoryBuffer>(
-      (uint8_t *)str_arg1,
-      len,
-      TMemoryBuffer::TAKE_OWNERSHIP
-    );
+        (uint8_t *)str_arg1, len, TMemoryBuffer::TAKE_OWNERSHIP);
   } else {
     strBuffer = boost::make_shared<TMemoryBuffer>();
   }
@@ -116,21 +119,19 @@ void serializer_init(void *serializer, int protocol, void *str_arg1,
   ts->tmb = strBuffer;
 }
 
-#define get_ts()                                                               \
-  void *self_data = NULL;                                                      \
-  Data_Get_Struct(self, void, self_data);                                      \
+#define get_ts()                          \
+  void *self_data = NULL;                 \
+  Data_Get_Struct(self, void, self_data); \
   ThriftSerializer *ts = (ThriftSerializer *)(self_data);
 
 #define watch_for_texcept() try {
-
-#define catch_thrift_and_reraise()                                             \
-  }                                                                            \
-  catch (::apache::thrift::TException e) {                                     \
-    rb_raise(SparsamNativeError, "%s", e.what());                              \
-    return Qnil;                                                               \
+#define catch_thrift_and_reraise()                \
+  }                                               \
+  catch (::apache::thrift::TException e) {        \
+    rb_raise(SparsamNativeError, "%s", e.what()); \
+    return Qnil;                                  \
   }
 
-
 static inline VALUE make_ruby_string(const string &val) {
   return rb_enc_str_new(val.c_str(), val.size(), rb_utf8_encoding());
 }
@@ -139,43 +140,58 @@ static inline VALUE make_ruby_binary(const string &val) {
   return rb_str_new(val.c_str(), val.size());
 }
 
-static void raise_exc_with_struct_and_field_names(
-        VALUE exc_class,
-        VALUE msg_prefix,
-        VALUE outer_struct_class,
-        VALUE field_sym) {
+static void raise_exc_with_struct_and_field_names(VALUE exc_class,
+                                                  VALUE msg_prefix,
+                                                  VALUE outer_struct_class,
+                                                  VALUE field_sym) {
   VALUE struct_name = rb_class_name(outer_struct_class);
   VALUE field_name = rb_sym_to_s(field_sym);
 
-  VALUE msg = rb_sprintf("%s (in %s#%s)",
-      RSTRING_PTR(msg_prefix),
-      RSTRING_PTR(struct_name),
-      RSTRING_PTR(field_name));
+  VALUE msg = rb_sprintf("%s (in %s#%s)", RSTRING_PTR(msg_prefix),
+                         RSTRING_PTR(struct_name), RSTRING_PTR(field_name));
   VALUE args[3] = {msg, struct_name, field_name};
   VALUE e = rb_class_new_instance(3, args, exc_class);
   rb_exc_raise(e);
 }
 
-static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym) {
-    raise_exc_with_struct_and_field_names(
-      SparsamTypeMismatchError,
-      rb_str_new2("Mismatched type"),
-      CLASS_OF(outer_struct),
-      field_sym);
+static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym,
+                                const char *expected, VALUE actual) {
+  VALUE actual_name = rb_class_name(CLASS_OF(actual));
+  VALUE msg = rb_sprintf(
+      "Mismatched type (expected to be compatible with: %s, found: %s)",
+      expected, RSTRING_PTR(actual_name));
+
+  raise_exc_with_struct_and_field_names(SparsamTypeMismatchError, msg,
+                                        CLASS_OF(outer_struct), field_sym);
 }
 
-static inline long raise_type_mismatch_as_value(VALUE outer_struct, VALUE field_sym) {
-  raise_type_mismatch(outer_struct, field_sym);
+static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym, int ttype,
+                                VALUE actual) {
+  raise_type_mismatch(outer_struct, field_sym, TTypeName((size_t)ttype).c_str(),
+                      actual);
+}
+
+static void raise_type_mismatch(VALUE outer_struct, VALUE field_sym,
+                                VALUE klass, VALUE actual) {
+  VALUE expected_name = rb_class_name(klass);
+  raise_type_mismatch(outer_struct, field_sym, RSTRING_PTR(expected_name),
+                      actual);
+}
+
+static inline long raise_type_mismatch_as_value(VALUE outer_struct,
+                                                VALUE field_sym, int ttype,
+                                                VALUE actual) {
+  raise_type_mismatch(outer_struct, field_sym, ttype, actual);
   return 0;
 }
 
-static inline void Sparsam_Check_Type(VALUE x, int t, VALUE outer_struct, VALUE field_sym) {
+static inline void Sparsam_Check_Type(VALUE x, int t, VALUE outer_struct,
+                                      VALUE field_sym) {
   if (!(RB_TYPE_P(x, t))) {
-    raise_type_mismatch(outer_struct, field_sym);
+    raise_type_mismatch(outer_struct, field_sym, t, x);
   }
 }
 
-
 static inline VALUE make_ruby_bool(bool val) { return val ? Qtrue : Qfalse; }
 
 void ThriftSerializer::skip_n_type(uint32_t n, TType ttype) {
@@ -194,18 +210,17 @@ void ThriftSerializer::skip_n_pair(uint32_t n, TType type_a, TType type_b) {
 // Blatantly copied protobuf's design
 // https://git.io/vHuUn
 // CONVERT is new here, because we're targeting ruby
-#define HANDLE_TYPE(TYPE, CPPTYPE, READ_METHOD, CONVERT)                       \
-  case protocol::T_##TYPE: {                                                   \
-    CPPTYPE value;                                                             \
-    this->tprot->read##READ_METHOD(value);                                     \
-    ret = CONVERT(value);                                                      \
-    break;                                                                     \
+#define HANDLE_TYPE(TYPE, CPPTYPE, READ_METHOD, CONVERT) \
+  case protocol::T_##TYPE: {                             \
+    CPPTYPE value;                                       \
+    this->tprot->read##READ_METHOD(value);               \
+    ret = CONVERT(value);                                \
+    break;                                               \
   }
 
 VALUE ThriftSerializer::readAny(TType ttype, FieldInfo *field_info) {
   VALUE ret = Qnil;
   switch (ttype) {
-
     // Handle all the non-container types by marco
     HANDLE_TYPE(I16, int16_t, I16, INT2FIX)
     HANDLE_TYPE(I32, int32_t, I32, INT2FIX)
@@ -214,99 +229,100 @@ VALUE ThriftSerializer::readAny(TType ttype, FieldInfo *field_info) {
     HANDLE_TYPE(DOUBLE, double, Double, DBL2NUM)
     HANDLE_TYPE(BYTE, int8_t, Byte, INT2FIX)
 
-  case protocol::T_STRING: {
-    string value;
-    if (field_info->isBinaryString) { // if (field_info[:binary])
-      this->tprot->readBinary(value);
-      ret = make_ruby_binary(value);
-    } else {
-      this->tprot->readString(value);
-      ret = make_ruby_string(value);
+    case protocol::T_STRING: {
+      string value;
+      if (field_info->isBinaryString) {  // if (field_info[:binary])
+        this->tprot->readBinary(value);
+        ret = make_ruby_binary(value);
+      } else {
+        this->tprot->readString(value);
+        ret = make_ruby_string(value);
+      }
+      break;
     }
-    break;
-  }
 
-  case protocol::T_LIST: {
-    TType element_type;
-    uint32_t size;
+    case protocol::T_LIST: {
+      TType element_type;
+      uint32_t size;
 
-    this->tprot->readListBegin(element_type, size);
-    if (field_info->elementType == NULL ||
-        element_type != field_info->elementType->ftype) {
-      this->skip_n_type(size, element_type);
-      break;
-    }
-    ret = rb_ary_new2(size);
+      this->tprot->readListBegin(element_type, size);
+      if (field_info->elementType == NULL ||
+          element_type != field_info->elementType->ftype) {
+        this->skip_n_type(size, element_type);
+        break;
+      }
+      ret = rb_ary_new2(size);
+
+      for (uint32_t i = 0; i < size; i++) {
+        rb_ary_store(ret, i,
+                     this->readAny(element_type, field_info->elementType));
+      }
+      this->tprot->readListEnd();
 
-    for (uint32_t i = 0; i < size; i++) {
-      rb_ary_store(ret, i,
-                   this->readAny(element_type, field_info->elementType));
+      break;
     }
-    this->tprot->readListEnd();
 
-    break;
-  }
+    case protocol::T_SET: {
+      TType element_type;
+      uint32_t size;
 
-  case protocol::T_SET: {
-    TType element_type;
-    uint32_t size;
+      this->tprot->readSetBegin(element_type, size);
+      if (field_info->elementType == NULL ||
+          element_type != field_info->elementType->ftype) {
+        this->skip_n_type(size, element_type);
+        break;
+      }
+      VALUE ary = rb_ary_new2(size);
 
-    this->tprot->readSetBegin(element_type, size);
-    if (field_info->elementType == NULL ||
-        element_type != field_info->elementType->ftype) {
-      this->skip_n_type(size, element_type);
+      for (uint32_t i = 0; i < size; i++) {
+        rb_ary_store(ary, i,
+                     this->readAny(element_type, field_info->elementType));
+      }
+      ret = rb_class_new_instance(1, &ary, klass_for_set);
+      this->tprot->readSetEnd();
       break;
     }
-    VALUE ary = rb_ary_new2(size);
 
-    for (uint32_t i = 0; i < size; i++) {
-      rb_ary_store(ary, i,
-                   this->readAny(element_type, field_info->elementType));
+    case protocol::T_STRUCT: {
+      string cname;
+      this->tprot->readStructBegin(cname);
+      if (unions.count(field_info->klass) == 1) {
+        ret = this->readUnion(field_info->klass);
+      } else {
+        ret = this->readStruct(field_info->klass);
+      }
+      this->tprot->readStructEnd();
+      break;
     }
-    ret = rb_class_new_instance(1, &ary, klass_for_set);
-    this->tprot->readSetEnd();
-    break;
-  }
 
-  case protocol::T_STRUCT: {
-    string cname;
-    this->tprot->readStructBegin(cname);
-    if (unions.count(field_info->klass) == 1) {
-      ret = this->readUnion(field_info->klass);
-    } else {
-      ret = this->readStruct(field_info->klass);
-    }
-    this->tprot->readStructEnd();
-    break;
-  }
+    case protocol::T_MAP: {
+      TType key_type, value_type;
+      uint32_t size;
+      VALUE k, v;
 
-  case protocol::T_MAP: {
-    TType key_type, value_type;
-    uint32_t size;
-    VALUE k, v;
+      this->tprot->readMapBegin(key_type, value_type, size);
 
-    this->tprot->readMapBegin(key_type, value_type, size);
+      if (field_info->keyType == NULL ||
+          field_info->elementType == NULL) {  // no type check to be consistent
+        skip_n_pair(size, key_type, value_type);
+        break;
+      }
 
-    if (field_info->keyType == NULL ||
-        field_info->elementType == NULL) { // no type check to be consistent
-      skip_n_pair(size, key_type, value_type);
+      ret = rb_hash_new();
+      for (uint32_t i = 0; i < size; i++) {
+        k = this->readAny(key_type, field_info->keyType);
+        v = this->readAny(value_type, field_info->elementType);
+        rb_hash_aset(ret, k, v);
+      }
+      this->tprot->readMapEnd();
       break;
     }
 
-    ret = rb_hash_new();
-    for (uint32_t i = 0; i < size; i++) {
-      k = this->readAny(key_type, field_info->keyType);
-      v = this->readAny(value_type, field_info->elementType);
-      rb_hash_aset(ret, k, v);
-    }
-    this->tprot->readMapEnd();
-    break;
-  }
-
-  default:
-    this->tprot->skip(ttype);
-    rb_raise(SparsamUnknownTypeException, "Received unknown type with id: %d", ttype);
-    break;
+    default:
+      this->tprot->skip(ttype);
+      rb_raise(SparsamUnknownTypeException, "Received unknown type with id: %d",
+               ttype);
+      break;
   }
 
   return ret;
@@ -315,12 +331,11 @@ VALUE ThriftSerializer::readAny(TType ttype, FieldInfo *field_info) {
 #undef HANDLE_TYPE
 
 VALUE ThriftSerializer::readStruct(VALUE klass) {
-
   string cname;
   FieldBegin fieldBegin;
   TType typeId;
   FieldInfo *fieldInfo;
-  VALUE ret = rb_class_new_instance(0, NULL, klass); // ret = &klass.new
+  VALUE ret = rb_class_new_instance(0, NULL, klass);  // ret = &klass.new
   auto fields = FindOrCreateFieldInfoMap(klass);
 
   while (true) {
@@ -342,10 +357,11 @@ VALUE ThriftSerializer::readStruct(VALUE klass) {
 
     if (typeId != fieldBegin.ftype) {
       raise_exc_with_struct_and_field_names(
-        SparsamTypeMismatchError,
-        rb_sprintf("Mismatched type (definition: %d, found: %d)", fieldBegin.ftype, typeId),
-        klass,
-        fieldInfo->symName);
+          SparsamTypeMismatchError,
+          rb_sprintf("Mismatched type (definition: %s, found: %s)",
+                     TTypeName(fieldBegin.ftype).c_str(),
+                     TTypeName(typeId).c_str()),
+          klass, fieldInfo->symName);
     }
 
     VALUE rb_value = this->readAny(fieldBegin.ftype, iter->second);
@@ -362,7 +378,7 @@ VALUE ThriftSerializer::readUnion(VALUE klass) {
   string cname;
   FieldBegin fieldBegin;
 
-  VALUE ret = rb_class_new_instance(0, NULL, klass); // ret = &klass.new
+  VALUE ret = rb_class_new_instance(0, NULL, klass);  // ret = &klass.new
   auto fields = FindOrCreateFieldInfoMap(klass);
 
   VALUE key, rb_value;
@@ -400,23 +416,22 @@ VALUE ThriftSerializer::readUnion(VALUE klass) {
 // for the unary `+` before lambda:
 // https://stackoverflow.com/a/18889029/4944625
 // explicit cast to work with signature: (int (*)(...))
-#define HASH_FOREACH_BEGIN(hash, ...)                                          \
-  void *_args[] = {__VA_ARGS__};                                               \
+#define HASH_FOREACH_BEGIN(hash, ...) \
+  void *_args[] = {__VA_ARGS__};      \
   rb_hash_foreach(hash, (int (*)(ANYARGS))(+[](VALUE k, VALUE v, VALUE args) { \
     void **argv = (void **) args;
-
 #define HASH_FOREACH_RET() return (int)ST_CONTINUE;
 
 #define HASH_FOREACH_ABORT() return (int)ST_STOP;
 
-#define HASH_FOREACH_END()                                                     \
-  HASH_FOREACH_RET()                                                           \
+#define HASH_FOREACH_END() \
+  HASH_FOREACH_RET()       \
   }), (VALUE) _args);
 
-#define HANDLE_TYPE(TYPE, WRITE_METHOD, CONVERT)                               \
-  case protocol::T_##TYPE: {                                                   \
-    this->tprot->write##WRITE_METHOD(CONVERT);                                 \
-    break;                                                                     \
+#define HANDLE_TYPE(TYPE, WRITE_METHOD, CONVERT) \
+  case protocol::T_##TYPE: {                     \
+    this->tprot->write##WRITE_METHOD(CONVERT);   \
+    break;                                       \
   }
 
 static inline long raise_bignum_range_error_as_value() {
@@ -424,19 +439,21 @@ static inline long raise_bignum_range_error_as_value() {
   return 0;
 }
 
-#define CONVERT_FIXNUM(CONVERT)                                                \
-  ((FIXNUM_P(actual)) ?                                                        \
-    CONVERT(actual) :                                                          \
-    ((RB_TYPE_P(actual, T_BIGNUM)) ?                                           \
-      raise_bignum_range_error_as_value() :                                    \
-      raise_type_mismatch_as_value(outer_struct, field_sym)))
-
-#define CONVERT_I64                                                            \
-  ((FIXNUM_P(actual)) ?                                                        \
-    (LONG_LONG)FIX2LONG(actual) :                                              \
-    ((RB_TYPE_P(actual, T_BIGNUM)) ?                                           \
-      rb_big2ll(actual) :                                                      \
-      raise_type_mismatch_as_value(outer_struct, field_sym)))
+#define CONVERT_FIXNUM(CONVERT, INTENDED)                             \
+  ((FIXNUM_P(actual))                                                 \
+       ? CONVERT(actual)                                              \
+       : ((RB_TYPE_P(actual, T_BIGNUM))                               \
+              ? raise_bignum_range_error_as_value()                   \
+              : raise_type_mismatch_as_value(outer_struct, field_sym, \
+                                             INTENDED, actual)))
+
+#define CONVERT_I64                                                   \
+  ((FIXNUM_P(actual))                                                 \
+       ? (LONG_LONG)FIX2LONG(actual)                                  \
+       : ((RB_TYPE_P(actual, T_BIGNUM))                               \
+              ? rb_big2ll(actual)                                     \
+              : raise_type_mismatch_as_value(outer_struct, field_sym, \
+                                             protocol::T_I64, actual)))
 
 #ifdef RB_FLOAT_TYPE_P
 #define FLOAT_TYPE_P(x) RB_FLOAT_TYPE_P(x)
@@ -444,19 +461,21 @@ static inline long raise_bignum_range_error_as_value() {
 #define FLOAT_TYPE_P(x) RB_TYPE_P(x, T_FLOAT)
 #endif
 
-#define CONVERT_FLOAT(CONVERT)                                                 \
-  ((FLOAT_TYPE_P(actual)) ?                                                    \
-   CONVERT(actual) :                                                           \
-   raise_type_mismatch_as_value(outer_struct, field_sym))                      \
+#define CONVERT_FLOAT(CONVERT)                                 \
+  ((FLOAT_TYPE_P(actual))                                      \
+       ? CONVERT(actual)                                       \
+       : raise_type_mismatch_as_value(outer_struct, field_sym, \
+                                      protocol::T_DOUBLE, actual))
 
-static inline bool convertBool(VALUE actual, VALUE outer_struct, VALUE field_sym) {
+static inline bool convertBool(VALUE actual, VALUE outer_struct,
+                               VALUE field_sym) {
   switch (actual) {
     case Qtrue:
       return true;
     case Qfalse:
       return false;
     default:
-      raise_type_mismatch(outer_struct, field_sym);
+      raise_type_mismatch(outer_struct, field_sym, protocol::T_BOOL, actual);
   }
 
   /* unreachable */
@@ -473,7 +492,7 @@ static inline char byte_convert(VALUE x) {
   short s = SHORT_CONVERT(x);
 
   if (s <= 127 && s >= -128) {
-    return (char) s;
+    return (char)s;
   } else {
     rb_raise(rb_eRangeError, "integer %d out of range for char", s);
   }
@@ -483,89 +502,94 @@ static inline char byte_convert(VALUE x) {
 }
 
 void ThriftSerializer::writeAny(TType ttype, FieldInfo *field_info,
-                                VALUE actual, VALUE outer_struct, VALUE field_sym) {
+                                VALUE actual, VALUE outer_struct,
+                                VALUE field_sym) {
   switch (ttype) {
-    HANDLE_TYPE(I16, I16, CONVERT_FIXNUM(SHORT_CONVERT))
-    HANDLE_TYPE(I32, I32, CONVERT_FIXNUM(FIX2INT))
+    HANDLE_TYPE(I16, I16, CONVERT_FIXNUM(SHORT_CONVERT, protocol::T_I16))
+    HANDLE_TYPE(I32, I32, CONVERT_FIXNUM(FIX2INT, protocol::T_I32))
     HANDLE_TYPE(I64, I64, CONVERT_I64)
     HANDLE_TYPE(BOOL, Bool, convertBool(actual, outer_struct, field_sym))
     HANDLE_TYPE(DOUBLE, Double, CONVERT_FLOAT(NUM2DBL))
-    HANDLE_TYPE(BYTE, Byte, CONVERT_FIXNUM(byte_convert))
+    HANDLE_TYPE(BYTE, Byte, CONVERT_FIXNUM(byte_convert, protocol::T_BYTE))
 
-  case protocol::T_STRING: {
-    Sparsam_Check_Type(actual, T_STRING, outer_struct, field_sym);
+    case protocol::T_STRING: {
+      Sparsam_Check_Type(actual, T_STRING, outer_struct, field_sym);
 
-    string data = string(StringValuePtr(actual), RSTRING_LEN(actual));
-    if (field_info->isBinaryString) {
-      this->tprot->writeBinary(data);
-    } else {
-      this->tprot->writeString(data);
+      string data = string(StringValuePtr(actual), RSTRING_LEN(actual));
+      if (field_info->isBinaryString) {
+        this->tprot->writeBinary(data);
+      } else {
+        this->tprot->writeString(data);
+      }
+      break;
     }
-    break;
-  }
 
-  case protocol::T_LIST: {
-    Sparsam_Check_Type(actual, T_ARRAY, outer_struct, field_sym);
+    case protocol::T_LIST: {
+      Sparsam_Check_Type(actual, T_ARRAY, outer_struct, field_sym);
 
-    long length = RARRAY_LEN(actual);
-    TType elem = field_info->elementType->ftype;
-    this->tprot->writeListBegin(elem, static_cast<size_t>(length));
-    for (long i = 0; i < length; i++) {
-      this->writeAny(elem, field_info->elementType, rb_ary_entry(actual, i), outer_struct, field_sym);
+      long length = RARRAY_LEN(actual);
+      TType elem = field_info->elementType->ftype;
+      this->tprot->writeListBegin(elem, static_cast<size_t>(length));
+      for (long i = 0; i < length; i++) {
+        this->writeAny(elem, field_info->elementType, rb_ary_entry(actual, i),
+                       outer_struct, field_sym);
+      }
+      this->tprot->writeListEnd();
+      break;
     }
-    this->tprot->writeListEnd();
-    break;
-  }
 
-  case protocol::T_SET: {
-    if (rb_class_real(CLASS_OF(actual)) != SetClass) {
-      raise_type_mismatch(outer_struct, field_sym);
+    case protocol::T_SET: {
+      if (rb_class_real(CLASS_OF(actual)) != SetClass) {
+        raise_type_mismatch(outer_struct, field_sym, protocol::T_SET, actual);
+      }
+
+      VALUE ary = rb_funcall(actual, intern_for_to_a, 0);
+      long length = RARRAY_LEN(ary);
+      TType elem = field_info->elementType->ftype;
+      this->tprot->writeListBegin(elem, static_cast<size_t>(length));
+      for (long i = 0; i < length; i++) {
+        this->writeAny(elem, field_info->elementType, rb_ary_entry(ary, i),
+                       outer_struct, field_sym);
+      }
+      this->tprot->writeListEnd();
+      break;
     }
 
-    VALUE ary = rb_funcall(actual, intern_for_to_a, 0);
-    long length = RARRAY_LEN(ary);
-    TType elem = field_info->elementType->ftype;
-    this->tprot->writeListBegin(elem, static_cast<size_t>(length));
-    for (long i = 0; i < length; i++) {
-      this->writeAny(elem, field_info->elementType, rb_ary_entry(ary, i), outer_struct, field_sym);
+    case protocol::T_MAP: {
+      Sparsam_Check_Type(actual, T_HASH, outer_struct, field_sym);
+
+      TType keyTType = field_info->keyType->ftype,
+            valueTType = field_info->elementType->ftype;
+      this->tprot->writeMapBegin(keyTType, valueTType,
+                                 static_cast<size_t>(RHASH_SIZE(actual)));
+      HASH_FOREACH_BEGIN(actual, this, field_info, &outer_struct, &field_sym)
+      ThriftSerializer *that = (ThriftSerializer *)argv[0];
+      FieldInfo *field_info = (FieldInfo *)argv[1];
+      VALUE *outer_struct = (VALUE *)argv[2];
+      VALUE *field_sym = (VALUE *)argv[3];
+      that->writeAny(field_info->keyType->ftype, field_info->keyType, k,
+                     *outer_struct, *field_sym);
+      that->writeAny(field_info->elementType->ftype, field_info->elementType, v,
+                     *outer_struct, *field_sym);
+      HASH_FOREACH_END()
+      this->tprot->writeMapEnd();
+      break;
     }
-    this->tprot->writeListEnd();
-    break;
-  }
 
-  case protocol::T_MAP: {
-    Sparsam_Check_Type(actual, T_HASH, outer_struct, field_sym);
-
-    TType keyTType = field_info->keyType->ftype,
-          valueTType = field_info->elementType->ftype;
-    this->tprot->writeMapBegin(keyTType, valueTType,
-                               static_cast<size_t>(RHASH_SIZE(actual)));
-    HASH_FOREACH_BEGIN(actual, this, field_info, &outer_struct, &field_sym)
-    ThriftSerializer *that = (ThriftSerializer *)argv[0];
-    FieldInfo *field_info = (FieldInfo *)argv[1];
-    VALUE *outer_struct = (VALUE *)argv[2];
-    VALUE *field_sym = (VALUE *)argv[3];
-    that->writeAny(field_info->keyType->ftype, field_info->keyType, k, *outer_struct, *field_sym);
-    that->writeAny(field_info->elementType->ftype, field_info->elementType, v, *outer_struct, *field_sym);
-    HASH_FOREACH_END()
-    this->tprot->writeMapEnd();
-    break;
-  }
+    case protocol::T_STRUCT: {
+      if (rb_class_real(CLASS_OF(actual)) != field_info->klass) {
+        raise_type_mismatch(outer_struct, field_sym, field_info->klass, actual);
+      }
 
-  case protocol::T_STRUCT: {
-    if (rb_class_real(CLASS_OF(actual)) != field_info->klass) {
-      raise_type_mismatch(outer_struct, field_sym);
+      static const string cname = "";
+      this->tprot->writeStructBegin(cname.c_str());
+      this->writeStruct(field_info->klass, actual);
+      this->tprot->writeFieldStop();
+      this->tprot->writeStructEnd();
+      break;
     }
 
-    static const string cname = "";
-    this->tprot->writeStructBegin(cname.c_str());
-    this->writeStruct(field_info->klass, actual);
-    this->tprot->writeFieldStop();
-    this->tprot->writeStructEnd();
-    break;
-  }
-
-  default: { break; }
+    default: { break; }
   }
 }
 
@@ -578,10 +602,8 @@ static bool checkRequiredFields(VALUE klass, VALUE data) {
       VALUE val = rb_ivar_get(data, entry.second->ivarName);
       if (NIL_P(val)) {
         raise_exc_with_struct_and_field_names(
-          SparsamMissingMandatory,
-          rb_str_new2("Required field missing"),
-          klass,
-          entry.second->symName);
+            SparsamMissingMandatory, rb_str_new2("Required field missing"),
+            klass, entry.second->symName);
         return false;
       }
     }
@@ -600,14 +622,16 @@ void ThriftSerializer::writeStruct(VALUE klass, VALUE data) {
     return;
   }
 
-  for (auto const & entry : *fields) {
+  for (auto const &entry : *fields) {
     fieldBegin.fid = entry.first;
     fieldInfo = entry.second;
     fieldBegin.ftype = fieldInfo->ftype;
     VALUE actual = rb_ivar_get(data, fieldInfo->ivarName);
     if (!NIL_P(actual)) {
-      this->tprot->writeFieldBegin(cname.c_str(), fieldBegin.ftype, fieldBegin.fid);
-      this->writeAny(fieldBegin.ftype, entry.second, actual, data, fieldInfo->symName);
+      this->tprot->writeFieldBegin(cname.c_str(), fieldBegin.ftype,
+                                   fieldBegin.fid);
+      this->writeAny(fieldBegin.ftype, entry.second, actual, data,
+                     fieldInfo->symName);
       this->tprot->writeFieldEnd();
     }
   }
@@ -621,13 +645,10 @@ VALUE serializer_writeStruct(VALUE self, VALUE klass, VALUE data) {
     VALUE actual_name = rb_class_name(CLASS_OF(data));
 
     raise_exc_with_struct_and_field_names(
-      SparsamTypeMismatchError,
-      rb_sprintf(
-        "Mismatched type passed to serialize (expected: %s got: %s)",
-        RSTRING_PTR(expected_name),
-        RSTRING_PTR(actual_name)),
-      CLASS_OF(data),
-      ID2SYM(rb_intern("(root)")));
+        SparsamTypeMismatchError,
+        rb_sprintf("Mismatched type passed to serialize (expected: %s got: %s)",
+                   RSTRING_PTR(expected_name), RSTRING_PTR(actual_name)),
+        CLASS_OF(data), ID2SYM(rb_intern("(root)")));
 
     RB_GC_GUARD(expected_name);
     RB_GC_GUARD(actual_name);
@@ -654,6 +675,17 @@ VALUE serializer_readStruct(VALUE self, VALUE klass) {
   catch_thrift_and_reraise();
 }
 
+VALUE serializer_readUnion(VALUE self, VALUE klass) {
+  watch_for_texcept() get_ts();
+  string cname;
+  VALUE ret;
+  ts->tprot->readStructBegin(cname);
+  ret = ts->readUnion(klass);
+  ts->tprot->readStructEnd();
+  return ret;
+  catch_thrift_and_reraise();
+}
+
 #define R_FIX_TO_TTYPE(x) (static_cast<TType>(FIX2INT(x)))
 
 FieldInfoMap *FindOrCreateFieldInfoMap(VALUE klass) {
@@ -693,34 +725,36 @@ FieldInfo *CreateFieldInfo(VALUE field_map_entry) {
       R_FIX_TO_TTYPE(rb_hash_aref(field_map_entry, sym_for_type));
   fieldInfo->isOptional =
       RTEST(rb_hash_aref(field_map_entry, sym_for_optional));
-  fieldInfo->ivarName = field_name_to_ivar_id(rb_hash_aref(field_map_entry, sym_for_name));
-  fieldInfo->symName = field_name_to_sym(rb_hash_aref(field_map_entry, sym_for_name));
+  fieldInfo->ivarName =
+      field_name_to_ivar_id(rb_hash_aref(field_map_entry, sym_for_name));
+  fieldInfo->symName =
+      field_name_to_sym(rb_hash_aref(field_map_entry, sym_for_name));
   switch (fieldInfo->ftype) {
-  case protocol::T_STRING: {
-    if (RTEST(rb_hash_aref(field_map_entry, sym_for_binary))) {
-      fieldInfo->isBinaryString = true;
+    case protocol::T_STRING: {
+      if (RTEST(rb_hash_aref(field_map_entry, sym_for_binary))) {
+        fieldInfo->isBinaryString = true;
+      }
+      break;
     }
-    break;
-  }
-  case protocol::T_STRUCT: {
-    fieldInfo->klass = rb_hash_aref(field_map_entry, sym_for_class);
-    break;
-  }
-  case protocol::T_LIST:
-  case protocol::T_SET: {
-    fieldInfo->elementType =
-        CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_element));
-    break;
-  }
-  case protocol::T_MAP: {
-    fieldInfo->keyType =
-        CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_key));
-    fieldInfo->elementType =
-        CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_value));
-    break;
-  }
-  default:
-    break;
+    case protocol::T_STRUCT: {
+      fieldInfo->klass = rb_hash_aref(field_map_entry, sym_for_class);
+      break;
+    }
+    case protocol::T_LIST:
+    case protocol::T_SET: {
+      fieldInfo->elementType =
+          CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_element));
+      break;
+    }
+    case protocol::T_MAP: {
+      fieldInfo->keyType =
+          CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_key));
+      fieldInfo->elementType =
+          CreateFieldInfo(rb_hash_aref(field_map_entry, sym_for_value));
+      break;
+    }
+    default:
+      break;
   }
   return fieldInfo;
 }