rice 4.5.0 → 4.6.0

data/rice/detail/to_ruby.ipp

@@ -3,8 +3,9 @@ namespace Rice
 {
   namespace detail
   {
+    // ===========  bool  ============
     template<>
-    class To_Ruby<void>
+    class To_Ruby<bool>
     {
     public:
       To_Ruby() = default;
@@ -13,10 +14,9 @@ namespace Rice
       {
       }
 
-      VALUE convert(const void*)
+      VALUE convert(const bool& native)
       {
-        throw std::runtime_error("Converting from void pointer is not implemented");
-        return Qnil;
+        return native ? Qtrue : Qfalse;
       }
 
     private:
@@ -24,7 +24,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<std::nullptr_t>
+    class To_Ruby<bool&>
     {
     public:
       To_Ruby() = default;
@@ -33,9 +33,9 @@ namespace Rice
       {
       }
 
-      VALUE convert(std::nullptr_t const)
+      VALUE convert(const bool& native)
       {
-        return Qnil;
+        return native ? Qtrue : Qfalse;
       }
 
     private:
@@ -43,7 +43,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<short>
+    class To_Ruby<bool*>
     {
     public:
       To_Ruby() = default;
@@ -52,7 +52,63 @@ namespace Rice
       {
       }
 
-      VALUE convert(const short& native)
+      VALUE convert(bool* data)
+      {
+        Buffer<bool> buffer(data);
+        Data_Object<Buffer<bool>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const bool* data)
+      {
+        return this->convert((bool*)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<bool N>
+    class To_Ruby<bool[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(bool data[N])
+      {
+        Buffer<bool> buffer(data, N);
+        Data_Object<Buffer<bool>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  int  ============
+    template<>
+    class To_Ruby<int>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const int& native)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_int2num_inline, (int)native);
+#else
+        return RB_INT2NUM(native);
+#endif
+      }
+
+      VALUE convert(const volatile int& native)
       {
 #ifdef rb_int2num_inline
         return protect(rb_int2num_inline, (int)native);
@@ -66,7 +122,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<short&>
+    class To_Ruby<int&>
     {
     public:
       To_Ruby() = default;
@@ -75,7 +131,7 @@ namespace Rice
       {
       }
 
-      VALUE convert(const short& native)
+      VALUE convert(const int& native)
       {
 #ifdef rb_int2num_inline
         return protect(rb_int2num_inline, (int)native);
@@ -89,7 +145,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<int>
+    class To_Ruby<int*>
     {
     public:
       To_Ruby() = default;
@@ -98,30 +154,840 @@ namespace Rice
       {
       }
 
-      VALUE convert(const int& native)
+      VALUE convert(int* data)
+      {
+        Buffer<int> buffer(data);
+        Data_Object<Buffer<int>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const int* data)
+      {
+        return this->convert((int*)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<int[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(int data[N])
+      {
+        Buffer<int> buffer(data, N);
+        Data_Object<Buffer<int>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<int**>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(int** data)
+      {
+        Buffer<int*> buffer(data);
+        Data_Object<Buffer<int*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const int** data)
+      {
+        return this->convert((int**)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  unsigned int  ============
+    template<>
+    class To_Ruby<unsigned int>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned int& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_int2num_inline, (int)native);
+        return protect(rb_uint2num_inline, (unsigned int)native);
 #else
-        return RB_INT2NUM(native);
+        return RB_UINT2NUM(native);
 #endif
       }
 
-      VALUE convert(const volatile int& native)
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned int&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned int& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_int2num_inline, (int)native);
+        return protect(rb_uint2num_inline, (unsigned int)native);
 #else
-        return RB_INT2NUM(native);
+        return RB_UINT2NUM(native);
 #endif
       }
-
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned int*>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(unsigned int* data)
+      {
+        Buffer<unsigned int> buffer(data);
+        Data_Object<Buffer<unsigned int>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const unsigned int* data)
+      {
+        return this->convert((unsigned int*)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<unsigned int[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(unsigned int data[N])
+      {
+        Buffer<unsigned int> buffer(data, N);
+        Data_Object<Buffer<unsigned int>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned int**>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(unsigned int** data)
+      {
+        Buffer<unsigned int*> buffer(data);
+        Data_Object<Buffer<unsigned int*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const unsigned int** data)
+      {
+        return this->convert((unsigned int**)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  char  ============
+    template<>
+    class To_Ruby<char>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char& native)
+      {
+        return To_Ruby<int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<char&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char& native)
+      {
+        return To_Ruby<int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<char*>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char* data)
+      {
+        if (!data)
+        {
+          return Qnil;
+        }
+        else if (strlen(data) > 0 && data[0] == ':')
+        {
+          size_t symbolLength = strlen(data) - 1;
+          char* symbol = new char[symbolLength];
+          strncpy(symbol, data + 1, symbolLength);
+          ID id = protect(rb_intern2, symbol, (long)symbolLength);
+          delete[] symbol;
+          return protect(rb_id2sym, id);
+        }
+        else if (this->arg_ && this->arg_->isOwner())
+        {
+          // This copies the buffer but does not free it. So Ruby is not really
+          // taking ownership of it. But there isn't a Ruby API for creating a string
+          // from an existing buffer and later freeing it.
+          return protect(rb_usascii_str_new_cstr, data);
+        }
+        else
+        {
+          // Does NOT copy the passed in buffer and does NOT free it when the string is GCed
+          long size = (long)strlen(data);
+          VALUE result = protect(rb_str_new_static, data, size);
+          // Freeze the object so Ruby can't modify the C string
+          return rb_obj_freeze(result);
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<char[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char buffer[])
+      {
+        if (N > 0 && buffer[0] == ':')
+        {
+          // N count includes a NULL character at the end of the string
+          constexpr size_t symbolLength = N - 1;
+          char symbol[symbolLength];
+          strncpy(symbol, buffer + 1, symbolLength);
+          ID id = protect(rb_intern, symbol);
+          return protect(rb_id2sym, id);
+        }
+        else
+        {
+          long size = (long)strlen(buffer);
+          return protect(rb_usascii_str_new_static, buffer, size);
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<char**>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(char** data)
+      {
+        Buffer<char*> buffer(data);
+        Data_Object<Buffer<char*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const char** data)
+      {
+        return this->convert((char**)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  unsigned char  ============
+    template<>
+    class To_Ruby<unsigned char>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned char& native)
+      {
+        return To_Ruby<unsigned int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned char&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned char& native)
+      {
+        return To_Ruby<unsigned int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned char*>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(unsigned char* data)
+      {
+        Buffer<unsigned char> buffer(data);
+        Data_Object<Buffer<unsigned char>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const unsigned char* data)
+      {
+        return this->convert((unsigned char*)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<unsigned char[N]>
+    {
+    public:
+      VALUE convert(unsigned char data[N])
+      {
+        Buffer<unsigned char> buffer(data, N);
+        Data_Object<Buffer<unsigned char>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned char**>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(unsigned char** data)
+      {
+        Buffer<unsigned char*> buffer(data);
+        Data_Object<Buffer<unsigned char*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const unsigned char** data)
+      {
+        return this->convert((unsigned char**)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  signed char  ============
+    template<>
+    class To_Ruby<signed char>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const signed char& native)
+      {
+        return To_Ruby<signed int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<signed char&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const signed char& native)
+      {
+        return To_Ruby<signed int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<signed char*>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(signed char* data)
+      {
+        Buffer<signed char> buffer(data);
+        Data_Object<Buffer<signed char>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const signed char* data)
+      {
+        return this->convert((signed char*)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<signed char[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(signed char data[N])
+      {
+        Buffer<signed char> buffer(data, N);
+        Data_Object<Buffer<signed char>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<signed char**>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(signed char** data)
+      {
+        Buffer<signed char*> buffer(data);
+        Data_Object<Buffer<signed char*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const signed char** data)
+      {
+        return this->convert((signed char**)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  double  ============
+    template<>
+    class To_Ruby<double>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const double& native)
+      {
+        return protect(rb_float_new, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<double&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const double& native)
+      {
+        return protect(rb_float_new, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<double*>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(double* data)
+      {
+        Buffer<double> buffer(data);
+        Data_Object<Buffer<double>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<double[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(double data[N])
+      {
+        Buffer<double> buffer(data, N);
+        Data_Object<Buffer<double>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<double**>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(double** data)
+      {
+        Buffer<double*> buffer(data);
+        Data_Object<Buffer<double*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const double** data)
+      {
+        return this->convert((double**)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  float  ============
+    template<>
+    class To_Ruby<float>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const float& native)
+      {
+        return protect(rb_float_new, (double)native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<float&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const float& native)
+      {
+        return protect(rb_float_new, (double)native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<float*>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(float* data)
+      {
+        Buffer<float> buffer(data);
+        Data_Object<Buffer<float>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<float[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(float data[N])
+      {
+        Buffer<float> buffer(data, N);
+        Data_Object<Buffer<float>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<float**>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(float** data)
+      {
+        Buffer<float*> buffer(data);
+        Data_Object<Buffer<float*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const float** data)
+      {
+        return this->convert((float**)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    // ===========  long  ============
+    template<>
+    class To_Ruby<long>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const long& native)
+      {
+        return protect(rb_long2num_inline, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<long&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const long& native)
+      {
+        return protect(rb_long2num_inline, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<long*>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(long* data)
+      {
+        Buffer<long> buffer(data);
+        Data_Object<Buffer<long>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<long[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(long data[N])
+      {
+        Buffer<long> buffer(data, N);
+        Data_Object<Buffer<long>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
     private:
       Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<int&>
+    class To_Ruby<long**>
     {
     public:
       To_Ruby() = default;
@@ -130,21 +996,25 @@ namespace Rice
       {
       }
 
-      VALUE convert(const int& native)
+      VALUE convert(long** data)
       {
-#ifdef rb_int2num_inline
-        return protect(rb_int2num_inline, (int)native);
-#else
-        return RB_INT2NUM(native);
-#endif
+        Buffer<long*> buffer(data);
+        Data_Object<Buffer<long*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const long** data)
+      {
+        return this->convert((long**)data);
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
+    // ===========  unsigned long  ============
     template<>
-    class To_Ruby<long>
+    class To_Ruby<unsigned long>
     {
     public:
       To_Ruby() = default;
@@ -153,9 +1023,16 @@ namespace Rice
       {
       }
 
-      VALUE convert(const long& native)
+      VALUE convert(const unsigned long& native)
       {
-        return protect(rb_long2num_inline, native);
+        if (this->arg_ && this->arg_->isValue())
+        {
+          return native;
+        }
+        else
+        {
+          return protect(rb_ulong2num_inline, native);
+        }
       }
 
     private:
@@ -163,7 +1040,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<long&>
+    class To_Ruby<unsigned long&>
     {
     public:
       To_Ruby() = default;
@@ -172,9 +1049,16 @@ namespace Rice
       {
       }
 
-      VALUE convert(const long& native)
+      VALUE convert(const unsigned long& native)
       {
-        return protect(rb_long2num_inline, native);
+        if (this->arg_ && this->arg_->isValue())
+        {
+          return native;
+        }
+        else
+        {
+          return protect(rb_ulong2num_inline, native);
+        }
       }
 
     private:
@@ -182,7 +1066,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<long long>
+    class To_Ruby<unsigned long*>
     {
     public:
       To_Ruby() = default;
@@ -191,17 +1075,19 @@ namespace Rice
       {
       }
 
-      VALUE convert(const long long& native)
+      VALUE convert(unsigned long* data)
       {
-        return protect(rb_ll2inum, native);
+        Buffer<unsigned long> buffer(data);
+        Data_Object<Buffer<unsigned long>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
-    template<>
-    class To_Ruby<long long&>
+    template<int N>
+    class To_Ruby<unsigned long[N]>
     {
     public:
       To_Ruby() = default;
@@ -210,17 +1096,18 @@ namespace Rice
       {
       }
 
-      VALUE convert(const long long& native)
+      VALUE convert(unsigned long data[N])
       {
-        return protect(rb_ll2inum, native);
+        Buffer<unsigned long> buffer(data, N);
+        Data_Object<Buffer<unsigned long>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
-
     private:
       Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<unsigned short>
+    class To_Ruby<unsigned long**>
     {
     public:
       To_Ruby() = default;
@@ -229,21 +1116,25 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned short& native)
+      VALUE convert(unsigned long** data)
       {
-#ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)native);
-#else
-        return RB_UINT2NUM(native);
-#endif
+        Buffer<unsigned long*> buffer(data);
+        Data_Object<Buffer<unsigned long*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const unsigned long** data)
+      {
+        return this->convert((unsigned long**)data);
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
+    // ===========  long long  ============
     template<>
-    class To_Ruby<unsigned short&>
+    class To_Ruby<long long>
     {
     public:
       To_Ruby() = default;
@@ -252,13 +1143,9 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned short& native)
+      VALUE convert(const long long& native)
       {
-#ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)native);
-#else
-        return RB_UINT2NUM(native);
-#endif
+        return protect(rb_ll2inum, native);
       }
 
     private:
@@ -266,7 +1153,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<unsigned int>
+    class To_Ruby<long long&>
     {
     public:
       To_Ruby() = default;
@@ -275,13 +1162,9 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned int& native)
+      VALUE convert(const long long& native)
       {
-#ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)native);
-#else
-        return RB_UINT2NUM(native);
-#endif
+        return protect(rb_ll2inum, native);
       }
 
     private:
@@ -289,7 +1172,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<unsigned int&>
+    class To_Ruby<long long*>
     {
     public:
       To_Ruby() = default;
@@ -298,21 +1181,19 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned int& native)
+      VALUE convert(long long* data)
       {
-#ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)native);
-#else
-        return RB_UINT2NUM(native);
-#endif
+        Buffer<long long> buffer(data);
+        Data_Object<Buffer<long long>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
-    template<>
-    class To_Ruby<unsigned long>
+    template<int N>
+    class To_Ruby<long long[N]>
     {
     public:
       To_Ruby() = default;
@@ -321,24 +1202,18 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned long& native)
+      VALUE convert(long long data[N])
       {
-        if (this->arg_ && this->arg_->isValue())
-        {
-          return native;
-        }
-        else
-        {
-          return protect(rb_ulong2num_inline, native);
-        }
+        Buffer<long long> buffer(data, N);
+        Data_Object<Buffer<long long>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
-
     private:
       Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<unsigned long&>
+    class To_Ruby<long long**>
     {
     public:
       To_Ruby() = default;
@@ -347,22 +1222,23 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned long& native)
+      VALUE convert(long long** data)
       {
-        if (this->arg_ && this->arg_->isValue())
-        {
-          return native;
-        }
-        else
-        {
-          return protect(rb_ulong2num_inline, native);
-        }
+        Buffer<long long*> buffer(data);
+        Data_Object<Buffer<long long*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const long long** data)
+      {
+        return this->convert((long long**)data);
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
+    // ===========  unsigned long long  ============
     template<>
     class To_Ruby<unsigned long long>
     {
@@ -427,7 +1303,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<float>
+    class To_Ruby<unsigned long long*>
     {
     public:
       To_Ruby() = default;
@@ -436,17 +1312,19 @@ namespace Rice
       {
       }
 
-      VALUE convert(const float& native)
+      VALUE convert(unsigned long long* data)
       {
-        return protect(rb_float_new, (double)native);
+        Buffer<unsigned long long> buffer(data);
+        Data_Object<Buffer<unsigned long long>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
-    template<>
-    class To_Ruby<float&>
+    template<int N>
+    class To_Ruby<unsigned long long[N]>
     {
     public:
       To_Ruby() = default;
@@ -455,17 +1333,18 @@ namespace Rice
       {
       }
 
-      VALUE convert(const float& native)
+      VALUE convert(unsigned long long data[N])
       {
-        return protect(rb_float_new, (double)native);
+        Buffer<unsigned long long> buffer(data, N);
+        Data_Object<Buffer<unsigned long long>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
-
     private:
       Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<double>
+    class To_Ruby<unsigned long long**>
     {
     public:
       To_Ruby() = default;
@@ -474,17 +1353,25 @@ namespace Rice
       {
       }
 
-      VALUE convert(const double& native)
+      VALUE convert(unsigned long long** data)
       {
-        return protect(rb_float_new, native);
+        Buffer<unsigned long long*> buffer(data);
+        Data_Object<Buffer<unsigned long long*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const unsigned long long** data)
+      {
+        return this->convert((unsigned long long**)data);
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
+    // ===========  short  ============
     template<>
-    class To_Ruby<double&>
+    class To_Ruby<short>
     {
     public:
       To_Ruby() = default;
@@ -493,9 +1380,13 @@ namespace Rice
       {
       }
 
-      VALUE convert(const double& native)
+      VALUE convert(const short& native)
       {
-        return protect(rb_float_new, native);
+#ifdef rb_int2num_inline
+        return protect(rb_int2num_inline, (int)native);
+#else
+        return RB_INT2NUM(native);
+#endif
       }
 
     private:
@@ -503,7 +1394,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<bool>
+    class To_Ruby<short&>
     {
     public:
       To_Ruby() = default;
@@ -512,9 +1403,13 @@ namespace Rice
       {
       }
 
-      VALUE convert(const bool& native)
+      VALUE convert(const short& native)
       {
-        return native ? Qtrue : Qfalse;
+#ifdef rb_int2num_inline
+        return protect(rb_int2num_inline, (int)native);
+#else
+        return RB_INT2NUM(native);
+#endif
       }
 
     private:
@@ -522,7 +1417,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<bool&>
+    class To_Ruby<short*>
     {
     public:
       To_Ruby() = default;
@@ -531,17 +1426,19 @@ namespace Rice
       {
       }
 
-      VALUE convert(const bool& native)
+      VALUE convert(short* data)
       {
-        return native ? Qtrue : Qfalse;
+        Buffer<short> buffer(data);
+        Data_Object<Buffer<short>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
-    template<>
-    class To_Ruby<char>
+    template<int N>
+    class To_Ruby<short[N]>
     {
     public:
       To_Ruby() = default;
@@ -550,17 +1447,18 @@ namespace Rice
       {
       }
 
-      VALUE convert(const char& native)
+      VALUE convert(short data[N])
       {
-        return To_Ruby<int>().convert(native);
+        Buffer<short> buffer(data, N);
+        Data_Object<Buffer<short>> dataObject(std::move(buffer));
+        return dataObject.value();
       }
-
     private:
       Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<char&>
+    class To_Ruby<short**>
     {
     public:
       To_Ruby() = default;
@@ -569,17 +1467,25 @@ namespace Rice
       {
       }
 
-      VALUE convert(const char& native)
+      VALUE convert(short** data)
       {
-        return To_Ruby<int>().convert(native);
+        Buffer<short*> buffer(data);
+        Data_Object<Buffer<short*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const short** data)
+      {
+        return this->convert((short**)data);
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
+    // ===========  unsigned short  ============
     template<>
-    class To_Ruby<char*>
+    class To_Ruby<unsigned short>
     {
     public:
       To_Ruby() = default;
@@ -588,42 +1494,21 @@ namespace Rice
       {
       }
 
-      VALUE convert(const char* buffer)
+      VALUE convert(const unsigned short& native)
       {
-        if (!buffer)
-        {
-          return Qnil;
-        }
-        else if (strlen(buffer) > 0 && buffer[0] == ':')
-        {
-          size_t symbolLength = strlen(buffer) - 1;
-          char* symbol = new char[symbolLength];
-          strncpy(symbol, buffer + 1, symbolLength);
-          ID id = protect(rb_intern2, symbol, (long)symbolLength);
-          delete[] symbol;
-          return protect(rb_id2sym, id);
-        }
-        else if (this->arg_ && this->arg_->isOwner())
-        {
-          // This copies the buffer but does not free it. So Ruby is not really
-          // taking ownership of it. But there isn't a Ruby API for creating a string
-          // from an existing buffer and later freeing it.
-          return protect(rb_usascii_str_new_cstr, buffer);
-        }
-        else
-        {
-          // Does NOT copy the passed in buffer and does NOT free it when the string is GCed
-          long size = (long)strlen(buffer);
-          return protect(rb_usascii_str_new_static, buffer, size);
-        }
+#ifdef rb_int2num_inline
+        return protect(rb_uint2num_inline, (unsigned int)native);
+#else
+        return RB_UINT2NUM(native);
+#endif
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
-    template<int N>
-    class To_Ruby<char[N]>
+    template<>
+    class To_Ruby<unsigned short&>
     {
     public:
       To_Ruby() = default;
@@ -632,22 +1517,13 @@ namespace Rice
       {
       }
 
-      VALUE convert(const char buffer[])
+      VALUE convert(const unsigned short& native)
       {
-        if (N > 0 && buffer[0] == ':')
-        {
-          // N count includes a NULL character at the end of the string
-          constexpr size_t symbolLength = N - 1;
-          char symbol[symbolLength];
-          strncpy(symbol, buffer + 1, symbolLength);
-          ID id = protect(rb_intern, symbol);
-          return protect(rb_id2sym, id);
-        }
-        else
-        {
-          long size = (long)strlen(buffer);
-          return protect(rb_usascii_str_new_static, buffer, size);
-        }
+#ifdef rb_int2num_inline
+        return protect(rb_uint2num_inline, (unsigned int)native);
+#else
+        return RB_UINT2NUM(native);
+#endif
       }
 
     private:
@@ -655,7 +1531,7 @@ namespace Rice
     };
 
     template<>
-    class To_Ruby<unsigned char>
+    class To_Ruby<unsigned short*>
     {
     public:
       To_Ruby() = default;
@@ -664,17 +1540,39 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned char& native)
+      VALUE convert(unsigned short* data)
+      {
+        Buffer<unsigned short> buffer(data);
+        Data_Object<Buffer<unsigned short>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<unsigned short[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return To_Ruby<unsigned int>().convert(native);
       }
 
+      VALUE convert(unsigned short data[N])
+      {
+        Buffer<unsigned short> buffer(data, N);
+        Data_Object<Buffer<unsigned short>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
     private:
       Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<unsigned char&>
+    class To_Ruby<unsigned short**>
     {
     public:
       To_Ruby() = default;
@@ -683,17 +1581,25 @@ namespace Rice
       {
       }
 
-      VALUE convert(const unsigned char& native)
+      VALUE convert(unsigned short** data)
       {
-        return To_Ruby<unsigned int>().convert(native);
+        Buffer<unsigned short*> buffer(data);
+        Data_Object<Buffer<unsigned short*>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+
+      VALUE convert(const unsigned short** data)
+      {
+        return this->convert((unsigned short**)data);
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
+    // ===========  std::nullptr_t  ============
     template<>
-    class To_Ruby<signed char>
+    class To_Ruby<std::nullptr_t>
     {
     public:
       To_Ruby() = default;
@@ -702,17 +1608,18 @@ namespace Rice
       {
       }
 
-      VALUE convert(const signed char& native)
+      VALUE convert(std::nullptr_t const)
       {
-        return To_Ruby<signed int>().convert(native);
+        return Qnil;
       }
 
     private:
       Arg* arg_ = nullptr;
     };
 
+    // ===========  void  ============
     template<>
-    class To_Ruby<signed char&>
+    class To_Ruby<void>
     {
     public:
       To_Ruby() = default;
@@ -721,15 +1628,16 @@ namespace Rice
       {
       }
 
-      VALUE convert(const signed char& native)
+      VALUE convert(const void*)
       {
-        return To_Ruby<signed int>().convert(native);
+        throw std::runtime_error("Converting from void pointer is not implemented");
+        return Qnil;
       }
 
     private:
       Arg* arg_ = nullptr;
     };
-
+ 
     template <>
     class To_Ruby<void*>
     {
@@ -742,21 +1650,19 @@ namespace Rice
 
       VALUE convert(void* data)
       {
-        if (this->arg_ && this->arg_->isOpaque())
+        if (data == nullptr)
         {
-          return VALUE(data);
+          return Qnil;
         }
-        else if (data)
+        else if (this->arg_ && this->arg_->isOpaque())
         {
-          // Note that T could be a pointer or reference to a base class while data is in fact a
-          // child class. Lookup the correct type so we return an instance of the correct Ruby class
-          std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(data);
-          bool isOwner = this->arg_ && this->arg_->isOwner();
-          return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+          return VALUE(data);
         }
         else
         {
-          return Qnil;
+          Buffer<void> buffer(data);
+          Data_Object<Buffer<void>> dataObject(std::move(buffer));
+          return dataObject.value();
         }
       }
 
@@ -768,5 +1674,5 @@ namespace Rice
     private:
       Arg* arg_ = nullptr;
     };
-  }
+ }
 }