rice 3.0.0 → 4.0.3

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);
+      }
+    };
   }
-}
+}

data/rice/detail/to_ruby_defn.hpp

@@ -0,0 +1,48 @@
+#ifndef Rice__detail__to_ruby_defn__hpp_
+#define Rice__detail__to_ruby_defn__hpp_
+
+#include "rice_traits.hpp"
+
+namespace Rice
+{
+  namespace detail
+  {
+    //! Convert a C++ object to Ruby.
+    /*! If x is a pointer, wraps the pointee as a Ruby object.  If x is an
+     *  Object, returns x.
+     *
+     *  If no conversion exists a compile-time error is generated.
+     *
+     *  \param x the object to convert.
+     *  \return a Ruby representation of the C++ object.
+     *
+     *  Example:
+     *  \code
+     *    rb_p(to_ruby(42));
+     *
+     *    Foo * p_foo = new Foo();
+     *    rb_p(to_ruby(p_foo));
+     *  \endcode
+     */
+    template <typename T>
+    class To_Ruby;
+   
+    // Helper template function that let's users avoid having to specify the template type - its deduced
+    template <typename T>
+    VALUE to_ruby(T&& x)
+    {
+      using Unqualified_T = remove_cv_recursive_t<T>;
+      return To_Ruby<Unqualified_T>().convert(std::forward<T>(x));
+    }
+
+    // Helper template function that let's users avoid having to specify the template type - its deduced
+    template <typename T>
+    VALUE to_ruby(T* x)
+    {
+      using Unqualified_T = remove_cv_recursive_t<T>;
+      return To_Ruby<Unqualified_T*>().convert(x);
+    }
+  } // detail
+} // Rice
+
+#endif // Rice__detail__to_ruby_defn__hpp_

data/rice/forward_declares.ipp

@@ -0,0 +1,82 @@
+#ifndef Rice__Forward_Declares__ipp_
+#define Rice__Forward_Declares__ipp_
+
+namespace Rice
+{
+  // These methods cannot be defined where they are declared due to circular dependencies
+  inline Class Object::class_of() const
+  {
+    return detail::protect(rb_class_of, value_);
+  }
+
+  inline String Object::to_s() const
+  {
+    return call("to_s");
+  }
+
+  inline String Object::class_name() const
+  {
+    return detail::protect(rb_obj_classname, this->value());
+  }
+
+  inline String Object::inspect() const
+  {
+    return call("inspect");
+  }
+
+  inline Object Object::instance_eval(String const& s)
+  {
+    const VALUE argv[] = { s.value() };
+    return detail::protect(rb_obj_instance_eval, 1, &argv[0], this->value());
+  }
+
+  inline Object Object::vcall(Identifier id, Array args)
+  {
+    std::vector<VALUE> a(args.size());
+
+    Array::const_iterator it = args.begin();
+    Array::const_iterator end = args.end();
+
+    for (int i = 0; it != end; i++, ++it)
+    {
+      a[i] = it->value();
+    }
+
+    return detail::protect(rb_funcall3, this->value(), id.id(), (int)args.size(), (const VALUE*)a.data());
+  }
+
+  inline std::ostream& operator<<(std::ostream& out, Object const& obj)
+  {
+    String s(obj.to_s());
+    out << s.c_str();
+    return out;
+  }
+
+  inline Identifier::Identifier(Symbol const& symbol) : id_(SYM2ID(symbol.value()))
+  {
+  }
+
+  inline String Module::name() const
+  {
+    VALUE name = detail::protect(rb_mod_name, this->value());
+    if (name == Qnil)
+    {
+      return String("");
+    }
+    else
+    {
+      return name;
+    }
+  }
+
+  inline Array Module::ancestors() const
+  {
+    return detail::protect(rb_mod_ancestors, this->value());
+  }
+
+  inline Class Module::singleton_class() const
+  {
+    return CLASS_OF(value());
+  }
+}
+#endif // Rice__Forward_Declares__ipp_

data/rice/global_function.hpp

@@ -5,27 +5,23 @@
 
 namespace Rice
 {
+  template<typename Function_T>
+  [[deprecated("Please call define_global_function with Arg parameters")]]
+  void define_global_function(char const * name, Function_T&& func, MethodInfo* arguments);
 
-  /**
-   * Helper forwarder method to easily wrap
-   * globally available functions. This simply
-   * forwards off a call to define_module_function
-   * on rb_mKernel
-   */
-  template<typename Func_T>
-  void define_global_function(
-      char const * name,
-      Func_T func,
-      Arguments* arguments = 0);
-
-  // FIXME: See Module::define_method with Arg
-  template<typename Func_T>
-  void define_global_function(
-      char const * name,
-      Func_T func,
-      Arg const& arg);
-  
-
+   //! Define an global function
+   /*! The method's implementation can be any function or static member
+    *  function.  A wrapper will be generated which will convert the arguments
+    *  from ruby types to C++ types before calling the function.  The return
+    *  value will be converted back to ruby.
+    *  \param name the name of the method
+    *  \param func the implementation of the function, either a function
+    *  pointer or a member function pointer.
+    *  \param args a list of Arg instance used to define default parameters (optional)
+    *  \return *this
+    */
+  template<typename Function_T, typename...Arg_Ts>
+  void define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args);
 } // Rice
 
 #include "global_function.ipp"

data/rice/global_function.ipp

@@ -1,22 +1,13 @@
-#include "detail/define_method_and_auto_wrap.hpp"
+#include "cpp_api/Module.hpp"
 
-template<typename Func_T>
-void Rice::define_global_function(
-    char const * name,
-    Func_T func,
-    Arguments* arguments)
+template<typename Function_T>
+void Rice::define_global_function(char const * name, Function_T&& func, MethodInfo* methodInfo)
 {
-  Module(rb_mKernel).define_module_function(name, func, arguments);
+  Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), methodInfo);
 }
 
-template<typename Func_T>
-void Rice::define_global_function(
-    char const * name,
-    Func_T func,
-    Arg const& arg)
+template<typename Function_T, typename...Arg_Ts>
+void Rice::define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args)
 {
-  Arguments* args = new Arguments();
-  args->add(arg);
-  define_global_function(name, func, args);
-}
-
+  Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), args...);
+}

data/rice/rice.hpp

@@ -0,0 +1,59 @@
+#ifndef Rice__hpp_
+#define Rice__hpp_
+
+#include "detail/ruby.hpp"
+#include "detail/rice_traits.hpp"
+#include "detail/function_traits.hpp"
+#include "detail/Type.hpp"
+#include "detail/TypeRegistry.hpp"
+#include "detail/Wrapper.hpp"
+#include "detail/default_allocation_func.hpp"
+#include "detail/Jump_Tag.hpp"
+#include "Exception_defn.hpp"
+#include "detail/RubyFunction.hpp"
+#include "Return.hpp"
+#include "Arg.hpp"
+#include "detail/from_ruby.hpp"
+#include "detail/to_ruby.hpp"
+#include "detail/MethodInfo.hpp"
+#include "detail/Exception_Handler.hpp"
+#include "detail/Iterator.hpp"
+#include "Exception.ipp"
+#include "detail/method_data.hpp"
+#include "ruby_try_catch.hpp"
+#include "detail/NativeAttribute.hpp"
+#include "detail/NativeFunction.hpp"
+
+#include "ruby_mark.hpp"
+
+#include "Identifier.hpp"
+
+#include "cpp_api/Object.hpp"
+#include "cpp_api/Builtin_Object.hpp"
+#include "cpp_api/String.hpp"
+#include "cpp_api/Array.hpp"
+#include "cpp_api/Hash.hpp"
+#include "cpp_api/Symbol.hpp"
+
+#include "Address_Registration_Guard.hpp"
+#include "cpp_api/Module.hpp"
+#include "global_function.hpp"
+
+#include "cpp_api/Class.hpp"
+#include "cpp_api/Struct.hpp"
+
+#include "Director.hpp"
+#include "Data_Type.hpp"
+#include "Constructor.hpp"
+#include "Data_Object.hpp"
+#include "detail/Iterator.ipp"
+
+// Dependent on Data_Object due to the way method metadata is stored in the Ruby class
+#include "detail/default_allocation_func.ipp"
+
+#include "Enum.hpp"
+
+// Dependent on Module, Class, Array and String
+#include "forward_declares.ipp"
+
+#endif // Rice__hpp_