rice 4.3.2 → 4.5.0

data/rice/detail/from_ruby.ipp

@@ -1,19 +1,448 @@
-#ifndef Rice__detail__from_ruby__ipp_
-#define Rice__detail__from_ruby__ipp_
-
+#include <limits>
 #include <optional>
 #include <stdexcept>
-#include "../Exception_defn.hpp"
-#include "../Arg.hpp"
-#include "RubyFunction.hpp"
 
 /* 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
 {
-  // ===========  short  ============
+  inline Convertible operator&(Convertible left, Convertible right)
+  {
+    return static_cast<Convertible>(static_cast<uint8_t>(left) & static_cast<uint8_t>(right));
+  }
+
+  inline Convertible operator|(Convertible left, Convertible right)
+  {
+    return static_cast<Convertible>(static_cast<uint8_t>(left) | static_cast<uint8_t>(right));
+  }
+
+  inline bool operator<(Convertible left, Convertible right)
+  {
+    return static_cast<uint8_t>(left) < static_cast<uint8_t>(right);
+  }
+
+  // ===========  Helpers  ============
+  template<typename T>
+  class FromRubyFundamental
+  {
+  public:
+    using RubyType_T = RubyType<T>;
+
+    static Convertible 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())
+      {
+        return Convertible::Cast;
+      }
+      else if (RubyType_T::Narrowable.find(valueType) != RubyType_T::Narrowable.end())
+      {
+        return Convertible::Narrowable;
+      }
+      else
+      {
+        return Convertible::None;
+      }
+    }
+
+    static T convert(VALUE value)
+    {
+      return (T)protect(RubyType_T::fromRuby, value);
+    }
+  };
+
+  template<typename T>
+  class FromRubyFundamental<T*>
+  {
+  public:
+    using RubyType_T = RubyType<T>;
+
+    static Convertible 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 (valueType == RUBY_T_ARRAY)
+      {
+        return Convertible::Exact;
+      }
+      else if (valueType == RUBY_T_STRING)
+      {
+        // Maybe we should check for ascii8bit encoding?
+        //if (RB_ENCODING_IS_ASCII8BIT(value))
+        return Convertible::Exact;
+      }
+
+      return Convertible::None;
+    }
+
+    static std::unique_ptr<T[]> convert(VALUE value)
+    {
+      ruby_value_type valueType = rb_type(value);
+      switch (valueType)
+      {
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+          break;
+        }
+        case RUBY_T_ARRAY:
+        {
+          Array array(value);
+          return array.pack<T>();
+          break;
+        }
+        case RUBY_T_STRING:
+        {
+          long size = RSTRING_LEN(value);
+          // Add null character to end
+          std::unique_ptr<T[]> dest = std::make_unique<T[]>(size + 1);
+          dest.get()[size] = 0;
+          memcpy(dest.get(), RSTRING_PTR(value), size);
+
+          return std::move(dest);
+          break;
+        }
+        default:
+        {
+          if (RubyType_T::Exact.find(valueType) != RubyType_T::Exact.end() ||
+              RubyType_T::Castable.find(valueType) != RubyType_T::Castable.end() ||
+              RubyType_T::Narrowable.find(valueType) != RubyType_T::Narrowable.end())
+          {
+            std::unique_ptr<T[]> dest = std::make_unique<T[]>(1);
+            *(dest.get()) = (T)protect(RubyType_T::fromRuby, value);
+            return std::move(dest);
+          }
+          else
+          {
+            std::string typeName = detail::typeName(typeid(T));
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+              detail::protect(rb_obj_classname, value), typeName.c_str());
+          }
+        }
+      }
+    }
+  };
+
+  // ===========  bool  ============
+  template<>
+  class From_Ruby<bool>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<bool>::is_convertible(value);
+    }
+
+    bool convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<bool>();
+      }
+      else
+      {
+        return FromRubyFundamental<bool>::convert(value);
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<bool&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<bool>::is_convertible(value);
+    }
+
+    bool& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<bool>();
+      }
+      else
+      {
+        this->converted_ = FromRubyFundamental<bool>::convert(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    bool converted_ = false;
+  };
+
+  template<>
+  class From_Ruby<bool*>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        this->converted_.release();
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<bool>::is_convertible(value);
+    }
+
+    bool* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<bool*>::convert(value);
+      return this->converted_.get();
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    std::unique_ptr<bool[]> converted_;
+  };
+
+  // ===========  char  ============
+  template<>
+  class From_Ruby<char>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<char>::is_convertible(value);
+    }
+
+    char convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<char>();
+      }
+      else
+      {
+        return FromRubyFundamental<char>::convert(value);
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<char&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<char>::is_convertible(value);
+    }
+
+    char& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<char>();
+      }
+      else
+      {
+        this->converted_ = FromRubyFundamental<char>::convert(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    char converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<char*>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        this->converted_.release();
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<char*>::is_convertible(value);
+    }
+
+    char* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<char*>::convert(value);
+      return this->converted_.get();
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    std::unique_ptr<char[]> converted_;
+  };
+    
+  template<>
+  class From_Ruby<const char*>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        this->converted_.release();
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<char*>::is_convertible(value);
+    }
+
+    char* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<char*>::convert(value);
+      return this->converted_.get();
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    std::unique_ptr<char[]> converted_;
+  };
+
+  // ===========  unsigned char  ============
+  template<>
+  class From_Ruby<unsigned char>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned char>::is_convertible(value);
+    }
+
+    unsigned char convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned char>();
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned char>::convert(value);
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned char&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned char>::is_convertible(value);
+    }
+
+    unsigned char& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned char>();
+      }
+      else
+      {
+        this->converted_ = FromRubyFundamental<unsigned char>::convert(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    unsigned char converted_ = 0;
+  };
+
   template<>
-  class From_Ruby<short>
+  class From_Ruby<unsigned char*>
   {
   public:
     From_Ruby() = default;
@@ -22,29 +451,37 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_FIXNUM;
-    }
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
 
-    short convert(VALUE value)
+    ~From_Ruby()
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<short>();
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        return protect(rb_num2short_inline, value);
+        this->converted_.release();
       }
     }
-  
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned char*>::is_convertible(value);
+    }
+
+    unsigned char* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<unsigned char*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
     Arg* arg_ = nullptr;
+    std::unique_ptr<unsigned char[]> converted_;
   };
 
+  // ===========  signed char  ============
   template<>
-  class From_Ruby<short&>
+  class From_Ruby<signed char>
   {
   public:
     From_Ruby() = default;
@@ -53,58 +490,68 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<signed char>::is_convertible(value);
     }
 
-    short& convert(VALUE value)
+    signed char convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<short>();
+        return this->arg_->defaultValue<signed char>();
       }
       else
       {
-        this->converted_ = protect(rb_num2short_inline, value);
-        return this->converted_;
+        return FromRubyFundamental<signed char>::convert(value);
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    short converted_ = 0;
   };
 
   template<>
-  class From_Ruby<short*>
+  class From_Ruby<signed char*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    short* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2short_inline, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<signed char*>::is_convertible(value);
+    }
+
+    signed char* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<signed char*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
-    short converted_ = 0;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<signed char[]> converted_;
   };
 
-  // ===========  int  ============
+  // ===========  double  ============
   template<>
-  class From_Ruby<int>
+  class From_Ruby<double>
   {
   public:
     From_Ruby() = default;
@@ -113,29 +560,29 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<double>::is_convertible(value);
     }
 
-    int convert(VALUE value)
+    double convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<int>();
+        return this->arg_->defaultValue<double>();
       }
       else
       {
-        return (int)protect(rb_num2long_inline, value);
+        return FromRubyFundamental<double>::convert(value);
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<int&>
+  class From_Ruby<double&>
   {
   public:
     From_Ruby() = default;
@@ -144,58 +591,70 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<double>::is_convertible(value);
     }
 
-    int& convert(VALUE value)
+    double& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<int>();
+        return this->arg_->defaultValue<double>();
       }
       else
       {
-        this->converted_ = (int)protect(rb_num2long_inline, value);
+        this->converted_ = FromRubyFundamental<double>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    int converted_ = 0;
+    double converted_;
   };
 
   template<>
-  class From_Ruby<int*>
+  class From_Ruby<double*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    int* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = (int)protect(rb_num2long_inline, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<double*>::is_convertible(value);
+    }
+
+    double* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<double*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
-    int converted_;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<double[]> converted_;
   };
 
-  // ===========  long  ============
+  // ===========  float  ============
   template<>
-  class From_Ruby<long>
+  class From_Ruby<float>
   {
   public:
     From_Ruby() = default;
@@ -204,29 +663,29 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<float>::is_convertible(value);
     }
 
-    long convert(VALUE value)
+    float convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<long>();
+        return this->arg_->defaultValue<float>();
       }
       else
       {
-        return protect(rb_num2long_inline, value);
+        return FromRubyFundamental<float>::convert(value);
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<long&>
+  class From_Ruby<float&>
   {
   public:
     From_Ruby() = default;
@@ -235,58 +694,70 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<float>::is_convertible(value);
     }
 
-    long& convert(VALUE value)
+    float& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<long>();
+        return this->arg_->defaultValue<float>();
       }
       else
       {
-        this->converted_ = protect(rb_num2long_inline, value);
+        this->converted_ = FromRubyFundamental<float>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    long converted_ = 0;
+    float converted_;
   };
 
   template<>
-  class From_Ruby<long*>
+  class From_Ruby<float*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    long* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2long_inline, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<float*>::is_convertible(value);
+    }
+
+    float* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<float*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
-    long converted_ = 0;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<float[]> converted_;
   };
 
-  // ===========  long long  ============
+  // ===========  int  ============
   template<>
-  class From_Ruby<long long>
+  class From_Ruby<int>
   {
   public:
     From_Ruby() = default;
@@ -295,20 +766,31 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      Convertible 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)
+      {
+        static ID id = protect(rb_intern, "to_int");
+        if (protect(rb_respond_to, value, id))
+        {
+          result = Convertible::Cast;
+        }
+      }
+      return result;
     }
 
-    long long convert(VALUE value)
+    int convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<long long>();
+        return this->arg_->defaultValue<int>();
       }
       else
       {
-        return protect(rb_num2ll_inline, value);
+        return FromRubyFundamental<int>::convert(value);
       }
     }
   
@@ -317,7 +799,7 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<long long&>
+  class From_Ruby<int&>
   {
   public:
     From_Ruby() = default;
@@ -326,58 +808,70 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<int>::is_convertible(value);
     }
 
-    long long& convert(VALUE value)
+    int& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<long long>();
+        return this->arg_->defaultValue<int>();
       }
       else
       {
-        this->converted_ = protect(rb_num2ll_inline, value);
+        this->converted_ = FromRubyFundamental<int>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    long long converted_ = 0;
+    int converted_ = 0;
   };
 
   template<>
-  class From_Ruby<long long*>
+  class From_Ruby<int*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    long long* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2ll_inline, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<int*>::is_convertible(value);
+    }
+
+    int* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<int*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
-    long long converted_ = 0;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<int[]> converted_;
   };
 
-  // ===========  unsigned short  ============
+  // ===========  unsigned int  ============
   template<>
-  class From_Ruby<unsigned short>
+  class From_Ruby<unsigned int>
   {
   public:
     From_Ruby() = default;
@@ -386,29 +880,29 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned int>::is_convertible(value);
     }
 
-    unsigned short convert(VALUE value)
+    unsigned int convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<unsigned short>();
+        return this->arg_->defaultValue<unsigned int>();
       }
       else
       {
-        return protect(rb_num2ushort, value);
+        return FromRubyFundamental<unsigned int>::convert(value);
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<unsigned short&>
+  class From_Ruby<unsigned int&>
   {
   public:
     From_Ruby() = default;
@@ -417,58 +911,70 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned int>::is_convertible(value);
     }
 
-    unsigned short& convert(VALUE value)
+    unsigned int& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<unsigned short>();
+        return this->arg_->defaultValue<unsigned int>();
       }
       else
       {
-        this->converted_ = protect(rb_num2ushort, value);
+        this->converted_ = FromRubyFundamental<unsigned int>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned short converted_ = 0;
+    unsigned int converted_ = 0;
   };
 
   template<>
-  class From_Ruby<unsigned short*>
+  class From_Ruby<unsigned int*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    unsigned short* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2ushort, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned int*>::is_convertible(value);
+    }
+
+    unsigned int* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<unsigned int*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
-    unsigned short converted_ = 0;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<unsigned int[]> converted_;;
   };
 
-  // ===========  unsigned int  ============
+  // ===========  long  ============
   template<>
-  class From_Ruby<unsigned int>
+  class From_Ruby<long>
   {
   public:
     From_Ruby() = default;
@@ -477,20 +983,20 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<long>::is_convertible(value);
     }
 
-    unsigned int convert(VALUE value)
+    long convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<unsigned int>();
+        return this->arg_->defaultValue<long>();
       }
       else
       {
-        return (unsigned int)protect(rb_num2ulong_inline, value);
+        return FromRubyFundamental<long>::convert(value);
       }
     }
   
@@ -499,7 +1005,7 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<unsigned int&>
+  class From_Ruby<long&>
   {
   public:
     From_Ruby() = default;
@@ -508,53 +1014,65 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<long>::is_convertible(value);
     }
 
-    unsigned int& convert(VALUE value)
+    long& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<unsigned int>();
+        return this->arg_->defaultValue<long>();
       }
       else
       {
-        this->converted_ = (unsigned int)protect(rb_num2ulong_inline, value);
+        this->converted_ = FromRubyFundamental<long>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned int converted_ = 0;
+    long converted_ = 0;
   };
 
   template<>
-  class From_Ruby<unsigned int*>
+  class From_Ruby<long*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    unsigned int* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = (unsigned int)protect(rb_num2ulong_inline, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<long*>::is_convertible(value);
+    }
+
+    long* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<long*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
-    unsigned int converted_ = 0;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<long[]> converted_;
   };
 
   // ===========  unsigned long  ============
@@ -568,9 +1086,9 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned long>::is_convertible(value);
     }
 
     unsigned long convert(VALUE value)
@@ -585,10 +1103,10 @@ namespace Rice::detail
       }
       else
       {
-        return protect(rb_num2ulong_inline, value);
+        return FromRubyFundamental<unsigned long>::convert(value);
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
@@ -603,9 +1121,9 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned long>::is_convertible(value);
     }
 
     unsigned long& convert(VALUE value)
@@ -616,7 +1134,7 @@ namespace Rice::detail
       }
       else
       {
-        this->converted_ = protect(rb_num2ulong_inline, value);
+        this->converted_ = FromRubyFundamental<unsigned long>::convert(value);
         return this->converted_;
       }
     }
@@ -630,26 +1148,38 @@ namespace Rice::detail
   class From_Ruby<unsigned long*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    unsigned long* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2ulong_inline, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned long*>::is_convertible(value);
+    }
+
+    unsigned long* convert(VALUE value)
+    {
+      this->converted_ = FromRubyFundamental<unsigned long*>::convert(value);
+      return this->converted_.get();
+    }
+
   private:
-    unsigned long converted_ = 0;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<unsigned long[]> converted_;
   };
 
   // ===========  unsigned long long  ============
@@ -663,9 +1193,9 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned long long>::is_convertible(value);
     }
 
     unsigned long long convert(VALUE value)
@@ -680,10 +1210,10 @@ namespace Rice::detail
       }
       else
       {
-        return protect(rb_num2ull, value);
+        return FromRubyFundamental<unsigned long long>::convert(value);
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
@@ -698,9 +1228,9 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned long long>::is_convertible(value);
     }
 
     unsigned long long& convert(VALUE value)
@@ -711,7 +1241,7 @@ namespace Rice::detail
       }
       else
       {
-        this->converted_ = protect(rb_num2ull, value);
+        this->converted_ = FromRubyFundamental<unsigned long long>::convert(value);
         return this->converted_;
       }
     }
@@ -725,9 +1255,27 @@ namespace Rice::detail
   class From_Ruby<unsigned long long*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        this->converted_.release();
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned long long*>::is_convertible(value);
     }
 
     unsigned long long* convert(VALUE value)
@@ -738,18 +1286,19 @@ namespace Rice::detail
       }
       else
       {
-        this->converted_ = protect(rb_num2ull, value);
-        return &this->converted_;
+        this->converted_ = FromRubyFundamental<unsigned long long*>::convert(value);
+        return this->converted_.get();
       }
     }
 
   private:
-    unsigned long long converted_ = 0;
+    Arg* arg_ = nullptr;
+    std::unique_ptr<unsigned long long[]> converted_;
   };
 
-  // ===========  bool  ============
+// ===========  long long  ============
   template<>
-  class From_Ruby<bool>
+  class From_Ruby<long long>
   {
   public:
     From_Ruby() = default;
@@ -758,23 +1307,20 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      ruby_value_type ruby_type = (ruby_value_type)rb_type(value);
-      return ruby_type == RUBY_T_TRUE ||
-            ruby_type == RUBY_T_FALSE ||
-            ruby_type == RUBY_T_NIL;
+      return FromRubyFundamental<long long>::is_convertible(value);
     }
 
-    bool convert(VALUE value)
+    long long convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<bool>();
+        return this->arg_->defaultValue<long long>();
       }
       else
       {
-        return RTEST(value);
+        return FromRubyFundamental<long long>::convert(value);
       }
     }
   
@@ -783,7 +1329,7 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<bool&>
+  class From_Ruby<long long&>
   {
   public:
     From_Ruby() = default;
@@ -792,125 +1338,70 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      ruby_value_type ruby_type = (ruby_value_type)rb_type(value);
-      return ruby_type == RUBY_T_TRUE ||
-             ruby_type == RUBY_T_FALSE ||
-             ruby_type == RUBY_T_NIL;
+      return FromRubyFundamental<long long>::is_convertible(value);
     }
 
-    bool& convert(VALUE value)
+    long long& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<bool>();
+        return this->arg_->defaultValue<long long>();
       }
       else
       {
-        this->converted_ = RTEST(value);
+        this->converted_ = FromRubyFundamental<long long>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    bool converted_ = false;
+    long long converted_ = 0;
   };
 
   template<>
-  class From_Ruby<bool*>
+  class From_Ruby<long long*>
   {
   public:
-    bool is_convertible(VALUE value)
-    {
-      ruby_value_type ruby_type = (ruby_value_type)rb_type(value);
-      return ruby_type == RUBY_T_TRUE ||
-             ruby_type == RUBY_T_FALSE ||
-             ruby_type == RUBY_T_NIL;
-    }
+    From_Ruby() = default;
 
-    bool* convert(VALUE value)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        this->converted_ = RTEST(value);
-        return &this->converted_;
-      }
     }
 
-  private:
-    bool converted_ = false;
-  };
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
 
-  // ===========  char  ============
-  template<typename T>
-  inline T charFromRuby(VALUE value)
-  {
-    switch (rb_type(value))
+    ~From_Ruby()
     {
-      case T_STRING:
-      {
-        if (RSTRING_LEN(value) == 1)
-        {
-          return RSTRING_PTR(value)[0];
-        }
-        else
-        {
-          throw std::invalid_argument("from_ruby<char>: string must have length 1");
-        }
-        break;
-      }
-      case T_FIXNUM:
-      {
-        return From_Ruby<long>().convert(value) & 0xff;
-        break;
-      }
-      default:
+      if (this->arg_ && this->arg_->isOwner())
       {
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
-          detail::protect(rb_obj_classname, value), "char type");
+        this->converted_.release();
       }
     }
-  }
-  
-  template<>
-  class From_Ruby<char>
-  {
-  public:
-    From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg) : arg_(arg)
+    Convertible is_convertible(VALUE value)
     {
+      return FromRubyFundamental<long long*>::is_convertible(value);
     }
 
-    bool is_convertible(VALUE value)
+    long long* convert(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      this->converted_ = FromRubyFundamental<long long*>::convert(value);
+      return this->converted_.get();
     }
 
-    char convert(VALUE value)
-    {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<char>();
-      }
-      else
-      {
-        return charFromRuby<char>(value);
-      }
-    }
-  
   private:
     Arg* arg_ = nullptr;
+    std::unique_ptr<long long[]> converted_;
   };
 
+  // ===========  short  ============
   template<>
-  class From_Ruby<char&>
+  class From_Ruby<short>
   {
   public:
     From_Ruby() = default;
@@ -919,79 +1410,62 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      return FromRubyFundamental<short>::is_convertible(value);
     }
 
-    char& convert(VALUE value)
+    short convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<char>();
+        return this->arg_->defaultValue<short>();
       }
       else
       {
-        this->converted_ = charFromRuby<char>(value);
-        return this->converted_;
+        return FromRubyFundamental<short>::convert(value);
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    char converted_ = 0;
   };
 
   template<>
-  class From_Ruby<char*>
+  class From_Ruby<short&>
   {
   public:
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_STRING;
-    }
+    From_Ruby() = default;
 
-    char* convert(VALUE value)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        detail::protect(rb_check_type, value, (int)T_STRING);
-        return RSTRING_PTR(value);
-      }
     }
-  };
-  
-  // This is mostly for testing. NativeFunction removes const before calling From_Ruby
-  template<>
-  class From_Ruby<char const*>
-  {
-  public:
-    bool is_convertible(VALUE value)
+
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      return FromRubyFundamental<short>::is_convertible(value);
     }
 
-    char const* convert(VALUE value)
+    short& convert(VALUE value)
     {
-      if (value == Qnil)
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return nullptr;
+        return this->arg_->defaultValue<short>();
       }
       else
       {
-        detail::protect(rb_check_type, value, (int)T_STRING);
-        return RSTRING_PTR(value);
+        this->converted_ = FromRubyFundamental<short>::convert(value);
+        return this->converted_;
       }
     }
+
+  private:
+    Arg* arg_ = nullptr;
+    short converted_ = 0;
   };
 
-  // ===========  unsinged char  ============
   template<>
-  class From_Ruby<unsigned char>
+  class From_Ruby<short*>
   {
   public:
     From_Ruby() = default;
@@ -1000,62 +1474,37 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_STRING;
-    }
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
 
-    unsigned char convert(VALUE value)
+    ~From_Ruby()
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (this->arg_ && this->arg_->isOwner())
       {
-        return this->arg_->defaultValue<unsigned char>();
-      }
-      else
-      {
-        return charFromRuby<unsigned char>(value);
+        this->converted_.release();
       }
     }
-  
-  private:
-    Arg* arg_ = nullptr;
-  };
 
-  // ===========  signed char  ============
-  template<>
-  class From_Ruby<signed char>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
+    Convertible is_convertible(VALUE value)
     {
+      return FromRubyFundamental<short*>::is_convertible(value);
     }
 
-    bool is_convertible(VALUE value)
+    short* convert(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      this->converted_ = FromRubyFundamental<short*>::convert(value);
+      return this->converted_.get();
     }
 
-    signed char convert(VALUE value)
-    {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<signed char>();
-      }
-      else
-      {
-        return charFromRuby<signed char>(value);
-      }
-    }
-  
   private:
     Arg* arg_ = nullptr;
+    std::unique_ptr<short[]> converted_;
   };
 
-  // ===========  double  ============
+  // ===========  unsigned short  ============
   template<>
-  class From_Ruby<double>
+  class From_Ruby<unsigned short>
   {
   public:
     From_Ruby() = default;
@@ -1064,20 +1513,20 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
+      return FromRubyFundamental<unsigned short>::is_convertible(value);
     }
 
-    double convert(VALUE value)
+    unsigned short convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<double>();
+        return this->arg_->defaultValue<unsigned short>();
       }
       else
       {
-        return protect(rb_num2dbl, value);
+        return FromRubyFundamental<unsigned short>::convert(value);
       }
     }
   
@@ -1086,7 +1535,7 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<double&>
+  class From_Ruby<unsigned short&>
   {
   public:
     From_Ruby() = default;
@@ -1095,144 +1544,152 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
+      return FromRubyFundamental<unsigned short>::is_convertible(value);
     }
 
-    double& convert(VALUE value)
+    unsigned short& convert(VALUE value)
     {
       if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
       {
-        return this->arg_->defaultValue<double>();
+        return this->arg_->defaultValue<unsigned short>();
       }
       else
       {
-        this->converted_ = protect(rb_num2dbl, value);
+        this->converted_ = FromRubyFundamental<unsigned short>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    double converted_;
+    unsigned short converted_ = 0;
   };
 
   template<>
-  class From_Ruby<double*>
+  class From_Ruby<unsigned short*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
     }
 
-    double* convert(VALUE value)
+    // Need move constructor and assignment due to std::unique_ptr
+    From_Ruby(From_Ruby&& other) = default;
+    From_Ruby& operator=(From_Ruby&& other) = default;
+
+    ~From_Ruby()
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2dbl, value);
-        return &this->converted_;
+        this->converted_.release();
       }
     }
 
-  private:
-    double converted_;
-  };
-
-  // ===========  float  ============
-  template<>
-  class From_Ruby<float>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
+    Convertible is_convertible(VALUE value)
     {
+      return FromRubyFundamental<unsigned short*>::is_convertible(value);
     }
 
-    bool is_convertible(VALUE value)
+    unsigned short* convert(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
+      this->converted_ = FromRubyFundamental<unsigned short*>::convert(value);
+      return this->converted_.get();
     }
 
-    float convert(VALUE value)
-    {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<float>();
-      }
-      else
-      {
-        return (float)protect(rb_num2dbl, value);
-      }
-    }
-  
   private:
     Arg* arg_ = nullptr;
+    std::unique_ptr<unsigned short[]> converted_;
   };
 
   template<>
-  class From_Ruby<float&>
+  class From_Ruby<void*>
   {
   public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
+      if (this->arg_->isOwner())
+      {
+        throw Exception(rb_eTypeError, "Cannot transfer ownership of string data to C++ void pointer");
+      }
     }
 
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_FLOAT;
-    }
-
-    float& convert(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (this->arg_ && this->arg_->isOpaque())
       {
-        return this->arg_->defaultValue<float>();
+        return Convertible::Exact;
       }
-      else
+
+      switch (rb_type(value))
       {
-        this->converted_ = (float)protect(rb_num2dbl, value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          return Convertible::Exact;
+          break;
+        }
+        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:
+        {
+          return Convertible::None;
+        }
       }
     }
 
-  private:
-    Arg* arg_ = nullptr;
-    float converted_;
-  };
-
-  template<>
-  class From_Ruby<float*>
-  {
-  public:
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_FLOAT;
-    }
-
-    float* convert(VALUE value)
+    void* convert(VALUE value)
     {
-      if (value == Qnil)
+      if (this->arg_ && this->arg_->isOpaque())
       {
-        return nullptr;
+        return (void*)value;
       }
-      else
+
+      switch (rb_type(value))
       {
-        this->converted_ = (float)protect(rb_num2dbl, value);
-        return &this->converted_;
+        case RUBY_T_DATA:
+        {
+          // Since C++ is not telling us type information, we need to extract it
+          // from the Ruby object.
+          const rb_data_type_t* rb_type = RTYPEDDATA_TYPE(value);
+          return detail::unwrap<void>(value, (rb_data_type_t*)rb_type, this->arg_ && this->arg_->isOwner());
+          break;
+        }
+        case RUBY_T_STRING:
+        {
+          // String must be formatted in a way the receiver understands! This likely means it was created
+          // by Array.pack. Once the underlying string goes away the passed in data becomes invalid!
+          return (void*)RSTRING_PTR(value);
+          break;
+        }
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+          break;
+        }
+        default:
+        {
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            detail::protect(rb_obj_classname, value), "pointer");
+        }
       }
     }
-
   private:
-    float converted_;
+    Arg* arg_ = nullptr;
   };
-}
-#endif // Rice__detail__from_ruby__ipp_
+}