rice 4.5.0 → 4.6.0

data/rice/detail/from_ruby.ipp

@@ -42,7 +42,7 @@ namespace Rice::detail
       }
       else if (RubyType_T::Narrowable.find(valueType) != RubyType_T::Narrowable.end())
       {
-        return Convertible::Narrowable;
+        return Convertible::Narrow;
       }
       else
       {
@@ -60,73 +60,117 @@ namespace Rice::detail
   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)
+      switch (valueType)
       {
-        // Maybe we should check for ascii8bit encoding?
-        //if (RB_ENCODING_IS_ASCII8BIT(value))
-        return Convertible::Exact;
+        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;
+        }
       }
-
-      return Convertible::None;
     }
 
-    static std::unique_ptr<T[]> convert(VALUE value)
+    static T* convert(VALUE value, Arg* arg)
     {
       ruby_value_type valueType = rb_type(value);
+
       switch (valueType)
       {
         case RUBY_T_NIL:
         {
           return nullptr;
-          break;
         }
-        case RUBY_T_ARRAY:
+        case RUBY_T_DATA:
         {
-          Array array(value);
-          return array.pack<T>();
-          break;
+          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]];
         }
-        case RUBY_T_STRING:
+        default:
         {
-          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);
+          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());
+        }
+      }
+    }
+  };
 
-          return std::move(dest);
+  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:
         {
-          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
+          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))
           {
-            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());
+            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());
         }
       }
     }
@@ -150,14 +194,7 @@ namespace Rice::detail
 
     bool convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<bool>();
-      }
-      else
-      {
-        return FromRubyFundamental<bool>::convert(value);
-      }
+      return FromRubyFundamental<bool>::convert(value);
     }
 
   private:
@@ -168,6 +205,8 @@ namespace Rice::detail
   class From_Ruby<bool&>
   {
   public:
+    using Buffer_T = Buffer<bool>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -176,14 +215,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<bool>::is_convertible(value);
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<bool>::is_convertible(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<bool>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -207,18 +254,6 @@ namespace Rice::detail
     {
     }
 
-    // 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);
@@ -226,13 +261,11 @@ namespace Rice::detail
 
     bool* convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<bool*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<bool*>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<bool[]> converted_;
   };
 
   // ===========  char  ============
@@ -253,14 +286,7 @@ namespace Rice::detail
 
     char convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<char>();
-      }
-      else
-      {
-        return FromRubyFundamental<char>::convert(value);
-      }
+      return FromRubyFundamental<char>::convert(value);
     }
 
   private:
@@ -271,6 +297,8 @@ namespace Rice::detail
   class From_Ruby<char&>
   {
   public:
+    using Buffer_T = Buffer<char>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -279,14 +307,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<char>::is_convertible(value);
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<char>::is_convertible(value);
+      }
     }
 
     char& 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<char>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -310,70 +346,82 @@ namespace Rice::detail
     {
     }
 
-    // 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()
+    Convertible is_convertible(VALUE value)
     {
-      if (this->arg_ && this->arg_->isOwner())
+      switch (rb_type(value))
       {
-        this->converted_.release();
+        case RUBY_T_NIL:
+        {
+          return Convertible::Exact;
+        }
+        case RUBY_T_STRING:
+        {
+          return Convertible::Exact;
+        }
+        default:
+        {
+          return FromRubyFundamental<char*>::is_convertible(value);
+        }
       }
     }
 
-    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();
+      switch (rb_type(value))
+      {
+        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_);
+        }
+      }
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<char[]> converted_;
   };
     
   template<>
-  class From_Ruby<const char*>
+  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)
-    {
-    }
-
-    // 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();
+        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);
+      return FromRubyFundamental<char**>::is_convertible(value);
     }
 
-    char* convert(VALUE value)
+    char** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<char*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<char**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<char[]> converted_;
   };
 
   // ===========  unsigned char  ============
@@ -394,14 +442,7 @@ namespace Rice::detail
 
     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);
-      }
+      return FromRubyFundamental<unsigned char>::convert(value);
     }
 
   private:
@@ -412,6 +453,8 @@ namespace Rice::detail
   class From_Ruby<unsigned char&>
   {
   public:
+    using Buffer_T = Buffer<unsigned char>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -420,14 +463,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned char>::is_convertible(value);
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned char>::is_convertible(value);
+      }
     }
 
     unsigned char& 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 char>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -451,32 +502,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned char*>::is_convertible(value);
+    }
 
-    ~From_Ruby()
+    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())
       {
-        this->converted_.release();
+        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);
+      return FromRubyFundamental<unsigned char**>::is_convertible(value);
     }
 
-    unsigned char* convert(VALUE value)
+    unsigned char** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<unsigned char*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<unsigned char**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<unsigned char[]> converted_;
   };
 
   // ===========  signed char  ============
@@ -497,18 +562,54 @@ namespace Rice::detail
 
     signed char convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      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 this->arg_->defaultValue<signed char>();
+        return Convertible::Exact;
       }
       else
       {
-        return FromRubyFundamental<signed char>::convert(value);
+        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<>
@@ -521,32 +622,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    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;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        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);
+      return FromRubyFundamental<signed char**>::is_convertible(value);
     }
 
-    signed char* convert(VALUE value)
+    signed char** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<signed char*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<signed char**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<signed char[]> converted_;
   };
 
   // ===========  double  ============
@@ -567,14 +682,7 @@ namespace Rice::detail
 
     double convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<double>();
-      }
-      else
-      {
-        return FromRubyFundamental<double>::convert(value);
-      }
+      return FromRubyFundamental<double>::convert(value);
     }
 
   private:
@@ -585,6 +693,8 @@ namespace Rice::detail
   class From_Ruby<double&>
   {
   public:
+    using Buffer_T = Buffer<double>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -593,14 +703,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<double>::is_convertible(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 (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
       {
@@ -624,32 +742,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<double*>::is_convertible(value);
+    }
 
-    ~From_Ruby()
+    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())
       {
-        this->converted_.release();
+        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);
+      return FromRubyFundamental<double**>::is_convertible(value);
     }
 
-    double* convert(VALUE value)
+    double** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<double*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<double**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<double[]> converted_;
   };
 
   // ===========  float  ============
@@ -670,14 +802,7 @@ namespace Rice::detail
 
     float convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<float>();
-      }
-      else
-      {
-        return FromRubyFundamental<float>::convert(value);
-      }
+      return FromRubyFundamental<float>::convert(value);
     }
 
   private:
@@ -688,6 +813,8 @@ namespace Rice::detail
   class From_Ruby<float&>
   {
   public:
+    using Buffer_T = Buffer<float>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -696,14 +823,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<float>::is_convertible(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 (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<float>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -727,32 +862,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    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;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        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);
+      return FromRubyFundamental<float**>::is_convertible(value);
     }
 
-    float* convert(VALUE value)
+    float** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<float*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<float**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<float[]> converted_;
   };
 
   // ===========  int  ============
@@ -784,14 +933,7 @@ namespace Rice::detail
 
     int convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<int>();
-      }
-      else
-      {
-        return FromRubyFundamental<int>::convert(value);
-      }
+      return FromRubyFundamental<int>::convert(value);
     }
   
   private:
@@ -802,6 +944,8 @@ namespace Rice::detail
   class From_Ruby<int&>
   {
   public:
+    using Buffer_T = Buffer<int>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -810,14 +954,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<int>::is_convertible(value);
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<int>::is_convertible(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<int>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -841,32 +993,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<int*>::is_convertible(value);
+    }
+
+    int* convert(VALUE value)
+    {
+      return FromRubyFundamental<int*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<int**>
+  {
+  public:
+    From_Ruby() = default;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<int*>::is_convertible(value);
+      return FromRubyFundamental<int**>::is_convertible(value);
     }
 
-    int* convert(VALUE value)
+    int** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<int*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<int**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<int[]> converted_;
   };
 
   // ===========  unsigned int  ============
@@ -887,14 +1053,7 @@ namespace Rice::detail
 
     unsigned int convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<unsigned int>();
-      }
-      else
-      {
-        return FromRubyFundamental<unsigned int>::convert(value);
-      }
+      return FromRubyFundamental<unsigned int>::convert(value);
     }
 
   private:
@@ -905,6 +1064,8 @@ namespace Rice::detail
   class From_Ruby<unsigned int&>
   {
   public:
+    using Buffer_T = Buffer<unsigned int>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -913,14 +1074,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned int>::is_convertible(value);
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned int>::is_convertible(value);
+      }
     }
 
     unsigned 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<unsigned int>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -944,32 +1113,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned int*>::is_convertible(value);
+    }
 
-    ~From_Ruby()
+    unsigned int* convert(VALUE value)
+    {
+      return FromRubyFundamental<unsigned int*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned int**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned int*>::is_convertible(value);
+      return FromRubyFundamental<unsigned int**>::is_convertible(value);
     }
 
-    unsigned int* convert(VALUE value)
+    unsigned int** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<unsigned int*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<unsigned int**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<unsigned int[]> converted_;;
   };
 
   // ===========  long  ============
@@ -990,14 +1173,7 @@ namespace Rice::detail
 
     long convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<long>();
-      }
-      else
-      {
-        return FromRubyFundamental<long>::convert(value);
-      }
+      return FromRubyFundamental<long>::convert(value);
     }
   
   private:
@@ -1008,6 +1184,8 @@ namespace Rice::detail
   class From_Ruby<long&>
   {
   public:
+    using Buffer_T = Buffer<long>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -1016,14 +1194,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<long>::is_convertible(value);
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<long>::is_convertible(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<long>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -1034,45 +1220,59 @@ namespace Rice::detail
 
   private:
     Arg* arg_ = nullptr;
-    long converted_ = 0;
+    long converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<long*>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<long*>::is_convertible(value);
+    }
+
+    long* convert(VALUE value)
+    {
+      return FromRubyFundamental<long*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<long*>
+  class From_Ruby<long**>
   {
   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();
+        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);
+      return FromRubyFundamental<long**>::is_convertible(value);
     }
 
-    long* convert(VALUE value)
+    long** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<long*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<long**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<long[]> converted_;
   };
 
   // ===========  unsigned long  ============
@@ -1097,10 +1297,6 @@ namespace Rice::detail
       {
         return (unsigned long)value;
       }
-      else if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<unsigned long>();
-      }
       else
       {
         return FromRubyFundamental<unsigned long>::convert(value);
@@ -1115,6 +1311,8 @@ 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)
@@ -1123,14 +1321,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned long>::is_convertible(value);
+      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
       {
@@ -1154,32 +1360,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    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:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned long**>
+  {
+  public:
+    From_Ruby() = default;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        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);
+      return FromRubyFundamental<unsigned long**>::is_convertible(value);
     }
 
-    unsigned long* convert(VALUE value)
+    unsigned long** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<unsigned long*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<unsigned long**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<unsigned long[]> converted_;
   };
 
   // ===========  unsigned long long  ============
@@ -1204,10 +1424,6 @@ namespace Rice::detail
       {
         return value;
       }
-      else if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<unsigned long long>();
-      }
       else
       {
         return FromRubyFundamental<unsigned long long>::convert(value);
@@ -1222,6 +1438,8 @@ 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)
@@ -1230,14 +1448,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned long long>::is_convertible(value);
+      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
       {
@@ -1261,42 +1487,49 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    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:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned long long**>
+  {
+  public:
+    From_Ruby() = default;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        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);
+      return FromRubyFundamental<unsigned long long**>::is_convertible(value);
     }
 
-    unsigned long long* convert(VALUE value)
+    unsigned long long** convert(VALUE value)
     {
-      if (value == Qnil)
-      {
-        return nullptr;
-      }
-      else
-      {
-        this->converted_ = FromRubyFundamental<unsigned long long*>::convert(value);
-        return this->converted_.get();
-      }
+      return FromRubyFundamental<unsigned long long**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<unsigned long long[]> converted_;
   };
-
-// ===========  long long  ============
+  
+  // ===========  long long  ============
   template<>
   class From_Ruby<long long>
   {
@@ -1314,14 +1547,7 @@ namespace Rice::detail
 
     long long convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<long long>();
-      }
-      else
-      {
-        return FromRubyFundamental<long long>::convert(value);
-      }
+      return FromRubyFundamental<long long>::convert(value);
     }
   
   private:
@@ -1332,6 +1558,8 @@ namespace Rice::detail
   class From_Ruby<long long&>
   {
   public:
+    using Buffer_T = Buffer<long long>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -1340,14 +1568,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<long long>::is_convertible(value);
+      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);
+      }
     }
 
     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<long long>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -1371,32 +1607,46 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<long long*>::is_convertible(value);
+    }
+
+    long long* convert(VALUE value)
+    {
+      return FromRubyFundamental<long long*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<long long**>
+  {
+  public:
+    From_Ruby() = default;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<long long*>::is_convertible(value);
+      return FromRubyFundamental<long long**>::is_convertible(value);
     }
 
-    long long* convert(VALUE value)
+    long long** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<long long*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<long long**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<long long[]> converted_;
   };
 
   // ===========  short  ============
@@ -1417,14 +1667,7 @@ namespace Rice::detail
 
     short convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<short>();
-      }
-      else
-      {
-        return FromRubyFundamental<short>::convert(value);
-      }
+      return FromRubyFundamental<short>::convert(value);
     }
 
   private:
@@ -1435,6 +1678,8 @@ namespace Rice::detail
   class From_Ruby<short&>
   {
   public:
+    using Buffer_T = Buffer<short>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -1443,14 +1688,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<short>::is_convertible(value);
+      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return FromRubyFundamental<short>::is_convertible(value);
+      }
     }
 
     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<short>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -1474,32 +1727,45 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<short*>::is_convertible(value);
+    }
+
+    short* convert(VALUE value)
+    {
+      return FromRubyFundamental<short*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<short**>
+  {
+  public:
+    From_Ruby() = default;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<short*>::is_convertible(value);
+      return FromRubyFundamental<short**>::is_convertible(value);
     }
 
-    short* convert(VALUE value)
+    short** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<short*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<short**>::convert(value, this->arg_);
     }
-
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<short[]> converted_;
   };
 
   // ===========  unsigned short  ============
@@ -1520,14 +1786,7 @@ namespace Rice::detail
 
     unsigned short convert(VALUE value)
     {
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->defaultValue<unsigned short>();
-      }
-      else
-      {
-        return FromRubyFundamental<unsigned short>::convert(value);
-      }
+      return FromRubyFundamental<unsigned short>::convert(value);
     }
   
   private:
@@ -1538,6 +1797,8 @@ namespace Rice::detail
   class From_Ruby<unsigned short&>
   {
   public:
+    using Buffer_T = Buffer<unsigned short>;
+
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -1546,14 +1807,22 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned short>::is_convertible(value);
+      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);
+      }
     }
 
     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<unsigned short>();
+        Buffer_T* buffer = unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), false);
+        return buffer->reference();
       }
       else
       {
@@ -1577,36 +1846,51 @@ namespace Rice::detail
     {
     }
 
-    // Need move constructor and assignment due to std::unique_ptr
-    From_Ruby(From_Ruby&& other) = default;
-    From_Ruby& operator=(From_Ruby&& other) = default;
+    Convertible is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<unsigned short*>::is_convertible(value);
+    }
+
+    unsigned short* convert(VALUE value)
+    {
+      return FromRubyFundamental<unsigned short*>::convert(value, this->arg_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned short**>
+  {
+  public:
+    From_Ruby() = default;
 
-    ~From_Ruby()
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
       if (this->arg_ && this->arg_->isOwner())
       {
-        this->converted_.release();
+        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
       }
     }
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned short*>::is_convertible(value);
+      return FromRubyFundamental<unsigned short**>::is_convertible(value);
     }
 
-    unsigned short* convert(VALUE value)
+    unsigned short** convert(VALUE value)
     {
-      this->converted_ = FromRubyFundamental<unsigned short*>::convert(value);
-      return this->converted_.get();
+      return FromRubyFundamental<unsigned short**>::convert(value, this->arg_);
     }
 
   private:
     Arg* arg_ = nullptr;
-    std::unique_ptr<unsigned short[]> converted_;
   };
 
+  // ===========  std::nullptr_t  ============
   template<>
-  class From_Ruby<void*>
+  class From_Ruby<std::nullptr_t>
   {
   public:
     From_Ruby() = default;
@@ -1615,7 +1899,7 @@ namespace Rice::detail
     {
       if (this->arg_->isOwner())
       {
-        throw Exception(rb_eTypeError, "Cannot transfer ownership of string data to C++ void pointer");
+        throw Exception(rb_eTypeError, "Cannot transfer ownership of C++ void pointer");
       }
     }
 
@@ -1628,11 +1912,82 @@ namespace Rice::detail
 
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
+        case RUBY_T_NIL:
         {
           return Convertible::Exact;
           break;
         }
+        default:
+        {
+          return Convertible::None;
+        }
+      }
+    }
+
+    void* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+
+      if (this->arg_ && this->arg_->isOpaque())
+      {
+        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;
+  };
+
+  // ===========  void  ============
+  template<>
+  class From_Ruby<void*>
+  {
+  public:
+    From_Ruby()
+    {
+      detail::Type<Buffer<void>>::verify();
+    };
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+      detail::Type<Buffer<void>>::verify();
+
+      if (this->arg_->isOwner())
+      {
+        throw Exception(rb_eTypeError, "Cannot transfer ownership of C++ void pointer");
+      }
+    }
+
+    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))
@@ -1655,6 +2010,11 @@ namespace Rice::detail
 
     void* convert(VALUE value)
     {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+
       if (this->arg_ && this->arg_->isOpaque())
       {
         return (void*)value;
@@ -1667,7 +2027,19 @@ namespace Rice::detail
           // 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());
+
+          // 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: