rice 4.0.4 → 4.2.0

data/lib/mkmf-rice.rb

@@ -1,6 +1,7 @@
 require 'mkmf'
 
 IS_MSWIN = !RbConfig::CONFIG['host_os'].match(/mswin/).nil?
+IS_MINGW = !RbConfig::CONFIG['host_os'].match(/mingw/).nil?
 IS_DARWIN = !RbConfig::CONFIG['host_os'].match(/darwin/).nil?
 
 # If we are on versions of Ruby before 2.7 then we need to copy in the experimental C++ support
@@ -106,8 +107,10 @@ include MakeMakefile['C++']
 
 # Rice needs c++17.
 if IS_MSWIN
-  $CXXFLAGS += " /std:c++17 /EHsc /permissive-"
-  $CPPFLAGS += " -D_ALLOW_KEYWORD_MACROS"
+  $CXXFLAGS += " /std:c++17 /EHsc /permissive- /bigobj"
+  $CPPFLAGS += " -D_ALLOW_KEYWORD_MACROS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE"
+elsif IS_MINGW
+  $CXXFLAGS += " -std=c++17 -Wa,-mbig-obj"
 else
   $CXXFLAGS += " -std=c++17"
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.0.4"
+  VERSION = "4.2.0"
 end

data/rice/Arg.hpp

@@ -57,18 +57,17 @@ namespace Rice
     //! Tell the receiving object to keep this argument alive
     //! until the receiving object is freed.
     Arg& keepAlive();
+    
+    //! Returns if the argument should be kept alive
+    bool isKeepAlive() const;
 
     //! Specifies if the argument should be treated as a value
-    Arg& isValue();
+    Arg& setValue();
 
     //! Returns if the argument should be treated as a value
-    bool getIsValue();
-
-    // No longer supported - implemented to raise error
-    Arg operator,(const Arg& other);
+    bool isValue() const;
 
   public:
-    bool isKeepAlive = false;
     const std::string name;
     int32_t position = -1;
 
@@ -76,6 +75,7 @@ namespace Rice
     //! Our saved default value
     std::any defaultValue_;
     bool isValue_ = false;
+    bool isKeepAlive_ = false;
   };
 } // Rice
 

data/rice/Arg.ipp

@@ -28,24 +28,23 @@ namespace Rice
 
   inline Arg& Arg::keepAlive()
   {
-    this->isKeepAlive = true;
+    this->isKeepAlive_ = true;
     return *this;
   }
 
-  inline Arg& Arg::isValue()
+  inline bool Arg::isKeepAlive() const
   {
-    isValue_ = true;
-    return *this;
+    return this->isKeepAlive_;
   }
 
-  inline bool Arg::getIsValue()
+  inline Arg& Arg::setValue()
   {
-    return isValue_;
+    isValue_ = true;
+    return *this;
   }
 
-  // Function to overload the, operator
-  inline Arg Arg::operator,(const Arg& other)
+  inline bool Arg::isValue() const
   {
-    throw std::runtime_error("The Arg class no longer supports the comma operator, please remove the surounding parentheses");
+    return isValue_;
   }
 } // Rice

data/rice/Constructor.hpp

@@ -26,7 +26,7 @@ namespace Rice
     static void construct(VALUE self, Arg_Ts...args)
     {
       T* data = new T(args...);
-      detail::replace<T>(self, Data_Type<T>::rb_type(), data, true);
+      detail::replace<T>(self, Data_Type<T>::ruby_data_type(), data, true);
     }
   };
 
@@ -38,7 +38,7 @@ namespace Rice
       static void construct(Object self, Arg_Ts...args)
       {
         T* data = new T(self, args...);
-        detail::replace<T>(self.value(), Data_Type<T>::rb_type(), data, true);
+        detail::replace<T>(self.value(), Data_Type<T>::ruby_data_type(), data, true);
       }
   };
 }

data/rice/Data_Object.ipp

@@ -18,27 +18,19 @@ namespace Rice
   template<typename T>
   inline Data_Object<T>::Data_Object(T& data, bool isOwner, Class klass)
   {
-    VALUE value = detail::wrap(klass, Data_Type<T>::rb_type(), data, isOwner);
+    VALUE value = detail::wrap(klass, Data_Type<T>::ruby_data_type(), data, isOwner);
     this->set_value(value);
   }
 
   template<typename T>
   inline Data_Object<T>::Data_Object(T* data, bool isOwner, Class klass)
   {
-    VALUE value = detail::wrap(klass, Data_Type<T>::rb_type(), data, isOwner);
+    VALUE value = detail::wrap(klass, Data_Type<T>::ruby_data_type(), data, isOwner);
     this->set_value(value);
   }
 
   template<typename T>
   inline Data_Object<T>::Data_Object(Object value) : Object(value)
-  {
-    Data_Type<T> klass;
-    check_ruby_type(value);
-  }
-
-  template<typename T>
-  template<typename U>
-  inline Data_Object<T>::Data_Object(Object value) : Object(value)
   {
     check_ruby_type(value);
   }
@@ -73,7 +65,7 @@ namespace Rice
     }
     else
     {
-      return detail::unwrap<T>(this->value(), Data_Type<T>::rb_type());
+      return detail::unwrap<T>(this->value(), Data_Type<T>::ruby_data_type());
     }
   }
 
@@ -82,7 +74,7 @@ namespace Rice
   {
     if (Data_Type<T>::is_descendant(value))
     {
-      return detail::unwrap<T>(value, Data_Type<T>::rb_type());
+      return detail::unwrap<T>(value, Data_Type<T>::ruby_data_type());
     }
     else
     {
@@ -100,7 +92,17 @@ namespace Rice::detail
     VALUE convert(T& data)
     {
       // Get the ruby typeinfo
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::TypeRegistry::figureType<T>(data);
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
+
+      // We always take ownership of data passed by value (yes the parameter is T& but the template
+      // matched <typename T> thus we have to tell wrap to copy the reference we are sending to it
+      return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+    }
+
+    VALUE convert(const T& data)
+    {
+      // Get the ruby typeinfo
+        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
 
       // We always take ownership of data passed by value (yes the parameter is T& but the template
       // matched <typename T> thus we have to tell wrap to copy the reference we are sending to it
@@ -122,7 +124,17 @@ namespace Rice::detail
     {
       // 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::TypeRegistry::figureType<T>(data);
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
+
+      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+      return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+    }
+
+    VALUE convert(const T& 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<T>(data);
 
       bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
       return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
@@ -142,13 +154,29 @@ namespace Rice::detail
     {
     }
 
+    VALUE convert(T* data)
+    {
+      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->returnInfo_ && this->returnInfo_->isOwner();
+        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+      }
+      else
+      {
+        return Qnil;
+      }
+    }
+
     VALUE convert(const T* data)
     {
       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::TypeRegistry::figureType(*data);
+        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
         bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
         return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
       }
@@ -175,6 +203,8 @@ namespace Rice::detail
   template <typename T>
   class From_Ruby
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
   public:
     From_Ruby() = default;
 
@@ -182,6 +212,12 @@ namespace Rice::detail
     {
     }
     
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_DATA &&
+        Data_Type<T>::is_descendant(value);
+    }
+
     T convert(VALUE value)
     {
       using Intrinsic_T = intrinsic_type<T>;
@@ -203,6 +239,8 @@ namespace Rice::detail
   template<typename T>
   class From_Ruby<T&>
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
   public:
     From_Ruby() = default;
 
@@ -210,6 +248,12 @@ namespace Rice::detail
     {
     }
 
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_DATA &&
+        Data_Type<T>::is_descendant(value);
+    }
+
     T& convert(VALUE value)
     {
       using Intrinsic_T = intrinsic_type<T>;
@@ -231,7 +275,15 @@ namespace Rice::detail
   template<typename T>
   class From_Ruby<T*>
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
   public:
+    bool is_convertible(VALUE value)
+    {
+      return rb_type(value) == RUBY_T_DATA &&
+        Data_Type<T>::is_descendant(value);
+    }
+
     T* convert(VALUE value)
     {
       using Intrinsic_T = intrinsic_type<T>;
@@ -250,6 +302,8 @@ namespace Rice::detail
   template<typename T>
   class From_Ruby<Data_Object<T>>
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
   public:
     static Data_Object<T> convert(VALUE value)
     {

data/rice/Data_Object_defn.hpp

@@ -48,7 +48,6 @@ namespace Rice
 
   public:
     static T* from_ruby(VALUE value);
-    static std::optional<T> implicit_from_ruby(VALUE value);
 
   public:
     //! Wrap a C++ object.
@@ -58,12 +57,9 @@ namespace Rice
      *  constructed objects that need to be managed by Ruby's garbage
      *  collector).
      *  \param obj the object to wrap.
+     *  \param isOwner Should the Data_Object take ownership of the object?
      *  \param klass the Ruby class to use for the newly created Ruby
      *  object.
-     *  \param mark_func a function that gets called by the garbage
-     *  collector to mark the object's children.
-     *  \param free_func a function that gets called by the garbage
-     *  collector to free the object.
      */
     Data_Object(T* obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
     Data_Object(T& obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
@@ -75,16 +71,6 @@ namespace Rice
      */
     Data_Object(Object value);
 
-    //! Unwrap a Ruby object.
-    /*! This constructor is analogous to calling Data_Get_Struct.  Will
-     *  throw an exception if the class of the object differs from the
-     *  specified class.
-     *  \param value the Ruby object to unwrap.
-     *  \param klass the expected class of the object.
-     */
-    template<typename U>
-    Data_Object(Object value);
-
     T& operator*() const; //!< Return a reference to obj_
     T* operator->() const; //!< Return a pointer to obj_
     T* get() const;        //!< Return a pointer to obj_

data/rice/Data_Type.ipp

@@ -1,14 +1,16 @@
 #ifndef Rice__Data_Type__ipp_
 #define Rice__Data_Type__ipp_
 
-#include "detail/method_data.hpp"
+#include "traits/attribute_traits.hpp"
+#include "traits/method_traits.hpp"
+#include "detail/NativeRegistry.hpp"
 #include "detail/NativeAttribute.hpp"
 #include "detail/default_allocation_func.hpp"
 #include "detail/TypeRegistry.hpp"
 #include "detail/Wrapper.hpp"
-#include "detail/Iterator.hpp"
-#include "Class.hpp"
-#include "String.hpp"
+#include "detail/NativeIterator.hpp"
+#include "cpp_api/Class.hpp"
+#include "cpp_api/String.hpp"
 
 #include <stdexcept>
 
@@ -39,7 +41,7 @@ namespace Rice
 
   template<typename T>
   template <typename Base_T>
-  inline Data_Type<T> Data_Type<T>::bind(Module const& klass)
+  inline Data_Type<T> Data_Type<T>::bind(const Module& klass)
   {
     if (is_bound())
     {
@@ -49,21 +51,21 @@ namespace Rice
 
     klass_ = klass;
 
-    rb_type_ = new rb_data_type_t();
-    rb_type_->wrap_struct_name = strdup(Rice::detail::protect(rb_class2name, klass_));
-    rb_type_->function.dmark = reinterpret_cast<void(*)(void*)>(&Rice::ruby_mark_internal<T>);
-    rb_type_->function.dfree = reinterpret_cast<void(*)(void*)>(&Rice::ruby_free_internal<T>);
-    rb_type_->function.dsize = reinterpret_cast<size_t(*)(const void*)>(&Rice::ruby_size_internal<T>);
-    rb_type_->data = nullptr;
-    rb_type_->flags = RUBY_TYPED_FREE_IMMEDIATELY;
+    rb_data_type_ = new rb_data_type_t();
+    rb_data_type_->wrap_struct_name = strdup(Rice::detail::protect(rb_class2name, klass_));
+    rb_data_type_->function.dmark = reinterpret_cast<void(*)(void*)>(&Rice::ruby_mark_internal<T>);
+    rb_data_type_->function.dfree = reinterpret_cast<void(*)(void*)>(&Rice::ruby_free_internal<T>);
+    rb_data_type_->function.dsize = reinterpret_cast<size_t(*)(const void*)>(&Rice::ruby_size_internal<T>);
+    rb_data_type_->data = nullptr;
+    rb_data_type_->flags = RUBY_TYPED_FREE_IMMEDIATELY;
 
     if constexpr (!std::is_void_v<Base_T>)
     {
-      rb_type_->parent = Data_Type<Base_T>::rb_type();
+      rb_data_type_->parent = Data_Type<Base_T>::ruby_data_type();
     }
 
     // Now register with the type registry
-    detail::TypeRegistry::add<T>(klass_, rb_type_);
+    detail::Registries::instance.types.add<T>(klass_, rb_data_type_);
 
     for (typename Instances::iterator it = unbound_instances().begin(),
       end = unbound_instances().end();
@@ -79,7 +81,7 @@ namespace Rice
   template<typename T>
   inline void Data_Type<T>::unbind()
   {
-    detail::TypeRegistry::remove<T>();
+    detail::Registries::instance.types.remove<T>();
 
     if (klass_ != Qnil)
     {
@@ -88,7 +90,7 @@ namespace Rice
 
     // There could be objects floating around using the existing rb_type so 
     // do not delete it. This is of course a memory leak.
-    rb_type_ = nullptr;
+    rb_data_type_ = nullptr;
   }
 
   template<typename T>
@@ -113,10 +115,10 @@ namespace Rice
   }
 
   template<typename T>
-  inline rb_data_type_t* Data_Type<T>::rb_type()
+  inline rb_data_type_t* Data_Type<T>::ruby_data_type()
   {
     check_is_bound();
-    return rb_type_;
+    return rb_data_type_;
   }
 
   template<typename T>
@@ -133,19 +135,6 @@ namespace Rice
     return *this;
   }
 
-  template<typename T>
-  template<typename Constructor_T>
-  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T, MethodInfo* methodInfo)
-  {
-    check_is_bound();
-
-    // Normal constructor pattern with new/initialize
-    detail::protect(rb_define_alloc_func, static_cast<VALUE>(*this), detail::default_allocation_func<T>);
-    this->define_method("initialize", &Constructor_T::construct, methodInfo);
-
-    return *this;
-  }
-
   template<typename T>
   template<typename Constructor_T, typename...Arg_Ts>
   inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T constructor, Arg_Ts const& ...args)
@@ -165,14 +154,14 @@ namespace Rice
   template<typename Director_T>
   inline Data_Type<T>& Data_Type<T>::define_director()
   {
-    if (!detail::TypeRegistry::isDefined<Director_T>())
+    if (!detail::Registries::instance.types.isDefined<Director_T>())
     {
       Data_Type<Director_T>::bind(*this);
     }
 
     // TODO - hack to fake Ruby into thinking that a Director is
     // the same as the base data type
-    Data_Type<Director_T>::rb_type_ = Data_Type<T>::rb_type_;
+    Data_Type<Director_T>::rb_data_type_ = Data_Type<T>::rb_data_type_;
     return *this;
   }
 
@@ -202,7 +191,7 @@ namespace Rice
   template<typename T, typename Base_T>
   inline Data_Type<T> define_class_under(Object module, char const* name)
   {
-    if (detail::TypeRegistry::isDefined<T>())
+    if (detail::Registries::instance.types.isDefined<T>())
     {
       return Data_Type<T>();
     }
@@ -226,7 +215,7 @@ namespace Rice
   template<typename T, typename Base_T>
   inline Data_Type<T> define_class(char const* name)
   {
-    if (detail::TypeRegistry::isDefined<T>())
+    if (detail::Registries::instance.types.isDefined<T>())
     {
       return Data_Type<T>();
     }
@@ -247,75 +236,56 @@ namespace Rice
   }
 
   template<typename T>
-  template<typename U, typename Iterator_T>
-  inline Data_Type<T>& Data_Type<T>::define_iterator(Iterator_T(U::* begin)(), Iterator_T(U::* end)(), Identifier name)
+  template<typename Iterator_Func_T>
+  inline Data_Type<T>& Data_Type<T>::define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name)
   {
-    using Iter_T = detail::Iterator<U, Iterator_T>;
-    Iter_T* iterator = new Iter_T(begin, end);
-    detail::MethodData::define_method(Data_Type<T>::klass(), name,
-      (RUBY_METHOD_FUNC)iterator->call, 0, iterator);
+    // Define a NativeIterator to bridge Ruby to C++
+    detail::NativeIterator<T, Iterator_Func_T>::define(Data_Type<T>::klass(), name, begin, end);
+
+    // Include enumerable support
+    this->klass().include_module(rb_mEnumerable);
 
     return *this;
   }
 
   template <typename T>
-  template <typename Attr_T>
-  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attr_T attr, AttrAccess access)
+  template <typename Attribute_T>
+  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access)
   {
-    auto* native = detail::Make_Native_Attribute(attr, access);
-    using Native_T = typename std::remove_pointer_t<decltype(native)>;
-
-    detail::verifyType<typename Native_T::Native_Return_T>();
-
-    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
-    {
-      detail::MethodData::define_method( klass_, Identifier(name).id(),
-        RUBY_METHOD_FUNC(&Native_T::get), 0, native);
-    }
-
-    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
-    {
-      if (std::is_const_v<std::remove_pointer_t<Attr_T>>)
-      {
-        throw std::runtime_error(name + " is readonly");
-      }
+    // Make sure the Attribute type has been previously seen by Rice
+    detail::verifyType<typename detail::attribute_traits<Attribute_T>::attr_type>();
 
-      detail::MethodData::define_method( klass_, Identifier(name + "=").id(),
-        RUBY_METHOD_FUNC(&Native_T::set), 1, native);
-    }
+    // Define native attribute
+    detail::NativeAttribute<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute), access);
 
     return *this;
   }
 
   template <typename T>
-  template <typename Attr_T>
-  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attr_T attr, AttrAccess access)
+  template <typename Attribute_T>
+  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access)
   {
-    auto* native = detail::Make_Native_Attribute(attr, access);
-    using Native_T = typename std::remove_pointer_t<decltype(native)>;
+    // Make sure the Attribute type has been previously seen by Rice
+    detail::verifyType<typename detail::attribute_traits<Attribute_T>::attr_type>();
 
-    detail::verifyType<typename Native_T::Native_Return_T>();
+    // Define native attribute
+    VALUE singleton = detail::protect(rb_singleton_class, this->value());
+    detail::NativeAttribute<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute), access);
 
-    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
-    {
-      VALUE singleton = detail::protect(rb_singleton_class, this->value());
-      detail::MethodData::define_method(singleton, Identifier(name).id(),
-        RUBY_METHOD_FUNC(&Native_T::get), 0, native);
-    }
+    return *this;
+  }
 
-    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
-    {
-      if (std::is_const_v<std::remove_pointer_t<Attr_T>>)
-      {
-        throw std::runtime_error(name  + " is readonly");
-      }
-
-      VALUE singleton = detail::protect(rb_singleton_class, this->value());
-      detail::MethodData::define_method(singleton, Identifier(name + "=").id(),
-        RUBY_METHOD_FUNC(&Native_T::set), 1, native);
-    }
+  template <typename T>
+  template<bool IsMethod, typename Function_T>
+  inline void Data_Type<T>::wrap_native_call(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>();
 
-    return *this;
+    // Define a NativeFunction to bridge Ruby to C++
+    detail::NativeFunction<T, Function_T, IsMethod>::define(klass, name, std::forward<Function_T>(function), methodInfo);
   }
 }
 #endif

data/rice/Data_Type_defn.hpp

@@ -1,7 +1,7 @@
 #ifndef Rice__Data_Type_defn__hpp_
 #define Rice__Data_Type_defn__hpp_
 
-#include "Class_defn.hpp"
+#include "cpp_api/Class_defn.hpp"
 #include "detail/ruby.hpp"
 #include <set>
 
@@ -38,8 +38,8 @@ namespace Rice
      */
     static Class klass();
 
-    //! Return the Ruby type.
-    static rb_data_type_t* rb_type();
+    //! Return the Ruby data type.
+    static rb_data_type_t* ruby_data_type();
 
     //! Assignment operator which takes a Module
     /*! \param klass must be the class to which this data type is already
@@ -48,11 +48,6 @@ namespace Rice
      */
     virtual Data_Type & operator=(Module const & klass);
 
-    //! Define a constructor for the class.
-    template<typename Constructor_T>
-    [[deprecated("Please call define_constructor with Arg parameters")]]
-    Data_Type<T> & define_constructor(Constructor_T constructor, MethodInfo * methodInfo);
-
     /*! Creates a singleton method allocate and an instance method called
      *  initialize which together create a new instance of the class.  The
      *  allocate method allocates memory for the object reference and the
@@ -118,14 +113,14 @@ namespace Rice
      *  \return *this
      */
 
-    template<typename U = T, typename Iterator_Return_T>
-    Data_Type<T>& define_iterator(Iterator_Return_T(U::* begin)(), Iterator_Return_T(U::* end)(), Identifier name = "each");
+    template<typename Iterator_Func_T>
+    Data_Type<T>& define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name = "each");
 
-    template <typename Attr_T>
-    Data_Type<T>& define_attr(std::string name, Attr_T attr, AttrAccess access = AttrAccess::ReadWrite);
+    template <typename Attribute_T>
+    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
   
-    template <typename Attr_T>
-    Data_Type<T>& define_singleton_attr(std::string name, Attr_T attr, AttrAccess access = AttrAccess::ReadWrite);
+    template <typename Attribute_T>
+    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
 
   #include "cpp_api/shared_methods.hpp"
 
@@ -138,7 +133,7 @@ namespace Rice
      *  \return *this
      */
     template <typename Base_T = void>
-    static Data_Type bind(Module const & klass);
+    static Data_Type bind(const Module& klass);
 
     template<typename T_, typename Base_T_>
     friend Rice::Data_Type<T_> define_class_under(Object module, char const * name);
@@ -146,6 +141,9 @@ namespace Rice
     template<typename T_, typename Base_T_>
     friend Rice::Data_Type<T_> define_class(char const * name);
 
+    template<bool IsMethod, typename Function_T>
+    void wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+
   private:
     template<typename T_>
     friend class Data_Type;
@@ -153,7 +151,7 @@ namespace Rice
     static inline VALUE klass_ = Qnil;
 
     // Typed Data support
-    static inline rb_data_type_t* rb_type_ = nullptr;
+    static inline rb_data_type_t* rb_data_type_ = nullptr;
 
     typedef std::set<Data_Type<T> *> Instances;
 
@@ -185,7 +183,6 @@ namespace Rice
    */
   template<typename T, typename Base_T = void>
   Data_Type<T> define_class(char const* name);
-
 } // namespace Rice
 
 #include "Data_Type.ipp"