rice 4.7.0 → 4.8.0

data/rice/Buffer.ipp

@@ -102,11 +102,11 @@ namespace Rice
       }
       default:
       {
-        if (RubyType_T::Exact.find(valueType) != RubyType_T::Exact.end() ||
-          RubyType_T::Castable.find(valueType) != RubyType_T::Castable.end() ||
-          RubyType_T::Narrowable.find(valueType) != RubyType_T::Narrowable.end())
+        if (detail::From_Ruby<detail::remove_cv_recursive_t<T>>().is_convertible(value))
         {
-          T data = detail::protect(RubyType_T::fromRuby, value);
+          // The Ruby method may return a different type - for example Ruby floats
+          // are converted to double and not float - so we need a typecast.
+          T data = (T)detail::protect(RubyType_T::fromRuby, value);
           this->m_size = 1;
           this->m_buffer = new T[this->m_size]();
           memcpy((void*)this->m_buffer, &data, sizeof(T));
@@ -115,9 +115,9 @@ namespace Rice
         }
         else
         {
-          detail::TypeMapper<T> typeMapper;
-          std::string typeName = typeMapper.name();
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+          detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+          std::string typeName = typeIndexParser.name();
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
             detail::protect(rb_obj_classname, value), typeName.c_str());
         }
       }
@@ -137,8 +137,8 @@ namespace Rice
         this->m_size = array.size();
 
         // Use operator new[] to allocate memory but not call constructors.
-        size_t size = sizeof(T) * this->m_size;
-        this->m_buffer = static_cast<T*>(operator new[](size));
+        size_t memsize = sizeof(T) * this->m_size;
+        this->m_buffer = static_cast<T*>(operator new[](memsize));
 
         detail::From_Ruby<Intrinsic_T> fromRuby;
 
@@ -147,7 +147,7 @@ namespace Rice
           // Construct objects in allocated memory using move or copy construction
           if constexpr (std::is_move_constructible_v<T>)
           {
-            new (&this->m_buffer[i]) T(std::move(fromRuby.convert(array[i].value())));
+            new (&this->m_buffer[i]) T(std::move(fromRuby.convert(array[(long)i].value())));
           }
           else if constexpr (std::is_copy_constructible_v<T>)
           {
@@ -155,8 +155,9 @@ namespace Rice
           }
           else
           {
+            detail::TypeIndexParser typeIndexParser(typeid(Intrinsic_T), std::is_fundamental_v<Intrinsic_T>);
             throw Exception(rb_eTypeError, "Cannot construct object of type %s - type is not move or copy constructible",
-              detail::TypeMapper<Intrinsic_T>().name().c_str());
+              typeIndexParser.name().c_str());
           }
         }
         break;
@@ -196,9 +197,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<T> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -267,8 +268,8 @@ namespace Rice
   template<typename T>
   inline VALUE Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::toString() const
   {
-    detail::TypeMapper<T*> typeMapper;
-    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+    detail::TypeIndexParser typeIndexParser(typeid(T*), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    std::string description = "Buffer<type: " + typeIndexParser.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
 
     // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
     return detail::protect(rb_utf8_str_new_cstr, description.c_str());
@@ -345,7 +346,7 @@ namespace Rice
   }
 
   template<typename T>
-  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_buffer(pointer), m_size(size)
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_size(size), m_buffer(pointer)
   {
   }
 
@@ -373,7 +374,7 @@ namespace Rice
         for (size_t i = 0; i < this->m_size; i++)
         {
           // Check the inner value is also an array
-          Array inner(outer[i].value());
+          Array inner(outer[(long)i].value());
 
           // Allocate inner buffer
           this->m_buffer[i] = new T[inner.size()]();
@@ -383,13 +384,16 @@ namespace Rice
             String packed = inner.pack<Intrinsic_T>();
             memcpy((void*)this->m_buffer[i], RSTRING_PTR(packed.value()), RSTRING_LEN(packed.value()));
           }
+          // This is for std::string, should be a 1 length array
           else
           {
             detail::From_Ruby<Intrinsic_T*> fromRuby;
-            for (int i = 0; i < inner.size(); i++)
+            if (inner.size() != 1)
             {
-              this->m_buffer[0] = fromRuby.convert(inner[i].value());
+              throw Exception(rb_eTypeError, "Expected inner array size 1 for type %s* but got %ld",
+                detail::TypeIndexParser(typeid(T)).name().c_str(), inner.size());
             }
+            this->m_buffer[i] = fromRuby.convert(inner[0].value());
           }
         }
 
@@ -409,9 +413,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<T> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -495,8 +499,8 @@ namespace Rice
   template<typename T>
   inline VALUE Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::toString() const
   {
-    detail::TypeMapper<T*> typeMapper;
-    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+    detail::TypeIndexParser typeIndexParser(typeid(T*), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    std::string description = "Buffer<type: " + typeIndexParser.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
 
     // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
     return detail::protect(rb_utf8_str_new_cstr, description.c_str());
@@ -559,7 +563,7 @@ namespace Rice
   }
 
   template<typename T>
-  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_buffer(pointer), m_size(size)
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_size(size), m_buffer(pointer)
   {
   }
 
@@ -584,7 +588,7 @@ namespace Rice
 
         for (size_t i = 0; i < this->m_size; i++)
         {
-          this->m_buffer[i] = fromRuby.convert(array[i].value());
+          this->m_buffer[i] = fromRuby.convert(array[(long)i].value());
         }
 
         this->m_owner = true;
@@ -602,9 +606,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<T> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -687,8 +691,8 @@ namespace Rice
   template<typename T>
   inline VALUE Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::toString() const
   {
-    detail::TypeMapper<T*> typeMapper;
-    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+    detail::TypeIndexParser typeIndexParser(typeid(T*), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    std::string description = "Buffer<type: " + typeIndexParser.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
 
     // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
     return detail::protect(rb_utf8_str_new_cstr, description.c_str());
@@ -750,7 +754,7 @@ namespace Rice
   }
   
   template<typename T>
-  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(VALUE value, size_t size)
+  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(VALUE value, size_t)
   {
     ruby_value_type valueType = rb_type(value);
 
@@ -767,9 +771,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<void> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -863,8 +867,8 @@ namespace Rice
         define_method("size", &Buffer_T::size).
         template define_method<VALUE(Buffer_T::*)(size_t) const>("bytes", &Buffer_T::bytes, Return().setValue()).
         template define_method<VALUE(Buffer_T::*)() const>("bytes", &Buffer_T::bytes, Return().setValue()).
-        define_method("data", &Buffer_T::ptr, Return().setBuffer()).
-        define_method("release", &Buffer_T::release, Return().setBuffer());
+        define_method("data", &Buffer_T::ptr, ReturnBuffer()).
+        define_method("release", &Buffer_T::release, ReturnBuffer());
     }
     else
     {
@@ -878,8 +882,8 @@ namespace Rice
         template define_method<Array(Buffer_T::*)(size_t) const>("to_ary", &Buffer_T::toArray, Return().setValue()).
         template define_method<Array(Buffer_T::*)() const>("to_ary", &Buffer_T::toArray, Return().setValue()).
         define_method("[]", &Buffer_T::operator[], Arg("index")).
-        define_method("data", &Buffer_T::ptr, Return().setBuffer()).
-        define_method("release", &Buffer_T::release, Return().setBuffer());
+        define_method("data", &Buffer_T::ptr, ReturnBuffer()).
+        define_method("release", &Buffer_T::release, ReturnBuffer());
 
       if constexpr (!std::is_pointer_v<T> && !std::is_void_v<T> && !std::is_const_v<T> && std::is_copy_assignable_v<T>)
       {

data/rice/Callback.hpp

@@ -16,6 +16,6 @@ namespace Rice
    *  \return nothing
    */
   template<typename Callback_T, typename...Arg_Ts>
-  void define_callback(const Arg_Ts&...args);
+  void define_callback(Arg_Ts&&...args);
 }
 #endif // Rice__Callback__hpp_

data/rice/Callback.ipp

@@ -1,13 +1,8 @@
 namespace Rice
 {
   template<typename Callback_T, typename...Arg_Ts>
-  void define_callback(const Arg_Ts&...args)
+  inline void define_callback(Arg_Ts&&...args)
   {
-    MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Callback_T>::arity, args...);
-  #ifdef HAVE_LIBFFI
-    detail::NativeCallbackFFI<Callback_T>::setMethodInfo(methodInfo);
-  #else
-    detail::NativeCallbackSimple<Callback_T>::setMethodInfo(methodInfo);
-  #endif
+    detail::NativeCallback<Callback_T>::define(std::forward<Arg_Ts>(args)...);
   }
 }

data/rice/Constructor.hpp

@@ -16,7 +16,7 @@ namespace Rice
   *
   *  For more information, see Rice::Data_Type::define_constructor.
   */
-  template<typename T, typename...Arg_Ts>
+  template<typename T, typename...Parameter_Ts>
   class Constructor;
 }
 #endif // Rice__Constructor__hpp_

data/rice/Constructor.ipp

@@ -1,16 +1,16 @@
 namespace Rice
 {
-  template<typename T, typename...Arg_Ts>
+  template<typename T, typename...Parameter_Ts>
   class Constructor
   {
   public:
-    static constexpr std::size_t arity = sizeof...(Arg_Ts);
+    static constexpr std::size_t arity = sizeof...(Parameter_Ts);
 
     static constexpr bool isCopyConstructor()
     {
       if constexpr (arity == 1)
       {
-        using Arg_Types = std::tuple<Arg_Ts...>;
+        using Arg_Types = std::tuple<Parameter_Ts...>;
         using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
         return (arity == 1 &&
                 std::is_lvalue_reference_v<First_Arg_T> &&
@@ -26,7 +26,7 @@ namespace Rice
     {
       if constexpr (arity == 1)
       {
-        using Arg_Types = std::tuple<Arg_Ts...>;
+        using Arg_Types = std::tuple<Parameter_Ts...>;
         using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
         return (arity == 1 &&
           std::is_rvalue_reference_v<First_Arg_T> &&
@@ -38,25 +38,25 @@ namespace Rice
       }
     }
 
-    static void initialize(VALUE self, Arg_Ts...args)
+    static void initialize(VALUE self, Parameter_Ts...args)
     {
       // Call C++ constructor
       T* data = new T(args...);
-      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
     }
 
     static void initialize_copy(VALUE self, const T& other)
     {
       // Call C++ copy constructor
       T* data = new T(other);
-      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
     }
 
   };
 
   //! Special-case Constructor used when defining Directors.
-  template<typename T, typename...Arg_Ts>
-  class Constructor<T, Object, Arg_Ts...>
+  template<typename T, typename...Parameter_Ts>
+  class Constructor<T, Object, Parameter_Ts...>
   {
     public:
       static constexpr bool isCopyConstructor()
@@ -69,11 +69,11 @@ namespace Rice
         return false;
       }
 
-      static void initialize(Object self, Arg_Ts...args)
+      static void initialize(Object self, Parameter_Ts...args)
       {
         // Call C++ constructor
         T* data = new T(self, args...);
-        detail::wrapConstructed<T>(self.value(), Data_Type<T>::ruby_data_type(), data, true);
+        detail::wrapConstructed<T>(self.value(), Data_Type<T>::ruby_data_type(), data);
       }
   };
 }

data/rice/Data_Object.ipp

@@ -6,16 +6,17 @@ namespace Rice
   template <typename T>
   Exception create_type_exception(VALUE value)
   {
-    if constexpr (std::is_pointer_v<T>)
+    if (Data_Type<T>::is_bound())
     {
-      return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
-        detail::protect(rb_class2name, Data_Type<Pointer<std::remove_cv_t<std::remove_pointer_t<T>>>>::klass().value()),
+      return Exception(rb_eTypeError, "Wrong argument type. Expected %s. Received %s.",
+        detail::protect(rb_class2name, Data_Type<T>::klass().value()),
         detail::protect(rb_obj_classname, value));
     }
     else
     {
-      return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
-        detail::protect(rb_class2name, Data_Type<detail::intrinsic_type<T>>::klass().value()),
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+      return Exception(rb_eTypeError, "Wrong argument type. Expected %s. Received %s.",
+        typeIndexParser.simplifiedName().c_str(),
         detail::protect(rb_obj_classname, value));
     }
   }
@@ -227,7 +228,7 @@ namespace Rice::detail
     VALUE convert(U* data)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
-      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ReturnBuffer*>(this->arg_) ? true : false;
 
       if (data == nullptr)
       {
@@ -272,7 +273,7 @@ namespace Rice::detail
     VALUE convert(U* data)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
-      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ReturnBuffer*>(this->arg_) ? true : false;
  
       if (data == nullptr)
       {
@@ -360,7 +361,7 @@ namespace Rice::detail
     {
     }
     
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -411,7 +412,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -454,7 +455,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -491,6 +492,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
     using Intrinsic_T = intrinsic_type<T>;
+    using Pointer_T = Pointer<remove_cv_recursive_t<T>>;
 
   public:
     From_Ruby() = default;
@@ -499,19 +501,21 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
+
       switch (rb_type(value))
       {
         case RUBY_T_NIL:
           return Convertible::Exact;
           break;
         case RUBY_T_DATA:
-          if (Data_Type<T>::is_descendant(value))
+          if (Data_Type<T>::is_descendant(value) && !isBuffer)
           {
             return Convertible::Exact;
           }
-          else if (Data_Type<Pointer<T>>::is_descendant(value))
+          else if (Data_Type<Pointer_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -524,6 +528,7 @@ namespace Rice::detail
     T* convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
 
       switch (rb_type(value))
       {
@@ -534,19 +539,26 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          if (Data_Type<T>::is_descendant(value))
+          if (Data_Type<T>::is_descendant(value) && !isBuffer)
           {
             return detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), isOwner);
           }
-          else if (Data_Type<Pointer<T>>::is_descendant(value))
+          else if (Data_Type<Pointer_T>::is_descendant(value))
           {
-            return detail::unwrap<T>(value, Data_Type<Pointer<T>>::ruby_data_type(), isOwner);
+            return detail::unwrap<T>(value, Data_Type<Pointer_T>::ruby_data_type(), isOwner);
           }
           [[fallthrough]];
         }
         default:
         {
-          throw create_type_exception<T*>(value);
+          if (isBuffer || std::is_fundamental_v<T>)
+          {
+            throw create_type_exception<Pointer_T>(value);
+          }
+          else
+          {
+            throw create_type_exception<T>(value);
+          }
         }
       }
     }
@@ -572,7 +584,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -613,6 +625,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
     using Intrinsic_T = intrinsic_type<T>;
+    using Pointer_T = Pointer<remove_cv_recursive_t<T>*>;
   public:
     From_Ruby() = default;
 
@@ -620,16 +633,21 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
+
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
-          return Data_Type<Pointer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
-          break;
         case RUBY_T_NIL:
           return Convertible::Exact;
           break;
+        case RUBY_T_DATA:
+          if (Data_Type<Pointer_T>::is_descendant(value) && isBuffer)
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
         default:
           return Convertible::None;
       }
@@ -638,23 +656,34 @@ namespace Rice::detail
     T** convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
 
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
-        {
-          T** result = detail::unwrap<Intrinsic_T*>(value, Data_Type<Pointer<T*>>::ruby_data_type(), isOwner);
-          return result;
-          break;
-        }
         case RUBY_T_NIL:
         {
           return nullptr;
           break;
         }
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value) && isBuffer)
+          {
+            T** result = detail::unwrap<Intrinsic_T*>(value, Data_Type<Pointer_T>::ruby_data_type(), isOwner);
+            return result;
+          }
+          [[fallthrough]];
+        }
         default:
         {
-          throw create_type_exception<T**>(value);
+          if (isBuffer)
+          {
+            throw create_type_exception<Pointer_T>(value);
+          }
+          else
+          {
+            throw create_type_exception<T**>(value);
+          }
         }
       }
     }
@@ -678,7 +707,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
   public:
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {

data/rice/Data_Type.hpp

@@ -90,8 +90,7 @@ namespace Rice
      *  library to die at run time when it tries to convert the base
      *  type into the Director proxy type.
      *
-     *  This method takes no methodInfo, just needs the type of the
-     *  Director proxy class.
+     *  This method needs the type of the Director proxy class.
      *
      *  For example:
      *  \code
@@ -134,11 +133,11 @@ namespace Rice
     template<typename Iterator_Func_T>
     Data_Type<T>& define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name = "each");
 
-    template <typename Attribute_T>
-    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, Return returnInfo = Return());
+    template <typename Attribute_T, typename...Arg_Ts>
+    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, const Arg_Ts&...args);
   
-    template <typename Attribute_T>
-    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, Return returnInfo = Return());
+    template <typename Attribute_T, typename...Arg_Ts>
+    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, const Arg_Ts&...args);
 
     #include "cpp_api/shared_methods.hpp"
   protected:
@@ -161,11 +160,11 @@ namespace Rice
     template<typename T_, typename Base_T>
     friend Rice::Data_Type<T_> define_class(char const * name);
 
-    template<typename Method_T>
-    void wrap_native_method(VALUE klass, std::string name, Method_T&& function, MethodInfo* methodInfo);
+    template<typename Method_T, typename...Arg_Ts>
+    void wrap_native_method(VALUE klass, std::string name, Method_T&& function, const Arg_Ts&...args);
 
-    template <typename Attribute_T>
-    Data_Type<T>& define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo);
+    template <typename Attribute_T, typename...Arg_Ts>
+    Data_Type<T>& define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args);
 
   private:
     template<typename T_>