rice 4.6.1 → 4.7.0

data/rice/Pointer.ipp

@@ -0,0 +1,49 @@
+namespace Rice
+{
+  template<typename T>
+  inline Data_Type<Pointer<T>> define_pointer(std::string klassName)
+  {
+    using Pointer_T = Pointer<T>;
+    using Data_Type_T = Data_Type<Pointer_T>;
+
+    if (klassName.empty())
+    {
+      detail::TypeMapper<Pointer_T> typeMapper;
+      klassName = typeMapper.rubyName();
+    }
+
+    Module rb_mRice = define_module("Rice");
+
+    if (Data_Type_T::check_defined(klassName, rb_mRice))
+    {
+      return Data_Type_T();
+    }
+
+    Data_Type<Pointer<T>> result = define_class_under<Pointer_T>(rb_mRice, klassName).
+      define_method("buffer", [](VALUE self) -> Buffer<T>
+      {
+        T* ptr = detail::unwrap<T>(self, Data_Type<Pointer<T>>::ruby_data_type(), false);
+        Buffer<T> buffer(ptr);
+        return buffer;
+      }, Arg("self").setValue());
+
+    // Define a buffer to read the pointer's data
+    define_buffer<T>();
+
+    return result;
+  }
+}
+
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<Pointer<T>>
+  {
+    static bool verify()
+    {
+      detail::verifyType<T>();
+      define_pointer<T>();
+      return true;
+    }
+  };
+}

data/rice/Return.hpp

@@ -13,7 +13,7 @@ namespace Rice
     Return& setValue() override;
     Return& setOpaque() override;
     Return& takeOwnership() override;
-    Return& setArray() override;
+    Return& setBuffer() override;
   };
 } // Rice
 

data/rice/Return.ipp

@@ -30,9 +30,9 @@ namespace Rice
     return *this;
   }
 
-  inline Return& Return::setArray()
+  inline Return& Return::setBuffer()
   {
-    Arg::setArray();
+    Arg::setBuffer();
     return *this;
   }
 }  // Rice

data/rice/api.hpp

@@ -0,0 +1,30 @@
+#ifndef Rice__Api_hpp_
+#define Rice__Api_hpp_
+
+#include "rice_api/ModuleRegistry.hpp"
+#include "rice_api/ModuleRegistry.ipp"
+#include "rice_api/NativeRegistry.hpp"
+#include "rice_api/NativeRegistry.ipp"
+#include "rice_api/TypeRegistry.hpp"
+#include "rice_api/TypeRegistry.ipp"
+#include "rice_api/Registries.hpp"
+#include "rice_api/Registries.ipp"
+#include "rice_api/Arg.hpp"
+#include "rice_api/Arg.ipp"
+#include "rice_api/Parameter.hpp"
+#include "rice_api/Parameter.ipp"
+#include "rice_api/Native.hpp"
+#include "rice_api/Native.ipp"
+
+extern "C"
+inline void Init_Rice_Api()
+{
+  Init_Registries();
+  Init_Module_Registry();
+  Init_Native_Registry();
+  Init_Type_Registry();
+  Init_Arg();
+  Init_Parameter();
+  Init_Native();
+}
+#endif

data/rice/cpp_api/Array.hpp

@@ -47,7 +47,7 @@ namespace Rice
     /*! \param a a C array of type T and size n.
      */
     template<typename T, long n>
-    Array(T const (&a)[n]);
+    Array(T (&a)[n]);
 
   public:
     //! Return the size of the array.
@@ -92,7 +92,7 @@ namespace Rice
      *  \return the object which was pushed onto the array.
      */
     template<typename T>
-    Object push(T obj);
+    Object push(T&& obj, bool takeOwnership);
 
     //! Pop an element from the end of the array
     /*! \return the object which was popped from the array, or Qnil if

data/rice/cpp_api/Array.ipp

@@ -24,16 +24,16 @@ namespace Rice
   {
     for (; it != end; ++it)
     {
-      push(*it);
+      push(*it, false);
     }
   }
 
   template<typename T, long n>
-  inline Array::Array(T const (&a)[n]) : Builtin_Object<T_ARRAY>(detail::protect(rb_ary_new))
+  inline Array::Array(T (&a)[n]) : Builtin_Object<T_ARRAY>(detail::protect(rb_ary_new))
   {
     for (long j = 0; j < n; ++j)
     {
-      push(a[j]);
+      push(a[j], false);
     }
   }
 
@@ -65,9 +65,16 @@ namespace Rice
   }
 
   template<typename T>
-  inline Object Array::push(T obj)
+  inline Object Array::push(T&& obj, bool takeOwnership)
   {
-    return detail::protect(rb_ary_push, value(), detail::To_Ruby<T>().convert(std::forward<T>(obj)));
+    Return returnInfo;
+    if (takeOwnership)
+    {
+      returnInfo.takeOwnership();
+    }
+
+    detail::To_Ruby<detail::remove_cv_recursive_t<T>> toRuby(&returnInfo);
+    return detail::protect(rb_ary_push, value(), toRuby.convert(std::forward<T>(obj)));
   }
 
   inline Object Array::pop()
@@ -247,42 +254,80 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cArray;
+    }
   };
 
   template<>
   class To_Ruby<Array>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(Array const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<Array&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(Array const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<Array*>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(Array const* x)
     {
       return x->value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class From_Ruby<Array>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))

data/rice/cpp_api/Class.hpp

@@ -1,11 +1,6 @@
 #ifndef Rice__Class__hpp_
 #define Rice__Class__hpp_
 
-/*!
- *  \example inheritance/animals.cpp
- *  \example callbacks/sample_callbacks.cpp
- */
-
 namespace Rice
 {
   //! A helper for defining a Class and its methods.

data/rice/cpp_api/Class.ipp

@@ -85,6 +85,25 @@ namespace Rice::detail
     }
   };
 
+  template<>
+  class To_Ruby<Class&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(Class const& x)
+    {
+      return x.value();
+    }
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };
+
   template<>
   class From_Ruby<Class>
   {

data/rice/cpp_api/Hash.ipp

@@ -221,22 +221,42 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cHash;
+    }
   };
 
   template<>
   class To_Ruby<Hash>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(Hash const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class From_Ruby<Hash>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))

data/rice/cpp_api/Module.hpp

@@ -49,15 +49,18 @@ namespace Rice
 
     #include "shared_methods.hpp"
   protected:
-    template<bool IsMethod, typename Function_T>
-    void wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+    template<typename Function_T>
+    void wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+
+    template<typename Class_T = VALUE, typename Method_T>
+    void wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo);
   };
 
   //! Define a new module in the namespace given by module.
   /*! \param module the module in which to define the new module.
    *  \param name the name of the new module.
    */
-  Module define_module_under(Object module, char const * name);
+  Module define_module_under(Object parent, char const * name);
 
   //! Define a new module in the default namespace.
   /*! \param name the name of the new module.

data/rice/cpp_api/Module.ipp

@@ -32,26 +32,30 @@ namespace Rice
     this->set_value(result);
   }
 
-  template<bool IsMethod, typename Function_T>
-  inline void Module::wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo)
+  template<typename Function_T>
+  inline void Module::wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo)
   {
-    // Make sure the return type and arguments have been previously seen by Rice
-    using traits = detail::method_traits<Function_T, IsMethod>;
-    detail::verifyType<typename traits::Return_T>();
-    detail::verifyTypes<typename traits::Arg_Ts>();
+    detail::NativeFunction<Function_T>::define(klass, name, std::forward<Function_T>(function), methodInfo);
+  }
 
-    // Define a NativeFunction to bridge Ruby to C++
-    detail::NativeFunction<VALUE, Function_T, IsMethod>::define(klass, name, std::forward<Function_T>(function), methodInfo);
+  template<typename Class_T, typename Method_T>
+  inline void Module::wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo)
+  {
+    detail::NativeMethod<Class_T, Method_T>::define(klass, name, std::forward<Method_T>(method), methodInfo);
   }
 
-  inline Module define_module_under(Object module, char const* name)
+  inline Module define_module_under(Object parent, char const* name)
   {
-    return detail::protect(rb_define_module_under, module.value(), name);
+    VALUE module = detail::protect(rb_define_module_under, parent.value(), name);
+    detail::Registries::instance.modules.add(module);
+    return module;
   }
 
   inline Module define_module(char const* name)
   {
-    return detail::protect(rb_define_module, name);
+    VALUE module = detail::protect(rb_define_module, name);
+    detail::Registries::instance.modules.add(module);
+    return module;
   }
 
   inline Module anonymous_module()
@@ -77,16 +81,50 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cModule;
+    }
   };
 
   template<>
   class To_Ruby<Module>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(Module const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };
+
+
+  template<>
+  class To_Ruby<Module&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(Module const& x)
+    {
+      return x.value();
+    }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>

data/rice/cpp_api/Object.ipp

@@ -189,32 +189,61 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cObject;
+    }
   };
 
   template<>
   class To_Ruby<Object>
   {
   public:
-    static VALUE convert(Object const& x)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(Object const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<Object&>
   {
   public:
-    static VALUE convert(Object const& x)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(Object const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class From_Ruby<Object>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))

data/rice/cpp_api/String.hpp

@@ -13,8 +13,7 @@ namespace Rice
    *    std::cout << s.length() << std::endl;
    *  \endcode
    */
-  class String
-    : public Builtin_Object<T_STRING>
+  class String : public Builtin_Object<T_STRING>
   {
   public:
     //! Construct a new string.

data/rice/cpp_api/String.ipp

@@ -66,7 +66,7 @@ namespace Rice
   template<typename T>
   inline Array String::unpack() const
   {
-    return this->call("unpack", detail::RubyType<T>::packTemplate.c_str());
+    return this->call("unpack", detail::RubyType<detail::remove_cv_recursive_t<T>>::packTemplate.c_str());
   }
 
   inline Identifier String::intern() const
@@ -84,22 +84,42 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
   };
   
   template<>
   class To_Ruby<String>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(String const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class From_Ruby<String>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))

data/rice/cpp_api/Struct.ipp

@@ -88,5 +88,10 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cStruct;
+    }
   };
 }

data/rice/cpp_api/Symbol.ipp

@@ -54,16 +54,50 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cSymbol;
+    }
   };
   
   template<>
   class To_Ruby<Symbol>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(Symbol const& x)
     {
       return x.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };
+
+
+  template<>
+  class To_Ruby<Symbol&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(Symbol const& x)
+    {
+      return x.value();
+    }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>

data/rice/cpp_api/shared_methods.hpp

@@ -30,11 +30,11 @@ inline auto& include_module(Module const& inc)
  *  \param args a list of Arg instance used to define default parameters.
  *  \return *this
  */
-template<typename Function_T, typename...Arg_Ts>
-inline auto& define_method(std::string name, Function_T&& func, const Arg_Ts&...args)
+template<typename Method_T, typename...Arg_Ts>
+inline auto& define_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, true>::arity, args...);
-  this->wrap_native_call<true>(this->value(), name, std::forward<Function_T>(func), methodInfo);
+  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
+  this->wrap_native_method(this->value(), name, std::forward<Method_T>(method), methodInfo);
   return *this;
 }
 
@@ -52,8 +52,8 @@ inline auto& define_method(std::string name, Function_T&& func, const Arg_Ts&...
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, false>::arity, args...);
-  this->wrap_native_call<false>(this->value(), name, std::forward<Function_T>(func), methodInfo);
+  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
+  this->wrap_native_function(this->value(), name, std::forward<Function_T>(func), methodInfo);
   return *this;
 }
 
@@ -72,11 +72,11 @@ inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&.
  *  \param args a list of Arg instance used to define default parameters (optional)
  *  \return *this
  */
-template<typename Function_T, typename...Arg_Ts>
-inline auto& define_singleton_method(std::string name, Function_T&& func, const Arg_Ts&...args)
+template<typename Method_T, typename...Arg_Ts>
+inline auto& define_singleton_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, true>::arity, args...);
-  this->wrap_native_call<true>(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
+  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
+  this->wrap_native_method(rb_singleton_class(*this), name, std::forward<Method_T>(method), methodInfo);
   return *this;
 }
 
@@ -94,8 +94,8 @@ inline auto& define_singleton_method(std::string name, Function_T&& func, const
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_singleton_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Function_T, false>::arity, args...);
-  this->wrap_native_call<false>(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
+  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
+  this->wrap_native_function(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
   return *this;
 }