rice 2.1.2 → 4.0.1

data/rice/detail/to_ruby.hpp

@@ -1,22 +1,8 @@
 #ifndef Rice__detail__to_ruby__hpp_
 #define Rice__detail__to_ruby__hpp_
 
-namespace Rice
-{
-  namespace detail
-  {
-    template<typename T>
-    struct to_ruby_
-    {
-      static Rice::Object convert(T const & x);
-    };
-
-    template<typename T>
-    struct to_ruby_<T *>
-    {
-      static Rice::Object convert(T * x);
-    };
-  } // detail
-} // Rice
+#include "to_ruby_defn.hpp"
+#include "to_ruby.ipp"
 
 #endif // Rice__detail__to_ruby__hpp_
+

data/rice/detail/to_ruby.ipp

@@ -1,36 +1,414 @@
-#include "../Data_Object.hpp"
+#include "RubyFunction.hpp"
+#include "../Return.hpp"
 
-template<typename T>
-Rice::Object
-Rice::detail::to_ruby_<T>::
-convert(T const & x)
+namespace Rice
 {
-  if(Data_Type<T>::is_bound())
+  namespace detail
   {
-    return Rice::Data_Object<T >(new T(x), Rice::Data_Type<T >::klass());
-  }
-  else
-  {
-    std::string s("Unable to convert ");
-    s += demangle(typeid(T *).name());
-    throw std::invalid_argument(s.c_str());
-  }
-}   
+    template<>
+    class To_Ruby<void>
+    {
+    public:
+      VALUE convert(void const*)
+      {
+        return Qnil;
+      }
+    };
 
-template<typename T>
-Rice::Object
-Rice::detail::to_ruby_<T *>::
-convert(T * x)
-{
-  if(Data_Type<T>::is_bound())
-  {
-    Data_Object<T> obj(x);
-    return obj;
-  }
-  else
-  {
-    std::string s("Unable to convert ");
-    s += demangle(typeid(T *).name());
-    throw std::invalid_argument(s.c_str());
+    template<>
+    class To_Ruby<std::nullptr_t>
+    {
+    public:
+      VALUE convert(std::nullptr_t const)
+      {
+        return Qnil;
+      }
+    };
+
+    template<>
+    class To_Ruby<short>
+    {
+    public:
+      VALUE convert(short const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_int2num_inline, (int)x);
+#else
+        return RB_INT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<short&>
+    {
+    public:
+      VALUE convert(short const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_int2num_inline, (int)x);
+#else
+        return RB_INT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<int>
+    {
+    public:
+      VALUE convert(int const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_int2num_inline, (int)x);
+#else
+        return RB_INT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<int&>
+    {
+    public:
+      VALUE convert(int const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_int2num_inline, (int)x);
+#else
+        return RB_INT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<long>
+    {
+    public:
+      VALUE convert(long const& x)
+      {
+        return protect(rb_long2num_inline, x);
+      }
+    };
+
+    template<>
+    class To_Ruby<long&>
+    {
+    public:
+      VALUE convert(long const& x)
+      {
+        return protect(rb_long2num_inline, x);
+      }
+    };
+
+    template<>
+    class To_Ruby<long long>
+    {
+    public:
+      VALUE convert(long long const& x)
+      {
+        return protect(rb_ll2inum, x);
+      }
+    };
+
+    template<>
+    class To_Ruby<long long&>
+    {
+    public:
+      VALUE convert(long long const& x)
+      {
+        return protect(rb_ll2inum, x);
+      }
+    };
+
+    template<>
+    class To_Ruby<unsigned short>
+    {
+    public:
+      VALUE convert(unsigned short const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_uint2num_inline, (unsigned int)x);
+#else
+        return RB_UINT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<unsigned short&>
+    {
+    public:
+      VALUE convert(unsigned short const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_uint2num_inline, (unsigned int)x);
+#else
+        return RB_UINT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<unsigned int>
+    {
+    public:
+      VALUE convert(unsigned int const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_uint2num_inline, (unsigned int)x);
+#else
+        return RB_UINT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<unsigned int&>
+    {
+    public:
+      VALUE convert(unsigned int const& x)
+      {
+#ifdef rb_int2num_inline
+        return protect(rb_uint2num_inline, (unsigned int)x);
+#else
+        return RB_UINT2NUM(x);
+#endif
+      }
+    };
+
+    template<>
+    class To_Ruby<unsigned long>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      {
+      }
+
+      VALUE convert(unsigned long const& x)
+      {
+        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        {
+          return x;
+        }
+        else
+        {
+          return protect(rb_ulong2num_inline, x);
+        }
+      }
+
+    private:
+      Return* returnInfo_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned long&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      {
+      }
+
+      VALUE convert(unsigned long const& x)
+      {
+        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        {
+          return x;
+        }
+        else
+        {
+          return protect(rb_ulong2num_inline, x);
+        }
+      }
+
+    private:
+      Return* returnInfo_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned long long>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      {
+      }
+
+      VALUE convert(unsigned long long const& x)
+      {
+        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        {
+          return x;
+        }
+        else
+        {
+          return protect(rb_ull2inum, (unsigned long long)x);
+        }
+      }
+
+    private:
+      Return* returnInfo_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<unsigned long long&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      {
+      }
+
+      VALUE convert(unsigned long long const& x)
+      {
+        if (this->returnInfo_ && this->returnInfo_->getIsValue())
+        {
+          return x;
+        }
+        else
+        {
+          return protect(rb_ull2inum, (unsigned long long)x);
+        }
+      }
+
+    private:
+      Return* returnInfo_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<float>
+    {
+    public:
+      VALUE convert(float const& x)
+      {
+        return protect(rb_float_new, (double)x);
+      }
+    };
+
+    template<>
+    class To_Ruby<float&>
+    {
+    public:
+      VALUE convert(float const& x)
+      {
+        return protect(rb_float_new, (double)x);
+      }
+    };
+
+    template<>
+    class To_Ruby<double>
+    {
+    public:
+      VALUE convert(double const& x)
+      {
+        return protect(rb_float_new, x);
+      }
+    };
+
+    template<>
+    class To_Ruby<double&>
+    {
+    public:
+      VALUE convert(double const& x)
+      {
+        return protect(rb_float_new, x);
+      }
+    };
+
+    template<>
+    class To_Ruby<bool>
+    {
+    public:
+      VALUE convert(bool const& x)
+      {
+        return x ? Qtrue : Qfalse;
+      }
+    };
+
+    template<>
+    class To_Ruby<bool&>
+    {
+    public:
+      VALUE convert(bool const& x)
+      {
+        return x ? Qtrue : Qfalse;
+      }
+    };
+
+    template<>
+    class To_Ruby<char>
+    {
+    public:
+      VALUE convert(char const& x)
+      {
+        return To_Ruby<int>().convert(x);
+      }
+    };
+
+    template<>
+    class To_Ruby<char&>
+    {
+    public:
+      VALUE convert(char const& x)
+      {
+        return To_Ruby<int>().convert(x);
+      }
+    };
+
+    template<>
+    class To_Ruby<unsigned char>
+    {
+    public:
+      VALUE convert(unsigned char const& x)
+      {
+        return To_Ruby<unsigned int>().convert(x);
+      }
+    };
+
+    template<>
+    class To_Ruby<unsigned char&>
+    {
+    public:
+      VALUE convert(unsigned char const& x)
+      {
+        return To_Ruby<unsigned int>().convert(x);
+      }
+    };
+
+    template<>
+    class To_Ruby<signed char>
+    {
+    public:
+      VALUE convert(signed char const& x)
+      {
+        return To_Ruby<signed int>().convert(x);
+      }
+    };
+
+    template<>
+    class To_Ruby<signed char&>
+    {
+    public:
+      VALUE convert(signed char const& x)
+      {
+        return To_Ruby<signed int>().convert(x);
+      }
+    };
+
+    template<>
+    class To_Ruby<char*>
+    {
+    public:
+      VALUE convert(char const* x)
+      {
+        return protect(rb_str_new2, x);
+      }
+    };
   }
-}
+}