rice 4.3.2 → 4.5.0

data/rice/detail/to_ruby.ipp

@@ -1,5 +1,3 @@
-#include "RubyFunction.hpp"
-#include "../Return.hpp"
 
 namespace Rice
 {
@@ -9,172 +7,308 @@ namespace Rice
     class To_Ruby<void>
     {
     public:
-      VALUE convert(void const*)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const void*)
       {
+        throw std::runtime_error("Converting from void pointer is not implemented");
         return Qnil;
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<std::nullptr_t>
     {
     public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       VALUE convert(std::nullptr_t const)
       {
         return Qnil;
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<short>
     {
     public:
-      VALUE convert(short const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const short& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_int2num_inline, (int)x);
+        return protect(rb_int2num_inline, (int)native);
 #else
-        return RB_INT2NUM(x);
+        return RB_INT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<short&>
     {
     public:
-      VALUE convert(short const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const short& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_int2num_inline, (int)x);
+        return protect(rb_int2num_inline, (int)native);
 #else
-        return RB_INT2NUM(x);
+        return RB_INT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<int>
     {
     public:
-      VALUE convert(int const& x)
+      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)x);
+        return protect(rb_int2num_inline, (int)native);
 #else
-        return RB_INT2NUM(x);
+        return RB_INT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<int&>
     {
     public:
-      VALUE convert(int const& x)
+      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)x);
+        return protect(rb_int2num_inline, (int)native);
 #else
-        return RB_INT2NUM(x);
+        return RB_INT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<long>
     {
     public:
-      VALUE convert(long const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const long& native)
       {
-        return protect(rb_long2num_inline, x);
+        return protect(rb_long2num_inline, native);
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<long&>
     {
     public:
-      VALUE convert(long const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return protect(rb_long2num_inline, x);
       }
+
+      VALUE convert(const long& native)
+      {
+        return protect(rb_long2num_inline, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<long long>
     {
     public:
-      VALUE convert(long long const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const long long& native)
       {
-        return protect(rb_ll2inum, x);
+        return protect(rb_ll2inum, native);
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<long long&>
     {
     public:
-      VALUE convert(long long const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return protect(rb_ll2inum, x);
       }
+
+      VALUE convert(const long long& native)
+      {
+        return protect(rb_ll2inum, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<unsigned short>
     {
     public:
-      VALUE convert(unsigned short const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned short& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)x);
+        return protect(rb_uint2num_inline, (unsigned int)native);
 #else
-        return RB_UINT2NUM(x);
+        return RB_UINT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<unsigned short&>
     {
     public:
-      VALUE convert(unsigned short const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned short& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)x);
+        return protect(rb_uint2num_inline, (unsigned int)native);
 #else
-        return RB_UINT2NUM(x);
+        return RB_UINT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<unsigned int>
     {
     public:
-      VALUE convert(unsigned int const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned int& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)x);
+        return protect(rb_uint2num_inline, (unsigned int)native);
 #else
-        return RB_UINT2NUM(x);
+        return RB_UINT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<unsigned int&>
     {
     public:
-      VALUE convert(unsigned int const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const unsigned int& native)
       {
 #ifdef rb_int2num_inline
-        return protect(rb_uint2num_inline, (unsigned int)x);
+        return protect(rb_uint2num_inline, (unsigned int)native);
 #else
-        return RB_UINT2NUM(x);
+        return RB_UINT2NUM(native);
 #endif
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
@@ -183,24 +317,24 @@ namespace Rice
     public:
       To_Ruby() = default;
 
-      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
       }
 
-      VALUE convert(unsigned long const& x)
+      VALUE convert(const unsigned long& native)
       {
-        if (this->returnInfo_ && this->returnInfo_->isValue())
+        if (this->arg_ && this->arg_->isValue())
         {
-          return x;
+          return native;
         }
         else
         {
-          return protect(rb_ulong2num_inline, x);
+          return protect(rb_ulong2num_inline, native);
         }
       }
 
     private:
-      Return* returnInfo_ = nullptr;
+      Arg* arg_ = nullptr;
     };
 
     template<>
@@ -209,24 +343,24 @@ namespace Rice
     public:
       To_Ruby() = default;
 
-      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
       }
 
-      VALUE convert(unsigned long const& x)
+      VALUE convert(const unsigned long& native)
       {
-        if (this->returnInfo_ && this->returnInfo_->isValue())
+        if (this->arg_ && this->arg_->isValue())
         {
-          return x;
+          return native;
         }
         else
         {
-          return protect(rb_ulong2num_inline, x);
+          return protect(rb_ulong2num_inline, native);
         }
       }
 
     private:
-      Return* returnInfo_ = nullptr;
+      Arg* arg_ = nullptr;
     };
 
     template<>
@@ -235,24 +369,35 @@ namespace Rice
     public:
       To_Ruby() = default;
 
-      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
       }
 
-      VALUE convert(unsigned long long const& x)
+      VALUE convert(const unsigned long long& native)
       {
-        if (this->returnInfo_ && this->returnInfo_->isValue())
+        if (this->arg_ && this->arg_->isValue())
         {
-          return x;
+          return native;
         }
         else
         {
-          return protect(rb_ull2inum, (unsigned long long)x);
+          return protect(rb_ull2inum, (unsigned long long)native);
         }
       }
 
+      VALUE convert(const volatile unsigned long long& native)
+      {
+        if (this->arg_ && this->arg_->isValue())
+        {
+          return native;
+        }
+        else
+        {
+          return protect(rb_ull2inum, (unsigned long long)native);
+        }
+      }
     private:
-      Return* returnInfo_ = nullptr;
+      Arg* arg_ = nullptr;
     };
 
     template<>
@@ -261,188 +406,367 @@ namespace Rice
     public:
       To_Ruby() = default;
 
-      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
       }
 
-      VALUE convert(unsigned long long const& x)
+      VALUE convert(const unsigned long long& native)
       {
-        if (this->returnInfo_ && this->returnInfo_->isValue())
+        if (this->arg_ && this->arg_->isValue())
         {
-          return x;
+          return native;
         }
         else
         {
-          return protect(rb_ull2inum, (unsigned long long)x);
+          return protect(rb_ull2inum, (unsigned long long)native);
         }
       }
 
     private:
-      Return* returnInfo_ = nullptr;
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<float>
     {
     public:
-      VALUE convert(float const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return protect(rb_float_new, (double)x);
       }
+
+      VALUE convert(const float& native)
+      {
+        return protect(rb_float_new, (double)native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<float&>
     {
     public:
-      VALUE convert(float const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const float& native)
       {
-        return protect(rb_float_new, (double)x);
+        return protect(rb_float_new, (double)native);
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<double>
     {
     public:
-      VALUE convert(double const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return protect(rb_float_new, x);
       }
+
+      VALUE convert(const double& native)
+      {
+        return protect(rb_float_new, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<double&>
     {
     public:
-      VALUE convert(double const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const double& native)
       {
-        return protect(rb_float_new, x);
+        return protect(rb_float_new, native);
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<bool>
     {
     public:
-      VALUE convert(bool const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const bool& native)
       {
-        return x ? Qtrue : Qfalse;
+        return native ? Qtrue : Qfalse;
       }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<bool&>
     {
     public:
-      VALUE convert(bool const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return x ? Qtrue : Qfalse;
       }
+
+      VALUE convert(const bool& native)
+      {
+        return native ? Qtrue : Qfalse;
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<char>
     {
     public:
-      VALUE convert(char const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return To_Ruby<int>().convert(x);
       }
+
+      VALUE convert(const char& native)
+      {
+        return To_Ruby<int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
     class To_Ruby<char&>
     {
     public:
-      VALUE convert(char const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return To_Ruby<int>().convert(x);
       }
+
+      VALUE convert(const char& native)
+      {
+        return To_Ruby<int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<unsigned char>
+    class To_Ruby<char*>
     {
     public:
-      VALUE convert(unsigned char const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char* buffer)
       {
-        return To_Ruby<unsigned int>().convert(x);
+        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);
+        }
       }
+
+    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<unsigned char&>
+    class To_Ruby<unsigned char>
     {
     public:
-      VALUE convert(unsigned char const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return To_Ruby<unsigned int>().convert(x);
       }
+
+      VALUE convert(const unsigned char& native)
+      {
+        return To_Ruby<unsigned int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<signed char>
+    class To_Ruby<unsigned char&>
     {
     public:
-      VALUE convert(signed char const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return To_Ruby<signed int>().convert(x);
       }
+
+      VALUE convert(const unsigned char& native)
+      {
+        return To_Ruby<unsigned int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<signed char&>
+    class To_Ruby<signed char>
     {
     public:
-      VALUE convert(signed char const& x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        return To_Ruby<signed int>().convert(x);
       }
+
+      VALUE convert(const signed char& native)
+      {
+        return To_Ruby<signed int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
     template<>
-    class To_Ruby<char*>
+    class To_Ruby<signed char&>
     {
     public:
-      VALUE convert(char const* x)
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
-        if (strlen(x) > 0 && x[0] == ':')
-        {
-          size_t symbolLength = strlen(x) - 1;
-          char* symbol = new char[symbolLength];
-          strncpy(symbol, x + 1, symbolLength);
-          ID id = protect(rb_intern2, symbol, (long)symbolLength);
-          delete[] symbol;
-          return protect(rb_id2sym, id);
-        }
-        else
-        {
-          return protect(rb_str_new2, x);
-        }
       }
+
+      VALUE convert(const signed char& native)
+      {
+        return To_Ruby<signed int>().convert(native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
 
-    template<int N>
-    class To_Ruby<char[N]>
+    template <>
+    class To_Ruby<void*>
     {
     public:
-      VALUE convert(char const x[])
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(void* data)
       {
-        if (N > 0 && x[0] == ':')
+        if (this->arg_ && this->arg_->isOpaque())
         {
-          // N count includes a NULL character at the end of the string
-          constexpr size_t symbolLength = N - 1;
-          char symbol[symbolLength];
-          strncpy(symbol, x + 1, symbolLength);
-          ID id = protect(rb_intern, symbol);
-          return protect(rb_id2sym, id);
+          return VALUE(data);
+        }
+        else if (data)
+        {
+          // 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);
         }
         else
         {
-          return protect(rb_str_new2, x);
+          return Qnil;
         }
       }
+
+      VALUE convert(const void* data)
+      {
+        return convert((void*)data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
     };
   }
 }