rice 4.7.1 → 4.8.0

data/rice/detail/from_ruby.ipp

@@ -2,57 +2,128 @@
 #include <optional>
 #include <stdexcept>
 
-/* This file implements conversions from Ruby to native values fo fundamental types 
+/* This file implements conversions from Ruby to native values fo fundamental types
    such as bool, int, float, etc. It also includes conversions for chars and strings */
 namespace Rice::detail
 {
-  inline Convertible operator&(Convertible left, Convertible right)
+  // Get precision bits for a Ruby numeric value
+  inline int rubyPrecisionBits(VALUE value)
   {
-    return static_cast<Convertible>(static_cast<uint8_t>(left) & static_cast<uint8_t>(right));
-  }
+    switch (rb_type(value))
+    {
+      // Ruby fixnums fit in long long (63 bits)
+      case RUBY_T_FIXNUM:
+        return std::numeric_limits<long long>::digits;
 
-  inline Convertible operator|(Convertible left, Convertible right)
-  {
-    return static_cast<Convertible>(static_cast<uint8_t>(left) | static_cast<uint8_t>(right));
+      // Ruby bignums can be arbitrarily large - return actual size
+      case RUBY_T_BIGNUM:
+      {
+        int nlz = 0;
+        size_t bytes = protect(rb_absint_size, value, &nlz);
+        return static_cast<int>(bytes * CHAR_BIT - nlz);
+      }
+
+      // Ruby floats are C doubles (53 bit mantissa)
+      case RUBY_T_FLOAT:
+        return std::numeric_limits<double>::digits;
+      
+      // Everything else...
+      default:
+        return 0;
+    }
   }
 
-  inline bool operator<(Convertible left, Convertible right)
+  // Precision score for converting Ruby numeric value to C++ type T
+  template<typename T>
+  inline double precisionScore(VALUE value)
   {
-    return static_cast<uint8_t>(left) < static_cast<uint8_t>(right);
+    int sourceBits = rubyPrecisionBits(value);
+    if (sourceBits == 0)
+    {
+      return Convertible::None;
+    }
+
+    constexpr int targetBits = std::numeric_limits<T>::digits;
+    return (targetBits >= sourceBits) ? Convertible::Exact : static_cast<double>(targetBits) / sourceBits;
   }
 
-  // ===========  Helpers  ============
-  template<typename T>
+  // Primary template for integral types
+  template<typename T, typename Enable = void>
   class FromRubyFundamental
   {
   public:
-    using RubyType_T = RubyType<T>;
-
-    static Convertible is_convertible(VALUE value)
+    static double is_convertible(VALUE value)
     {
-      ruby_value_type valueType = rb_type(value);
-
-      if (RubyType_T::Exact.find(valueType) != RubyType_T::Exact.end())
-      {
-        return Convertible::Exact;
-      }
-      else if (RubyType_T::Castable.find(valueType) != RubyType_T::Castable.end())
+      double score = precisionScore<T>(value);
+      if (score > Convertible::None)
       {
-        return Convertible::Cast;
+        switch (rb_type(value))
+        {
+          case RUBY_T_BIGNUM:
+          {
+            constexpr int targetBits = std::numeric_limits<T>::digits;
+            int sourceBits = rubyPrecisionBits(value);
+            if (sourceBits > targetBits)
+            {
+              return Convertible::None;
+            }
+            [[fallthrough]];
+          }
+          case RUBY_T_FIXNUM:
+          {
+            if constexpr (std::is_unsigned_v<T>)
+            {
+              score *= Convertible::SignedToUnsigned;
+            }
+            break;
+          }
+          case RUBY_T_FLOAT:
+          {
+            score *= Convertible::FloatToInt;
+            break;
+          }
+          default:
+            break;
+        }
+
+        return score;
       }
-      else if (RubyType_T::Narrowable.find(valueType) != RubyType_T::Narrowable.end())
+
+      if constexpr (is_char_type_v<T>)
       {
-        return Convertible::Narrow;
+        if (rb_type(value) == RUBY_T_STRING)
+        {
+          return Convertible::Exact;
+        }
       }
-      else
+
+      return Convertible::None;
+    }
+
+    static T convert(VALUE value)
+    {
+      return (T)protect(RubyType<T>::fromRuby, value);
+    }
+  };
+
+  // Specialization for floating point types
+  template<typename T>
+  class FromRubyFundamental<T, std::enable_if_t<std::is_floating_point_v<T>>>
+  {
+  public:
+    static double is_convertible(VALUE value)
+    {
+      double score = precisionScore<T>(value);
+      if (score > Convertible::None && rb_type(value) != RUBY_T_FLOAT)
       {
-        return Convertible::None;
+        score *= Convertible::IntToFloat;
       }
+      return score;
     }
 
     static T convert(VALUE value)
     {
-      return (T)protect(RubyType_T::fromRuby, value);
+      return (T)protect(RubyType<T>::fromRuby, value);
     }
   };
 
@@ -60,7 +131,7 @@ namespace Rice::detail
   class FromRubyFundamental<T*>
   {
   public:
-    static Convertible is_convertible(VALUE value)
+    static double is_convertible(VALUE value)
     {
       ruby_value_type valueType = rb_type(value);
 
@@ -69,7 +140,6 @@ namespace Rice::detail
         case RUBY_T_NIL:
         {
           return Convertible::Exact;
-          break;
         }
         case RUBY_T_DATA:
         {
@@ -108,7 +178,7 @@ namespace Rice::detail
         {
           detail::TypeMapper<Pointer<T>> typeMapper;
           std::string expected = typeMapper.rubyName();
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
             detail::protect(rb_obj_classname, value), expected.c_str());
         }
       }
@@ -119,7 +189,7 @@ namespace Rice::detail
   class FromRubyFundamental<T**>
   {
   public:
-    static Convertible is_convertible(VALUE value)
+    static double is_convertible(VALUE value)
     {
       ruby_value_type valueType = rb_type(value);
 
@@ -128,7 +198,6 @@ namespace Rice::detail
         case RUBY_T_NIL:
         {
           return Convertible::Exact;
-          break;
         }
         case RUBY_T_DATA:
         {
@@ -167,7 +236,7 @@ namespace Rice::detail
         {
           detail::TypeMapper<Pointer<T*>> typeMapper;
           std::string expected = typeMapper.rubyName();
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
             detail::protect(rb_obj_classname, value), expected.c_str());
         }
       }
@@ -185,14 +254,22 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      return FromRubyFundamental<bool>::is_convertible(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_TRUE:
+        case RUBY_T_FALSE:
+        case RUBY_T_NIL:
+          return Convertible::Exact;
+        default:
+          return Convertible::None;
+      }
     }
 
     bool convert(VALUE value)
     {
-      return FromRubyFundamental<bool>::convert(value);
+      return protect(RubyType<bool>::fromRuby, value);
     }
 
   private:
@@ -203,7 +280,7 @@ namespace Rice::detail
   class From_Ruby<bool&>
   {
   public:
-    using Pointer_T = Pointer<bool>;
+    using Reference_T = Reference<bool>;
 
     From_Ruby() = default;
 
@@ -211,13 +288,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -225,7 +302,7 @@ namespace Rice::detail
         }
         default:
         {
-          return FromRubyFundamental<bool>::is_convertible(value);
+          return this->from_.is_convertible(value);
         }
       }
     }
@@ -236,23 +313,25 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (bool&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<bool>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<bool>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
+    From_Ruby<bool> from_;
     Arg* arg_ = nullptr;
-    bool converted_ = false;
+    Reference<bool> reference_;
   };
 
   // ===========  char  ============
@@ -266,7 +345,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<char>::is_convertible(value);
     }
@@ -284,7 +363,7 @@ namespace Rice::detail
   class From_Ruby<char&>
   {
   public:
-    using Pointer_T = Pointer<char>;
+    using Reference_T = Reference<char>;
 
     From_Ruby() = default;
 
@@ -292,13 +371,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -317,25 +396,26 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (char&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<char>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<char>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    char converted_ = 0;
+    Reference<char> reference_;
   };
-      
+
   template<>
   class From_Ruby<char*>
   {
@@ -346,7 +426,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -402,7 +482,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<unsigned char>::is_convertible(value);
     }
@@ -420,7 +500,7 @@ namespace Rice::detail
   class From_Ruby<unsigned char&>
   {
   public:
-    using Pointer_T = Pointer<unsigned char>;
+    using Reference_T = Reference<unsigned char>;
 
     From_Ruby() = default;
 
@@ -428,13 +508,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -453,23 +533,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (unsigned char&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<unsigned char>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<unsigned char>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned char converted_ = 0;
+    Reference<unsigned char> reference_;
   };
 
   // ===========  signed char  ============
@@ -483,7 +564,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<signed char>::is_convertible(value);
     }
@@ -501,7 +582,7 @@ namespace Rice::detail
   class From_Ruby<signed char&>
   {
   public:
-    using Pointer_T = Pointer<signed char>;
+    using Reference_T = Reference<signed char>;
 
     From_Ruby() = default;
 
@@ -509,13 +590,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -534,23 +615,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (signed char&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<signed char>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<signed char>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    signed char converted_ = 0;
+    Reference<signed char> reference_;
   };
 
   // ===========  double  ============
@@ -564,7 +646,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<double>::is_convertible(value);
     }
@@ -582,7 +664,7 @@ namespace Rice::detail
   class From_Ruby<double&>
   {
   public:
-    using Pointer_T = Pointer<double>;
+    using Reference_T = Reference<double>;
 
     From_Ruby() = default;
 
@@ -590,13 +672,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -615,23 +697,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (double&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<double>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<double>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    double converted_;
+    Reference<double> reference_;
   };
 
   // ===========  float  ============
@@ -645,7 +728,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<float>::is_convertible(value);
     }
@@ -663,7 +746,7 @@ namespace Rice::detail
   class From_Ruby<float&>
   {
   public:
-    using Pointer_T = Pointer<float>;
+    using Reference_T = Reference<float>;
 
     From_Ruby() = default;
 
@@ -671,13 +754,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -696,23 +779,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (float&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<float>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<float>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    float converted_;
+    Reference<float> reference_;
   };
 
   // ===========  int  ============
@@ -726,9 +810,9 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      Convertible result = FromRubyFundamental<int>::is_convertible(value);
+      double result = FromRubyFundamental<int>::is_convertible(value);
 
       // Is this an enum? If so we want to support converting it to an integer
       if (result == Convertible::None && rb_type(value) == RUBY_T_DATA)
@@ -736,7 +820,7 @@ namespace Rice::detail
         static ID id = protect(rb_intern, "to_int");
         if (protect(rb_respond_to, value, id))
         {
-          result = Convertible::Cast;
+          result = Convertible::Exact;
         }
       }
       return result;
@@ -746,7 +830,7 @@ namespace Rice::detail
     {
       return FromRubyFundamental<int>::convert(value);
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
@@ -755,7 +839,7 @@ namespace Rice::detail
   class From_Ruby<int&>
   {
   public:
-    using Pointer_T = Pointer<int>;
+    using Reference_T = Reference<int>;
 
     From_Ruby() = default;
 
@@ -763,13 +847,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -788,23 +872,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (int&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<int>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<int>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    int converted_ = 0;
+    Reference<int> reference_;
   };
 
   // ===========  unsigned int  ============
@@ -818,7 +903,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<unsigned int>::is_convertible(value);
     }
@@ -836,7 +921,7 @@ namespace Rice::detail
   class From_Ruby<unsigned int&>
   {
   public:
-    using Pointer_T = Pointer<unsigned int>;
+    using Reference_T = Reference<unsigned int>;
 
     From_Ruby() = default;
 
@@ -844,13 +929,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -869,23 +954,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (unsigned int&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<unsigned int>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<unsigned int>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned int converted_ = 0;
+    Reference<unsigned int> reference_;
   };
 
   // ===========  long  ============
@@ -899,7 +985,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<long>::is_convertible(value);
     }
@@ -917,7 +1003,7 @@ namespace Rice::detail
   class From_Ruby<long&>
   {
   public:
-    using Pointer_T = Pointer<long>;
+    using Reference_T = Reference<long>;
 
     From_Ruby() = default;
 
@@ -925,13 +1011,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -950,23 +1036,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<long>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<long>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    long converted_ = 0;
+    Reference<long> reference_;
   };
 
   // ===========  unsigned long  ============
@@ -980,7 +1067,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<unsigned long>::is_convertible(value);
     }
@@ -1005,7 +1092,7 @@ namespace Rice::detail
   class From_Ruby<unsigned long&>
   {
   public:
-    using Pointer_T = Pointer<unsigned long>;
+    using Reference_T = Reference<unsigned long>;
 
     From_Ruby() = default;
 
@@ -1013,13 +1100,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -1038,23 +1125,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (unsigned long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<unsigned long>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<unsigned long>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned long converted_ = 0;
+    Reference<unsigned long> reference_;
   };
 
   // ===========  unsigned long long  ============
@@ -1068,7 +1156,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<unsigned long long>::is_convertible(value);
     }
@@ -1093,7 +1181,7 @@ namespace Rice::detail
   class From_Ruby<unsigned long long&>
   {
   public:
-    using Pointer_T = Pointer<unsigned long long>;
+    using Reference_T = Reference<unsigned long long>;
 
     From_Ruby() = default;
 
@@ -1101,13 +1189,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -1126,9 +1214,10 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (unsigned long long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
@@ -1144,7 +1233,7 @@ namespace Rice::detail
     Arg* arg_ = nullptr;
     unsigned long long converted_ = 0;
   };
- 
+
   // ===========  long long  ============
   template<>
   class From_Ruby<long long>
@@ -1156,7 +1245,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<long long>::is_convertible(value);
     }
@@ -1174,7 +1263,7 @@ namespace Rice::detail
   class From_Ruby<long long&>
   {
   public:
-    using Pointer_T = Pointer<long long>;
+    using Reference_T = Reference<long long>;
 
     From_Ruby() = default;
 
@@ -1182,13 +1271,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -1207,23 +1296,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (long long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<long long>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<long long>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    long long converted_ = 0;
+    Reference<long long> reference_;
   };
 
   // ===========  short  ============
@@ -1237,7 +1327,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<short>::is_convertible(value);
     }
@@ -1255,7 +1345,7 @@ namespace Rice::detail
   class From_Ruby<short&>
   {
   public:
-    using Pointer_T = Pointer<short>;
+    using Reference_T = Reference<short>;
 
     From_Ruby() = default;
 
@@ -1263,13 +1353,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -1288,23 +1378,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (short&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<short>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<short>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    short converted_ = 0;
+    Reference<short> reference_;
   };
 
   // ===========  unsigned short  ============
@@ -1318,7 +1409,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       return FromRubyFundamental<unsigned short>::is_convertible(value);
     }
@@ -1336,7 +1427,7 @@ namespace Rice::detail
   class From_Ruby<unsigned short&>
   {
   public:
-    using Pointer_T = Pointer<unsigned short>;
+    using Reference_T = Reference<unsigned short>;
 
     From_Ruby() = default;
 
@@ -1344,13 +1435,13 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -1369,23 +1460,24 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          if (Data_Type<Pointer_T>::is_descendant(value))
+          if (Data_Type<Reference_T>::is_descendant(value))
           {
-            return (unsigned short&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
           }
           [[fallthrough]];
         }
         default:
         {
-          this->converted_ = FromRubyFundamental<unsigned short>::convert(value);
-          return this->converted_;
+          this->reference_ = Reference<unsigned short>(value);
+          return this->reference_.get();
         }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned short converted_ = 0;
+    Reference<unsigned short> reference_;
   };
 
   // ===========  std::nullptr_t  ============
@@ -1403,7 +1495,7 @@ namespace Rice::detail
       }
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       if (this->arg_ && this->arg_->isOpaque())
       {
@@ -1445,7 +1537,7 @@ namespace Rice::detail
         }
         default:
         {
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
             detail::protect(rb_obj_classname, value), "nil");
         }
       }
@@ -1455,6 +1547,46 @@ namespace Rice::detail
   };
 
   // ===========  void  ============
+  template<>
+  class From_Ruby<void>
+  {
+  public:
+    From_Ruby()
+    {
+    };
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_->isOwner())
+      {
+        throw Exception(rb_eTypeError, "Cannot transfer ownership of C++ void pointer");
+      }
+    }
+
+    double is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_NIL:
+        {
+          return Convertible::Exact;
+          break;
+        }
+        default:
+        {
+          return Convertible::None;
+        }
+      }
+    }
+
+    void convert(VALUE)
+    {
+      // Nothing to do
+    }
+  private:
+    Arg* arg_ = nullptr;
+  };
+
   template<>
   class From_Ruby<void*>
   {
@@ -1471,7 +1603,7 @@ namespace Rice::detail
       }
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       if (this->arg_ && this->arg_->isOpaque())
       {
@@ -1482,21 +1614,22 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          return Convertible::Cast;
-          break;
+          return Convertible::Exact;
         }
         case RUBY_T_STRING:
         {
           if (RB_ENCODING_IS_ASCII8BIT(value))
+          {
             return Convertible::Exact;
+          }
           else
+          {
             return Convertible::None;
-          break;
+          }
         }
         case RUBY_T_NIL:
         {
           return Convertible::Exact;
-          break;
         }
         default:
         {
@@ -1550,7 +1683,7 @@ namespace Rice::detail
         }
         default:
         {
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
             detail::protect(rb_obj_classname, value), "pointer");
         }
       }