rice 4.6.1 → 4.7.0

data/rice/detail/from_ruby.ipp

@@ -73,7 +73,11 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          return Data_Type<Buffer<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          if (Data_Type<Pointer<T>>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
         }
         default:
         {
@@ -82,7 +86,7 @@ namespace Rice::detail
       }
     }
 
-    static T* convert(VALUE value, Arg* arg)
+    static T* convert(VALUE value)
     {
       ruby_value_type valueType = rb_type(value);
 
@@ -94,21 +98,16 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          if (Data_Type<Buffer<T>>::is_descendant(value))
+          if (Data_Type<Pointer<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();
+            return unwrap<T>(value, Data_Type<Pointer<T>>::ruby_data_type(), false);
           }
           [[fallthrough]];
         }
         default:
         {
-          std::string name = typeName(typeid(Buffer<intrinsic_type<T>>));
-          std::string expected = rubyClassName(name);
+          detail::TypeMapper<Pointer<T>> typeMapper;
+          std::string expected = typeMapper.rubyName();
           throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
             detail::protect(rb_obj_classname, value), expected.c_str());
         }
@@ -133,7 +132,11 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          return Data_Type<Buffer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          if (Data_Type<Pointer<T*>>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
         }
         default:
         {
@@ -142,7 +145,7 @@ namespace Rice::detail
       }
     }
 
-    static T** convert(VALUE value, Arg* arg)
+    static T** convert(VALUE value)
     {
       ruby_value_type valueType = rb_type(value);
 
@@ -154,21 +157,16 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          if (Data_Type<Buffer<T*>>::is_descendant(value))
+          if (Data_Type<Pointer<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();
+            return unwrap<T*>(value, Data_Type<Pointer<T*>>::ruby_data_type(), false);
           }
           [[fallthrough]];
         }
         default:
         {
-          std::string name = typeName(typeid(Buffer<intrinsic_type<T>*>));
-          std::string expected = rubyClassName(name);
+          detail::TypeMapper<Pointer<T*>> typeMapper;
+          std::string expected = typeMapper.rubyName();
           throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
             detail::protect(rb_obj_classname, value), expected.c_str());
         }
@@ -205,7 +203,7 @@ namespace Rice::detail
   class From_Ruby<bool&>
   {
   public:
-    using Buffer_T = Buffer<bool>;
+    using Pointer_T = Pointer<bool>;
 
     From_Ruby() = default;
 
@@ -215,27 +213,40 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<bool>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<bool>::is_convertible(value);
+        }
       }
     }
 
     bool& 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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<bool>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (bool&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<bool>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
@@ -244,30 +255,6 @@ namespace Rice::detail
     bool converted_ = false;
   };
 
-  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, this->arg_);
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
   // ===========  char  ============
   template<>
   class From_Ruby<char>
@@ -297,7 +284,7 @@ namespace Rice::detail
   class From_Ruby<char&>
   {
   public:
-    using Buffer_T = Buffer<char>;
+    using Pointer_T = Pointer<char>;
 
     From_Ruby() = default;
 
@@ -307,27 +294,40 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<char>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<char>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (char&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<char>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
@@ -335,7 +335,7 @@ namespace Rice::detail
     Arg* arg_ = nullptr;
     char converted_ = 0;
   };
-
+      
   template<>
   class From_Ruby<char*>
   {
@@ -350,18 +350,18 @@ namespace Rice::detail
     {
       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);
-        }
+      case RUBY_T_NIL:
+      {
+        return Convertible::Exact;
+      }
+      case RUBY_T_STRING:
+      {
+        return Convertible::Exact;
+      }
+      default:
+      {
+        return FromRubyFundamental<char*>::is_convertible(value);
+      }
       }
     }
 
@@ -382,7 +382,7 @@ namespace Rice::detail
         default:
         {
           char* rb_string_value_cstr(volatile VALUE * ptr);
-          return FromRubyFundamental<char*>::convert(value, this->arg_);
+          return FromRubyFundamental<char*>::convert(value);
         }
       }
     }
@@ -390,40 +390,7 @@ namespace Rice::detail
   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())
-      {
-        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;
-  };
-
+  
   // ===========  unsigned char  ============
   template<>
   class From_Ruby<unsigned char>
@@ -453,7 +420,7 @@ namespace Rice::detail
   class From_Ruby<unsigned char&>
   {
   public:
-    using Buffer_T = Buffer<unsigned char>;
+    using Pointer_T = Pointer<unsigned char>;
 
     From_Ruby() = default;
 
@@ -463,27 +430,40 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<unsigned char>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<unsigned char>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (unsigned char&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<unsigned char>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
@@ -492,8 +472,9 @@ namespace Rice::detail
     unsigned char converted_ = 0;
   };
 
+  // ===========  signed char  ============
   template<>
-  class From_Ruby<unsigned char*>
+  class From_Ruby<signed char>
   {
   public:
     From_Ruby() = default;
@@ -504,12 +485,12 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned char*>::is_convertible(value);
+      return FromRubyFundamental<signed char>::is_convertible(value);
     }
 
-    unsigned char* convert(VALUE value)
+    signed char convert(VALUE value)
     {
-      return FromRubyFundamental<unsigned char*>::convert(value, this->arg_);
+      return FromRubyFundamental<signed char>::convert(value);
     }
 
   private:
@@ -517,36 +498,64 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<unsigned char**>
+  class From_Ruby<signed char&>
   {
   public:
+    using Pointer_T = Pointer<signed char>;
+
     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);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<signed char>::is_convertible(value);
+        }
+      }
     }
 
-    unsigned char** convert(VALUE value)
+    signed char& convert(VALUE value)
     {
-      return FromRubyFundamental<unsigned char**>::convert(value, this->arg_);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (signed char&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<signed char>::convert(value);
+          return this->converted_;
+        }
+      }
     }
 
   private:
     Arg* arg_ = nullptr;
+    signed char converted_ = 0;
   };
 
-  // ===========  signed char  ============
+  // ===========  double  ============
   template<>
-  class From_Ruby<signed char>
+  class From_Ruby<double>
   {
   public:
     From_Ruby() = default;
@@ -557,12 +566,12 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<signed char>::is_convertible(value);
+      return FromRubyFundamental<double>::is_convertible(value);
     }
 
-    signed char convert(VALUE value)
+    double convert(VALUE value)
     {
-      return FromRubyFundamental<signed char>::convert(value);
+      return FromRubyFundamental<double>::convert(value);
     }
 
   private:
@@ -570,10 +579,10 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<signed char&>
+  class From_Ruby<double&>
   {
   public:
-    using Buffer_T = Buffer<signed char>;
+    using Pointer_T = Pointer<double>;
 
     From_Ruby() = default;
 
@@ -583,37 +592,51 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<signed char>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<double>::is_convertible(value);
+        }
       }
     }
 
-    signed char& convert(VALUE 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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<signed char>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (double&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<double>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    signed char converted_ = 0;
+    double converted_;
   };
 
+  // ===========  float  ============
   template<>
-  class From_Ruby<signed char*>
+  class From_Ruby<float>
   {
   public:
     From_Ruby() = default;
@@ -624,12 +647,12 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<signed char*>::is_convertible(value);
+      return FromRubyFundamental<float>::is_convertible(value);
     }
 
-    signed char* convert(VALUE value)
+    float convert(VALUE value)
     {
-      return FromRubyFundamental<signed char*>::convert(value, this->arg_);
+      return FromRubyFundamental<float>::convert(value);
     }
 
   private:
@@ -637,103 +660,64 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<signed char**>
+  class From_Ruby<float&>
   {
   public:
+    using Pointer_T = Pointer<float>;
+
     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
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<double>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<float>::is_convertible(value);
+        }
       }
     }
 
-    double& convert(VALUE 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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<double>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (float&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<float>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    double converted_;
+    float converted_;
   };
 
+  // ===========  int  ============
   template<>
-  class From_Ruby<double*>
+  class From_Ruby<int>
   {
   public:
     From_Ruby() = default;
@@ -744,76 +728,34 @@ namespace Rice::detail
 
     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;
+      Convertible result = FromRubyFundamental<int>::is_convertible(value);
 
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-      if (this->arg_ && this->arg_->isOwner())
+      // 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)
       {
-        throw std::runtime_error("Cannot transfer ownership of an array of pointers to a fundamental type");
+        static ID id = protect(rb_intern, "to_int");
+        if (protect(rb_respond_to, value, id))
+        {
+          result = Convertible::Cast;
+        }
       }
+      return result;
     }
 
-    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)
+    int convert(VALUE value)
     {
-      return FromRubyFundamental<float>::convert(value);
+      return FromRubyFundamental<int>::convert(value);
     }
-
+  
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<float&>
+  class From_Ruby<int&>
   {
   public:
-    using Buffer_T = Buffer<float>;
+    using Pointer_T = Pointer<int>;
 
     From_Ruby() = default;
 
@@ -823,37 +765,51 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<float>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<int>::is_convertible(value);
+        }
       }
     }
 
-    float& convert(VALUE value)
+    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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<float>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (int&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<int>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    float converted_;
+    int converted_ = 0;
   };
 
+  // ===========  unsigned int  ============
   template<>
-  class From_Ruby<float*>
+  class From_Ruby<unsigned int>
   {
   public:
     From_Ruby() = default;
@@ -864,12 +820,12 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<float*>::is_convertible(value);
+      return FromRubyFundamental<unsigned int>::is_convertible(value);
     }
 
-    float* convert(VALUE value)
+    unsigned int convert(VALUE value)
     {
-      return FromRubyFundamental<float*>::convert(value, this->arg_);
+      return FromRubyFundamental<unsigned int>::convert(value);
     }
 
   private:
@@ -877,38 +833,11 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<float**>
+  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");
-      }
-    }
-
-    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;
-  };
+    using Pointer_T = Pointer<unsigned int>;
 
-  // ===========  int  ============
-  template<>
-  class From_Ruby<int>
-  {
-  public:
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -917,35 +846,53 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      Convertible result = FromRubyFundamental<int>::is_convertible(value);
-
-      // Is this an enum? If so we want to support converting it to an integer
-      if (result == Convertible::None && rb_type(value) == RUBY_T_DATA)
+      switch (rb_type(value))
       {
-        static ID id = protect(rb_intern, "to_int");
-        if (protect(rb_respond_to, value, id))
+        case RUBY_T_DATA:
         {
-          result = Convertible::Cast;
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<unsigned int>::is_convertible(value);
         }
       }
-      return result;
     }
 
-    int convert(VALUE value)
+    unsigned int& convert(VALUE value)
     {
-      return FromRubyFundamental<int>::convert(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (unsigned int&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<unsigned int>::convert(value);
+          return this->converted_;
+        }
+      }
     }
-  
+
   private:
     Arg* arg_ = nullptr;
+    unsigned int converted_ = 0;
   };
 
+  // ===========  long  ============
   template<>
-  class From_Ruby<int&>
+  class From_Ruby<long>
   {
   public:
-    using Buffer_T = Buffer<int>;
-
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -954,600 +901,12 @@ namespace Rice::detail
 
     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<int>::is_convertible(value);
-      }
-    }
-
-    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_ = FromRubyFundamental<int>::convert(value);
-        return this->converted_;
-      }
+      return FromRubyFundamental<long>::is_convertible(value);
     }
 
-  private:
-    Arg* arg_ = nullptr;
-    int converted_ = 0;
-  };
-
-  template<>
-  class From_Ruby<int*>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    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;
-
-    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<int**>::is_convertible(value);
-    }
-
-    int** convert(VALUE value)
-    {
-      return FromRubyFundamental<int**>::convert(value, this->arg_);
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  // ===========  unsigned int  ============
-  template<>
-  class From_Ruby<unsigned int>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      return FromRubyFundamental<unsigned int>::is_convertible(value);
-    }
-
-    unsigned int convert(VALUE value)
-    {
-      return FromRubyFundamental<unsigned int>::convert(value);
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  template<>
-  class From_Ruby<unsigned int&>
-  {
-  public:
-    using Buffer_T = Buffer<unsigned int>;
-
-    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<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_ = FromRubyFundamental<unsigned int>::convert(value);
-        return this->converted_;
-      }
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-    unsigned int converted_ = 0;
-  };
-
-  template<>
-  class From_Ruby<unsigned int*>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      return FromRubyFundamental<unsigned int*>::is_convertible(value);
-    }
-
-    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())
-      {
-        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);
-    }
-
-    unsigned int** convert(VALUE value)
-    {
-      return FromRubyFundamental<unsigned int**>::convert(value, this->arg_);
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  // ===========  long  ============
-  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);
-    }
-  
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  template<>
-  class From_Ruby<long&>
-  {
-  public:
-    using Buffer_T = Buffer<long>;
-
-    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<long>::is_convertible(value);
-      }
-    }
-
-    long& 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<long>::convert(value);
-        return this->converted_;
-      }
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-    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**>
-  {
-  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<long**>::is_convertible(value);
-    }
-
-    long** convert(VALUE value)
-    {
-      return FromRubyFundamental<long**>::convert(value, this->arg_);
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  // ===========  unsigned long  ============
-  template<>
-  class From_Ruby<unsigned long>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      return FromRubyFundamental<unsigned long>::is_convertible(value);
-    }
-
-    unsigned long convert(VALUE value)
-    {
-      if (this->arg_ && this->arg_->isValue())
-      {
-        return (unsigned long)value;
-      }
-      else
-      {
-        return FromRubyFundamental<unsigned long>::convert(value);
-      }
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  template<>
-  class From_Ruby<unsigned long&>
-  {
-  public:
-    using Buffer_T = Buffer<unsigned long>;
-
-    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<unsigned long>::is_convertible(value);
-      }
-    }
-
-    unsigned long& 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<unsigned long>::convert(value);
-        return this->converted_;
-      }
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-    unsigned long converted_ = 0;
-  };
-
-  template<>
-  class From_Ruby<unsigned long*>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    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;
-
-    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 long**>::is_convertible(value);
-    }
-
-    unsigned long** convert(VALUE value)
-    {
-      return FromRubyFundamental<unsigned long**>::convert(value, this->arg_);
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  // ===========  unsigned long long  ============
-  template<>
-  class From_Ruby<unsigned long long>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      return FromRubyFundamental<unsigned long long>::is_convertible(value);
-    }
-
-    unsigned long long convert(VALUE value)
-    {
-      if (this->arg_ && this->arg_->isValue())
-      {
-        return value;
-      }
-      else
-      {
-        return FromRubyFundamental<unsigned long long>::convert(value);
-      }
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  template<>
-  class From_Ruby<unsigned long long&>
-  {
-  public:
-    using Buffer_T = Buffer<unsigned long long>;
-
-    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<unsigned long long>::is_convertible(value);
-      }
-    }
-
-    unsigned long long& 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<unsigned long long>::convert(value);
-        return this->converted_;
-      }
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-    unsigned long long converted_ = 0;
-  };
-
-  template<>
-  class From_Ruby<unsigned long long*>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    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;
-
-    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 long long**>::is_convertible(value);
-    }
-
-    unsigned long long** convert(VALUE value)
-    {
-      return FromRubyFundamental<unsigned long long**>::convert(value, this->arg_);
-    }
-
-  private:
-    Arg* arg_ = nullptr;
-  };
-  
-  // ===========  long long  ============
-  template<>
-  class From_Ruby<long long>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      return FromRubyFundamental<long long>::is_convertible(value);
-    }
-
-    long long convert(VALUE value)
+    long convert(VALUE value)
     {
-      return FromRubyFundamental<long long>::convert(value);
+      return FromRubyFundamental<long>::convert(value);
     }
   
   private:
@@ -1555,10 +914,10 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<long long&>
+  class From_Ruby<long&>
   {
   public:
-    using Buffer_T = Buffer<long long>;
+    using Pointer_T = Pointer<long>;
 
     From_Ruby() = default;
 
@@ -1568,37 +927,51 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<long long>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<long>::is_convertible(value);
+        }
       }
     }
 
-    long long& convert(VALUE value)
+    long& 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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<long long>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<long>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    long long converted_ = 0;
+    long converted_ = 0;
   };
 
+  // ===========  unsigned long  ============
   template<>
-  class From_Ruby<long long*>
+  class From_Ruby<unsigned long>
   {
   public:
     From_Ruby() = default;
@@ -1609,12 +982,19 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<long long*>::is_convertible(value);
+      return FromRubyFundamental<unsigned long>::is_convertible(value);
     }
 
-    long long* convert(VALUE value)
+    unsigned long convert(VALUE value)
     {
-      return FromRubyFundamental<long long*>::convert(value, this->arg_);
+      if (this->arg_ && this->arg_->isValue())
+      {
+        return (unsigned long)value;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned long>::convert(value);
+      }
     }
 
   private:
@@ -1622,36 +1002,64 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<long long**>
+  class From_Ruby<unsigned long&>
   {
   public:
+    using Pointer_T = Pointer<unsigned long>;
+
     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<long long**>::is_convertible(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<unsigned long>::is_convertible(value);
+        }
+      }
     }
 
-    long long** convert(VALUE value)
+    unsigned long& convert(VALUE value)
     {
-      return FromRubyFundamental<long long**>::convert(value, this->arg_);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (unsigned long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<unsigned long>::convert(value);
+          return this->converted_;
+        }
+      }
     }
 
   private:
     Arg* arg_ = nullptr;
+    unsigned long converted_ = 0;
   };
 
-  // ===========  short  ============
+  // ===========  unsigned long long  ============
   template<>
-  class From_Ruby<short>
+  class From_Ruby<unsigned long long>
   {
   public:
     From_Ruby() = default;
@@ -1662,12 +1070,19 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<short>::is_convertible(value);
+      return FromRubyFundamental<unsigned long long>::is_convertible(value);
     }
 
-    short convert(VALUE value)
+    unsigned long long convert(VALUE value)
     {
-      return FromRubyFundamental<short>::convert(value);
+      if (this->arg_ && this->arg_->isValue())
+      {
+        return value;
+      }
+      else
+      {
+        return FromRubyFundamental<unsigned long long>::convert(value);
+      }
     }
 
   private:
@@ -1675,10 +1090,10 @@ namespace Rice::detail
   };
 
   template<>
-  class From_Ruby<short&>
+  class From_Ruby<unsigned long long&>
   {
   public:
-    using Buffer_T = Buffer<short>;
+    using Pointer_T = Pointer<unsigned long long>;
 
     From_Ruby() = default;
 
@@ -1688,37 +1103,51 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<short>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<unsigned long long>::is_convertible(value);
+        }
       }
     }
 
-    short& convert(VALUE value)
+    unsigned long long& 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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<short>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (unsigned long long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<unsigned long long>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    short converted_ = 0;
+    unsigned long long converted_ = 0;
   };
-
+ 
+  // ===========  long long  ============
   template<>
-  class From_Ruby<short*>
+  class From_Ruby<long long>
   {
   public:
     From_Ruby() = default;
@@ -1729,48 +1158,77 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<short*>::is_convertible(value);
+      return FromRubyFundamental<long long>::is_convertible(value);
     }
 
-    short* convert(VALUE value)
+    long long convert(VALUE value)
     {
-      return FromRubyFundamental<short*>::convert(value, this->arg_);
+      return FromRubyFundamental<long long>::convert(value);
     }
-
+  
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<short**>
+  class From_Ruby<long long&>
   {
   public:
+    using Pointer_T = Pointer<long long>;
+
     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<short**>::is_convertible(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<long long>::is_convertible(value);
+        }
+      }
     }
 
-    short** convert(VALUE value)
+    long long& convert(VALUE value)
     {
-      return FromRubyFundamental<short**>::convert(value, this->arg_);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (long long&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<long long>::convert(value);
+          return this->converted_;
+        }
+      }
     }
+
   private:
     Arg* arg_ = nullptr;
+    long long converted_ = 0;
   };
 
-  // ===========  unsigned short  ============
+  // ===========  short  ============
   template<>
-  class From_Ruby<unsigned short>
+  class From_Ruby<short>
   {
   public:
     From_Ruby() = default;
@@ -1781,23 +1239,23 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      return FromRubyFundamental<unsigned short>::is_convertible(value);
+      return FromRubyFundamental<short>::is_convertible(value);
     }
 
-    unsigned short convert(VALUE value)
+    short convert(VALUE value)
     {
-      return FromRubyFundamental<unsigned short>::convert(value);
+      return FromRubyFundamental<short>::convert(value);
     }
-  
+
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<unsigned short&>
+  class From_Ruby<short&>
   {
   public:
-    using Buffer_T = Buffer<unsigned short>;
+    using Pointer_T = Pointer<short>;
 
     From_Ruby() = default;
 
@@ -1807,37 +1265,51 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
-      if (rb_type(value) == RUBY_T_DATA && Data_Type<Buffer_T>::is_descendant(value))
-      {
-        return Convertible::Exact;
-      }
-      else
+      switch (rb_type(value))
       {
-        return FromRubyFundamental<unsigned short>::is_convertible(value);
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<short>::is_convertible(value);
+        }
       }
     }
 
-    unsigned short& convert(VALUE value)
+    short& 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
+      switch (rb_type(value))
       {
-        this->converted_ = FromRubyFundamental<unsigned short>::convert(value);
-        return this->converted_;
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (short&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<short>::convert(value);
+          return this->converted_;
+        }
       }
     }
 
   private:
     Arg* arg_ = nullptr;
-    unsigned short converted_ = 0;
+    short converted_ = 0;
   };
 
+  // ===========  unsigned short  ============
   template<>
-  class From_Ruby<unsigned short*>
+  class From_Ruby<unsigned short>
   {
   public:
     From_Ruby() = default;
@@ -1848,44 +1320,72 @@ namespace Rice::detail
 
     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)
     {
-      return FromRubyFundamental<unsigned short*>::convert(value, this->arg_);
+      return FromRubyFundamental<unsigned short>::convert(value);
     }
-
+  
   private:
     Arg* arg_ = nullptr;
   };
 
   template<>
-  class From_Ruby<unsigned short**>
+  class From_Ruby<unsigned short&>
   {
   public:
+    using Pointer_T = Pointer<unsigned short>;
+
     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 short**>::is_convertible(value);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<unsigned short>::is_convertible(value);
+        }
+      }
     }
 
-    unsigned short** convert(VALUE value)
+    unsigned short& convert(VALUE value)
     {
-      return FromRubyFundamental<unsigned short**>::convert(value, this->arg_);
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value))
+          {
+            return (unsigned short&)*unwrap<Pointer_T>(value, Data_Type<Pointer_T>::ruby_data_type(), false);
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->converted_ = FromRubyFundamental<unsigned short>::convert(value);
+          return this->converted_;
+        }
+      }
     }
 
   private:
     Arg* arg_ = nullptr;
+    unsigned short converted_ = 0;
   };
 
   // ===========  std::nullptr_t  ============
@@ -1961,13 +1461,10 @@ namespace Rice::detail
   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");
@@ -2028,12 +1525,9 @@ namespace Rice::detail
           // 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())
+          if (Data_Type<Pointer<void>>::is_descendant(value))
           {
-            Data_Object<Buffer<void>> buffer(value);
-            return buffer->ptr();
+            return unwrap<void>(value, Data_Type<Pointer<void>>::ruby_data_type(), false);
           }
           else 
           {