rice 4.3.3 → 4.6.0

data/rice/detail/from_ruby.ipp

@@ -1,110 +1,276 @@
-#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  ============
-  template<>
-  class From_Ruby<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:
-    From_Ruby() = default;
+    using RubyType_T = RubyType<T>;
 
-    explicit From_Ruby(Arg* arg) : arg_(arg)
+    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::Narrow;
+      }
+      else
+      {
+        return Convertible::None;
+      }
     }
 
-    bool is_convertible(VALUE value)
+    static T convert(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return (T)protect(RubyType_T::fromRuby, value);
     }
+  };
 
-    short convert(VALUE value)
+  template<typename T>
+  class FromRubyFundamental<T*>
+  {
+  public:
+    static Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      ruby_value_type valueType = rb_type(value);
+
+      switch (valueType)
       {
-        return this->arg_->defaultValue<short>();
+        case RUBY_T_NIL:
+        {
+          return Convertible::Exact;
+          break;
+        }
+        case RUBY_T_DATA:
+        {
+          return Data_Type<Buffer<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+        }
+        default:
+        {
+          return Convertible::None;
+        }
       }
-      else
+    }
+
+    static T* convert(VALUE value, Arg* arg)
+    {
+      ruby_value_type valueType = rb_type(value);
+
+      switch (valueType)
       {
-        return protect(rb_num2short_inline, value);
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+        }
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Buffer<T>>::is_descendant(value))
+          {
+            Buffer<T>* buffer = unwrap<Buffer<T>>(value, Data_Type<Buffer<T>>::ruby_data_type(), false);
+            if (arg && arg->isOwner())
+            {
+              buffer->release();
+            }
+            return buffer->ptr();
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          std::string name = typeName(typeid(Buffer<intrinsic_type<T>>));
+          std::string expected = rubyClassName(name);
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            detail::protect(rb_obj_classname, value), expected.c_str());
+        }
       }
     }
-  
+  };
+
+  template<typename T>
+  class FromRubyFundamental<T**>
+  {
+  public:
+    static Convertible is_convertible(VALUE value)
+    {
+      ruby_value_type valueType = rb_type(value);
+
+      switch (valueType)
+      {
+        case RUBY_T_NIL:
+        {
+          return Convertible::Exact;
+          break;
+        }
+        case RUBY_T_DATA:
+        {
+          return Data_Type<Buffer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+        }
+        default:
+        {
+          return Convertible::None;
+        }
+      }
+    }
+
+    static T** convert(VALUE value, Arg* arg)
+    {
+      ruby_value_type valueType = rb_type(value);
+
+      switch (valueType)
+      {
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+        }
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Buffer<T*>>::is_descendant(value))
+          {
+            Buffer<T*>* buffer = unwrap<Buffer<T*>>(value, Data_Type<Buffer<T*>>::ruby_data_type(), false);
+            if (arg && arg->isOwner())
+            {
+              buffer->release();
+            }
+            return buffer->ptr();
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          std::string name = typeName(typeid(Buffer<intrinsic_type<T>*>));
+          std::string expected = rubyClassName(name);
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            detail::protect(rb_obj_classname, value), expected.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)
+    {
+      return FromRubyFundamental<bool>::convert(value);
+    }
+
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<short&>
+  class From_Ruby<bool&>
   {
   public:
+    using Buffer_T = Buffer<bool>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<bool>::is_convertible(value);
+      }
     }
 
-    short& convert(VALUE value)
+    bool& convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<short>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
-        this->converted_ = protect(rb_num2short_inline, value);
+        this->converted_ = FromRubyFundamental<bool>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    short converted_ = 0;
+    bool converted_ = false;
   };
 
   template<>
-  class From_Ruby<short*>
+  class From_Ruby<bool*>
   {
   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)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        this->converted_ = protect(rb_num2short_inline, value);
-        return &this->converted_;
-      }
+      return FromRubyFundamental<bool>::is_convertible(value);
+    }
+
+    bool* convert(VALUE value)
+    {
+      return FromRubyFundamental<bool*>::convert(value, this->arg_);
     }
 
   private:
-    short converted_ = 0;
+    Arg* arg_ = nullptr;
   };
 
-  // ===========  int  ============
+  // ===========  char  ============
   template<>
-  class From_Ruby<int>
+  class From_Ruby<char>
   {
   public:
     From_Ruby() = default;
@@ -113,29 +279,65 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<char>::is_convertible(value);
     }
 
-    int convert(VALUE value)
+    char convert(VALUE value)
+    {
+      return FromRubyFundamental<char>::convert(value);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<char&>
+  {
+  public:
+    using Buffer_T = Buffer<char>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<int>();
+        return Convertible::Exact;
       }
       else
       {
-        return (int)protect(rb_num2long_inline, value);
+        return FromRubyFundamental<char>::is_convertible(value);
       }
     }
-  
+
+    char& convert(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
+      }
+      else
+      {
+        this->converted_ = FromRubyFundamental<char>::convert(value);
+        return this->converted_;
+      }
+    }
+
   private:
     Arg* arg_ = nullptr;
+    char converted_ = 0;
   };
 
   template<>
-  class From_Ruby<int&>
+  class From_Ruby<char*>
   {
   public:
     From_Ruby() = default;
@@ -144,58 +346,567 @@ namespace Rice::detail
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      switch (rb_type(value))
+      {
+        case RUBY_T_NIL:
+        {
+          return Convertible::Exact;
+        }
+        case RUBY_T_STRING:
+        {
+          return Convertible::Exact;
+        }
+        default:
+        {
+          return FromRubyFundamental<char*>::is_convertible(value);
+        }
+      }
     }
 
-    int& convert(VALUE value)
+    char* convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      switch (rb_type(value))
       {
-        return this->arg_->defaultValue<int>();
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+        }
+        case RUBY_T_STRING:
+        {
+          // WARNING - this shares the Ruby string memory directly with C++. value really should be frozen.
+          // Maybe we should enforce that? Note the user can always create a Buffer to allocate new memory.
+          return rb_string_value_cstr(&value);
+        }
+        default:
+        {
+          char* rb_string_value_cstr(volatile VALUE * ptr);
+          return FromRubyFundamental<char*>::convert(value, this->arg_);
+        }
       }
-      else
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+    
+  template<>
+  class From_Ruby<const char*> : public From_Ruby<char*>
+  {
+  };
+
+  template<>
+  class From_Ruby<char**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = (int)protect(rb_num2long_inline, value);
-        return this->converted_;
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<char**>::is_convertible(value);
+    }
+
+    char** convert(VALUE value)
+    {
+      return FromRubyFundamental<char**>::convert(value, this->arg_);
+    }
+
   private:
     Arg* arg_ = nullptr;
-    int converted_ = 0;
   };
 
+  // ===========  unsigned char  ============
   template<>
-  class From_Ruby<int*>
+  class From_Ruby<unsigned char>
   {
   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)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
+      return FromRubyFundamental<unsigned char>::is_convertible(value);
+    }
+
+    unsigned char convert(VALUE value)
+    {
+      return FromRubyFundamental<unsigned char>::convert(value);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned char&>
+  {
+  public:
+    using Buffer_T = Buffer<unsigned char>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return nullptr;
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned char>::is_convertible(value);
+      }
+    }
+
+    unsigned char& convert(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
-        this->converted_ = (int)protect(rb_num2long_inline, value);
-        return &this->converted_;
+        this->converted_ = FromRubyFundamental<unsigned char>::convert(value);
+        return this->converted_;
       }
     }
 
   private:
-    int converted_;
+    Arg* arg_ = nullptr;
+    unsigned char converted_ = 0;
   };
 
-  // ===========  long  ============
   template<>
-  class From_Ruby<long>
+  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)
+    {
+      return FromRubyFundamental<unsigned char*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned char**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned char**>::is_convertible(value);
+    }
+
+    unsigned char** convert(VALUE value)
+    {
+      return FromRubyFundamental<unsigned char**>::convert(value, this->arg_);
+    }
+
+  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<signed char>::is_convertible(value);
+    }
+
+    signed char convert(VALUE value)
+    {
+      return FromRubyFundamental<signed char>::convert(value);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<signed char&>
+  {
+  public:
+    using Buffer_T = Buffer<signed char>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<signed char>::is_convertible(value);
+      }
+    }
+
+    signed char& convert(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
+      }
+      else
+      {
+        this->converted_ = FromRubyFundamental<signed char>::convert(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    signed char converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<signed char*>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<signed char*>::is_convertible(value);
+    }
+
+    signed char* convert(VALUE value)
+    {
+      return FromRubyFundamental<signed char*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<signed char**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<signed char**>::is_convertible(value);
+    }
+
+    signed char** convert(VALUE value)
+    {
+      return FromRubyFundamental<signed char**>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  // ===========  double  ============
+  template<>
+  class From_Ruby<double>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<double>::is_convertible(value);
+    }
+
+    double convert(VALUE value)
+    {
+      return FromRubyFundamental<double>::convert(value);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<double&>
+  {
+  public:
+    using Buffer_T = Buffer<double>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<double>::is_convertible(value);
+      }
+    }
+
+    double& convert(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
+      }
+      else
+      {
+        this->converted_ = FromRubyFundamental<double>::convert(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    double converted_;
+  };
+
+  template<>
+  class From_Ruby<double*>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<double*>::is_convertible(value);
+    }
+
+    double* convert(VALUE value)
+    {
+      return FromRubyFundamental<double*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<double**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<double**>::is_convertible(value);
+    }
+
+    double** convert(VALUE value)
+    {
+      return FromRubyFundamental<double**>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  // ===========  float  ============
+  template<>
+  class From_Ruby<float>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<float>::is_convertible(value);
+    }
+
+    float convert(VALUE value)
+    {
+      return FromRubyFundamental<float>::convert(value);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<float&>
+  {
+  public:
+    using Buffer_T = Buffer<float>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<float>::is_convertible(value);
+      }
+    }
+
+    float& convert(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
+      }
+      else
+      {
+        this->converted_ = FromRubyFundamental<float>::convert(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    float converted_;
+  };
+
+  template<>
+  class From_Ruby<float*>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<float*>::is_convertible(value);
+    }
+
+    float* convert(VALUE value)
+    {
+      return FromRubyFundamental<float*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<float**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<float**>::is_convertible(value);
+    }
+
+    float** convert(VALUE value)
+    {
+      return FromRubyFundamental<float**>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  // ===========  int  ============
+  template<>
+  class From_Ruby<int>
   {
   public:
     From_Ruby() = default;
@@ -204,21 +915,25 @@ 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);
 
-    long convert(VALUE value)
-    {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<long>();
-      }
-      else
+      // 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)
       {
-        return protect(rb_num2long_inline, value);
+        static ID id = protect(rb_intern, "to_int");
+        if (protect(rb_respond_to, value, id))
+        {
+          result = Convertible::Cast;
+        }
       }
+      return result;
+    }
+
+    int convert(VALUE value)
+    {
+      return FromRubyFundamental<int>::convert(value);
     }
   
   private:
@@ -226,98 +941,103 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<long&>
+  class From_Ruby<int&>
   {
   public:
+    using Buffer_T = Buffer<int>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<int>::is_convertible(value);
+      }
     }
 
-    long& convert(VALUE value)
+    int& convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<long>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
-        this->converted_ = protect(rb_num2long_inline, value);
+        this->converted_ = FromRubyFundamental<int>::convert(value);
         return this->converted_;
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    long converted_ = 0;
+    int converted_ = 0;
   };
 
   template<>
-  class From_Ruby<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* convert(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        this->converted_ = protect(rb_num2long_inline, value);
-        return &this->converted_;
-      }
+      return FromRubyFundamental<int*>::is_convertible(value);
+    }
+
+    int* convert(VALUE value)
+    {
+      return FromRubyFundamental<int*>::convert(value, this->arg_);
     }
 
   private:
-    long converted_ = 0;
+    Arg* arg_ = nullptr;
   };
 
-  // ===========  long long  ============
   template<>
-  class From_Ruby<long long>
+  class From_Ruby<int**>
   {
   public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
     }
 
-    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>();
-      }
-      else
-      {
-        return protect(rb_num2ll_inline, value);
-      }
+      return FromRubyFundamental<int**>::convert(value, this->arg_);
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
+  // ===========  unsigned int  ============
   template<>
-  class From_Ruby<long long&>
+  class From_Ruby<unsigned int>
   {
   public:
     From_Ruby() = default;
@@ -326,58 +1046,65 @@ 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);
     }
 
-    long long& convert(VALUE value)
+    unsigned int convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<long long>();
-      }
-      else
-      {
-        this->converted_ = protect(rb_num2ll_inline, value);
-        return this->converted_;
-      }
+      return FromRubyFundamental<unsigned int>::convert(value);
     }
 
   private:
     Arg* arg_ = nullptr;
-    long long converted_ = 0;
   };
 
   template<>
-  class From_Ruby<long long*>
+  class From_Ruby<unsigned int&>
   {
   public:
-    bool is_convertible(VALUE value)
+    using Buffer_T = Buffer<unsigned int>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
     }
 
-    long long* convert(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return nullptr;
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned int>::is_convertible(value);
+      }
+    }
+
+    unsigned int& convert(VALUE value)
+    {
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
-        this->converted_ = protect(rb_num2ll_inline, value);
-        return &this->converted_;
+        this->converted_ = FromRubyFundamental<unsigned int>::convert(value);
+        return this->converted_;
       }
     }
 
   private:
-    long long converted_ = 0;
+    Arg* arg_ = nullptr;
+    unsigned int converted_ = 0;
   };
 
-  // ===========  unsigned short  ============
   template<>
-  class From_Ruby<unsigned short>
+  class From_Ruby<unsigned int*>
   {
   public:
     From_Ruby() = default;
@@ -386,120 +1113,118 @@ 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>();
-      }
-      else
-      {
-        return protect(rb_num2ushort, value);
-      }
+      return FromRubyFundamental<unsigned int*>::convert(value, this->arg_);
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<unsigned short&>
+  class From_Ruby<unsigned int**>
   {
   public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
     }
 
-    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>();
-      }
-      else
-      {
-        this->converted_ = protect(rb_num2ushort, value);
-        return this->converted_;
-      }
+      return FromRubyFundamental<unsigned int**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned short converted_ = 0;
   };
 
+  // ===========  long  ============
   template<>
-  class From_Ruby<unsigned short*>
+  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 short* convert(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        this->converted_ = protect(rb_num2ushort, value);
-        return &this->converted_;
-      }
+      return FromRubyFundamental<long>::is_convertible(value);
     }
 
+    long convert(VALUE value)
+    {
+      return FromRubyFundamental<long>::convert(value);
+    }
+  
   private:
-    unsigned short converted_ = 0;
+    Arg* arg_ = nullptr;
   };
 
-  // ===========  unsigned int  ============
   template<>
-  class From_Ruby<unsigned int>
+  class From_Ruby<long&>
   {
   public:
+    using Buffer_T = Buffer<long>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<long>::is_convertible(value);
+      }
     }
 
-    unsigned int convert(VALUE value)
+    long& convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<unsigned int>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
-        return (unsigned int)protect(rb_num2ulong_inline, value);
+        this->converted_ = FromRubyFundamental<long>::convert(value);
+        return this->converted_;
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
+    long converted_ = 0;
   };
 
   template<>
-  class From_Ruby<unsigned int&>
+  class From_Ruby<long*>
   {
   public:
     From_Ruby() = default;
@@ -508,53 +1233,46 @@ 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>();
-      }
-      else
-      {
-        this->converted_ = (unsigned int)protect(rb_num2ulong_inline, value);
-        return this->converted_;
-      }
+      return FromRubyFundamental<long*>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned int converted_ = 0;
   };
 
   template<>
-  class From_Ruby<unsigned int*>
+  class From_Ruby<long**>
   {
   public:
-    bool is_convertible(VALUE value)
-    {
-      return rb_type(value) == RUBY_T_FIXNUM;
-    }
+    From_Ruby() = default;
 
-    unsigned int* convert(VALUE value)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = (unsigned int)protect(rb_num2ulong_inline, value);
-        return &this->converted_;
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<long**>::is_convertible(value);
+    }
+
+    long** convert(VALUE value)
+    {
+      return FromRubyFundamental<long**>::convert(value, this->arg_);
+    }
+
   private:
-    unsigned int converted_ = 0;
+    Arg* arg_ = nullptr;
   };
 
   // ===========  unsigned long  ============
@@ -568,9 +1286,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)
@@ -579,16 +1297,12 @@ namespace Rice::detail
       {
         return (unsigned long)value;
       }
-      else if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<unsigned long>();
-      }
       else
       {
-        return protect(rb_num2ulong_inline, value);
+        return FromRubyFundamental<unsigned long>::convert(value);
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
@@ -597,26 +1311,36 @@ namespace Rice::detail
   class From_Ruby<unsigned long&>
   {
   public:
+    using Buffer_T = Buffer<unsigned long>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned long>::is_convertible(value);
+      }
     }
 
     unsigned long& convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<unsigned long>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
-        this->converted_ = protect(rb_num2ulong_inline, value);
+        this->converted_ = FromRubyFundamental<unsigned long>::convert(value);
         return this->converted_;
       }
     }
@@ -630,26 +1354,52 @@ namespace Rice::detail
   class From_Ruby<unsigned long*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      return FromRubyFundamental<unsigned long*>::is_convertible(value);
     }
 
     unsigned long* convert(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      return FromRubyFundamental<unsigned long*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned long**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2ulong_inline, value);
-        return &this->converted_;
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned long**>::is_convertible(value);
+    }
+
+    unsigned long** convert(VALUE value)
+    {
+      return FromRubyFundamental<unsigned long**>::convert(value, this->arg_);
+    }
+
   private:
-    unsigned long converted_ = 0;
+    Arg* arg_ = nullptr;
   };
 
   // ===========  unsigned long long  ============
@@ -663,9 +1413,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)
@@ -674,16 +1424,12 @@ namespace Rice::detail
       {
         return value;
       }
-      else if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<unsigned long long>();
-      }
       else
       {
-        return protect(rb_num2ull, value);
+        return FromRubyFundamental<unsigned long long>::convert(value);
       }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
@@ -692,26 +1438,36 @@ namespace Rice::detail
   class From_Ruby<unsigned long long&>
   {
   public:
+    using Buffer_T = Buffer<unsigned long long>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned long long>::is_convertible(value);
+      }
     }
 
     unsigned long long& convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<unsigned long long>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
-        this->converted_ = protect(rb_num2ull, value);
+        this->converted_ = FromRubyFundamental<unsigned long long>::convert(value);
         return this->converted_;
       }
     }
@@ -725,31 +1481,57 @@ 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)
     {
-      return rb_type(value) == RUBY_T_FIXNUM;
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned long long*>::is_convertible(value);
     }
 
     unsigned long long* convert(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
+      return FromRubyFundamental<unsigned long long*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned long long**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_ = protect(rb_num2ull, value);
-        return &this->converted_;
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned long long**>::is_convertible(value);
+    }
+
+    unsigned long long** convert(VALUE value)
+    {
+      return FromRubyFundamental<unsigned long long**>::convert(value, this->arg_);
+    }
+
   private:
-    unsigned long long converted_ = 0;
+    Arg* arg_ = nullptr;
   };
-
-  // ===========  bool  ============
+  
+  // ===========  long long  ============
   template<>
-  class From_Ruby<bool>
+  class From_Ruby<long long>
   {
   public:
     From_Ruby() = default;
@@ -758,24 +1540,14 @@ 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>();
-      }
-      else
-      {
-        return RTEST(value);
-      }
+      return FromRubyFundamental<long long>::convert(value);
     }
   
   private:
@@ -783,134 +1555,103 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<bool&>
+  class From_Ruby<long long&>
   {
   public:
+    using Buffer_T = Buffer<long long>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    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;
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<long long>::is_convertible(value);
+      }
     }
 
-    bool& convert(VALUE value)
+    long long& convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<bool>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       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)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      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;
     }
 
-    bool* convert(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        this->converted_ = RTEST(value);
-        return &this->converted_;
-      }
+      return FromRubyFundamental<long long*>::is_convertible(value);
+    }
+
+    long long* convert(VALUE value)
+    {
+      return FromRubyFundamental<long long*>::convert(value, this->arg_);
     }
 
   private:
-    bool converted_ = false;
+    Arg* arg_ = nullptr;
   };
 
-  // ===========  char  ============
-  template<typename T>
-  inline T charFromRuby(VALUE value)
-  {
-    switch (rb_type(value))
-    {
-      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:
-      {
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
-          detail::protect(rb_obj_classname, value), "char type");
-      }
-    }
-  }
-  
   template<>
-  class From_Ruby<char>
+  class From_Ruby<long long**>
   {
   public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      return FromRubyFundamental<long long**>::is_convertible(value);
     }
 
-    char convert(VALUE value)
+    long long** convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<char>();
-      }
-      else
-      {
-        return charFromRuby<char>(value);
-      }
+      return FromRubyFundamental<long long**>::convert(value, this->arg_);
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
+  // ===========  short  ============
   template<>
-  class From_Ruby<char&>
+  class From_Ruby<short>
   {
   public:
     From_Ruby() = default;
@@ -919,79 +1660,65 @@ 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>();
-      }
-      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)
+    using Buffer_T = Buffer<short>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_STRING;
     }
 
-    char* convert(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return nullptr;
+        return Convertible::Exact;
       }
       else
       {
-        detail::protect(rb_check_type, value, (int)T_STRING);
-        return RSTRING_PTR(value);
+        return FromRubyFundamental<short>::is_convertible(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)
-    {
-      return rb_type(value) == RUBY_T_STRING;
-    }
 
-    char const* convert(VALUE value)
+    short& convert(VALUE value)
     {
-      if (value == Qnil)
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return nullptr;
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       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 +1727,50 @@ 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);
     }
 
-    unsigned char convert(VALUE value)
+    short* convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<unsigned char>();
-      }
-      else
-      {
-        return charFromRuby<unsigned char>(value);
-      }
+      return FromRubyFundamental<short*>::convert(value, this->arg_);
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
-  // ===========  signed char  ============
   template<>
-  class From_Ruby<signed char>
+  class From_Ruby<short**>
   {
   public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_STRING;
+      return FromRubyFundamental<short**>::is_convertible(value);
     }
 
-    signed char convert(VALUE value)
+    short** convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<signed char>();
-      }
-      else
-      {
-        return charFromRuby<signed char>(value);
-      }
+      return FromRubyFundamental<short**>::convert(value, this->arg_);
     }
-  
   private:
     Arg* arg_ = nullptr;
   };
 
-  // ===========  double  ============
+  // ===========  unsigned short  ============
   template<>
-  class From_Ruby<double>
+  class From_Ruby<unsigned short>
   {
   public:
     From_Ruby() = default;
@@ -1064,21 +1779,14 @@ 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>();
-      }
-      else
-      {
-        return protect(rb_num2dbl, value);
-      }
+      return FromRubyFundamental<unsigned short>::convert(value);
     }
   
   private:
@@ -1086,153 +1794,274 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<double&>
+  class From_Ruby<unsigned short&>
   {
   public:
+    using Buffer_T = Buffer<unsigned short>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned short>::is_convertible(value);
+      }
     }
 
-    double& convert(VALUE value)
+    unsigned short& convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
       {
-        return this->arg_->defaultValue<double>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       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)
+    Convertible is_convertible(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        this->converted_ = protect(rb_num2dbl, value);
-        return &this->converted_;
-      }
+      return FromRubyFundamental<unsigned short*>::is_convertible(value);
+    }
+
+    unsigned short* convert(VALUE value)
+    {
+      return FromRubyFundamental<unsigned short*>::convert(value, this->arg_);
     }
 
   private:
-    double converted_;
+    Arg* arg_ = nullptr;
   };
 
-  // ===========  float  ============
   template<>
-  class From_Ruby<float>
+  class From_Ruby<unsigned short**>
   {
   public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
+      if (this->arg_ && this->arg_->isOwner())
+      {
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+      }
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
+      return FromRubyFundamental<unsigned short**>::is_convertible(value);
     }
 
-    float convert(VALUE value)
+    unsigned short** convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<float>();
-      }
-      else
-      {
-        return (float)protect(rb_num2dbl, value);
-      }
+      return FromRubyFundamental<unsigned short**>::convert(value, this->arg_);
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
+  // ===========  std::nullptr_t  ============
   template<>
-  class From_Ruby<float&>
+  class From_Ruby<std::nullptr_t>
   {
   public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
     {
+      if (this->arg_->isOwner())
+      {
+        throw Exception(rb_eTypeError, "Cannot transfer ownership of C++ void pointer");
+      }
     }
 
-    bool is_convertible(VALUE value)
+    Convertible is_convertible(VALUE value)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
+      if (this->arg_ && this->arg_->isOpaque())
+      {
+        return Convertible::Exact;
+      }
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_NIL:
+        {
+          return Convertible::Exact;
+          break;
+        }
+        default:
+        {
+          return Convertible::None;
+        }
+      }
     }
 
-    float& convert(VALUE value)
+    void* convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      if (value == Qnil)
       {
-        return this->arg_->defaultValue<float>();
+        return nullptr;
       }
-      else
+
+      if (this->arg_ && this->arg_->isOpaque())
       {
-        this->converted_ = (float)protect(rb_num2dbl, value);
-        return this->converted_;
+        return (void*)value;
       }
-    }
 
+      switch (rb_type(value))
+      {
+        case RUBY_T_NIL:
+        {
+          return nullptr;
+          break;
+        }
+        default:
+        {
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            detail::protect(rb_obj_classname, value), "nil");
+        }
+      }
+    }
   private:
     Arg* arg_ = nullptr;
-    float converted_;
   };
 
+  // ===========  void  ============
   template<>
-  class From_Ruby<float*>
+  class From_Ruby<void*>
   {
   public:
-    bool is_convertible(VALUE value)
+    From_Ruby()
+    {
+      detail::Type<Buffer<void>>::verify();
+    };
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
-      return rb_type(value) == RUBY_T_FLOAT;
+      detail::Type<Buffer<void>>::verify();
+
+      if (this->arg_->isOwner())
+      {
+        throw Exception(rb_eTypeError, "Cannot transfer ownership of C++ void pointer");
+      }
     }
 
-    float* convert(VALUE value)
+    Convertible is_convertible(VALUE value)
+    {
+      if (this->arg_ && this->arg_->isOpaque())
+      {
+        return Convertible::Exact;
+      }
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          return Convertible::Cast;
+          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;
+        }
+      }
+    }
+
+    void* convert(VALUE value)
     {
       if (value == Qnil)
       {
         return nullptr;
       }
-      else
+
+      if (this->arg_ && this->arg_->isOpaque())
       {
-        this->converted_ = (float)protect(rb_num2dbl, value);
-        return &this->converted_;
+        return (void*)value;
       }
-    }
 
+      switch (rb_type(value))
+      {
+        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);
+
+          // Is this a Buffer? It could also be a pointer to any other object being passed to 
+          // a C++ paramter that takes void*
+          if (rb_type == Data_Type<Buffer<void>>::ruby_data_type())
+          {
+            Data_Object<Buffer<void>> buffer(value);
+            return buffer->ptr();
+          }
+          else 
+          {
+            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_
+}