rice 4.6.1 → 4.7.0

data/rice/Data_Object.ipp

@@ -6,9 +6,18 @@ namespace Rice
   template <typename T>
   Exception create_type_exception(VALUE 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));
+    if constexpr (std::is_pointer_v<T>)
+    {
+      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()),
+        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::protect(rb_obj_classname, value));
+    }
   }
 
   template<typename T>
@@ -102,6 +111,12 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     template<typename U>
     VALUE convert(U& data)
     {
@@ -123,6 +138,9 @@ namespace Rice::detail
       // 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);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template <typename T>
@@ -141,7 +159,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return * returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -152,19 +170,45 @@ namespace Rice::detail
       // 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());
+      bool isOwner = (this->arg_ && this->arg_->isOwner());
       return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
     }
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
+  };
+
+  template <typename T, int N>
+  class To_Ruby<T[N]>
+  {
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+      !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+      !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+      !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+      !std::is_same_v<T, std::vector<T>>,
+      "Please include rice/stl.hpp header for STL support");
+
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    template<typename U>
+    VALUE convert(U data[N])
+    {
+      Buffer<T> buffer(data, N);
+      Data_Object<Buffer<T>> dataObject(std::move(buffer));
+      return dataObject.value();
+    }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template <typename T>
   class To_Ruby<T*>
   {
-    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
-                  "Data_Object cannot be used with fundamental types");
-
     static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
                   !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
                   !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
@@ -175,25 +219,24 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
     template<typename U>
     VALUE convert(U* data)
     {
-      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+      bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
 
       if (data == nullptr)
       {
         return Qnil;
       }
-      else if (this->returnInfo_ && this->returnInfo_->isArray())
+      else if (std::is_fundamental_v<std::remove_pointer_t<T>> || isBuffer)
       {
-        using Buffer_T = Buffer<T>;
-        Buffer_T buffer((T*)data);
-        buffer.setOwner(isOwner);
-        return detail::wrap(Data_Type<Buffer_T>::klass(), Data_Type<Buffer_T>::ruby_data_type(), buffer, true);
+        using Pointer_T = Pointer<remove_cv_recursive_t<U>>;
+        return detail::wrap(Data_Type<Pointer_T>::klass(), Data_Type<Pointer_T>::ruby_data_type(), data, isOwner);
       }
       else
       {
@@ -205,15 +248,12 @@ namespace Rice::detail
     }
     
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template <typename T>
-  class To_Ruby<T*&>
+    class To_Ruby<T*&>
   {
-    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
-                  "Data_Object cannot be used with fundamental types");
-
     static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
                   !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
                   !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
@@ -224,25 +264,29 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
     template<typename U>
     VALUE convert(U* data)
     {
-      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-
+      bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+ 
       if (data == nullptr)
       {
         return Qnil;
       }
-      else if (this->returnInfo_ && this->returnInfo_->isArray())
+      else if constexpr (std::is_const_v<U>)
       {
-        using Buffer_T = Buffer<intrinsic_type<T>>;
-        Buffer_T buffer((T*)data);
-        buffer.setOwner(isOwner);
-        return detail::wrap(Data_Type<Buffer_T>::klass(), Data_Type<Buffer_T>::ruby_data_type(), buffer, true);
+        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
+        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+      }
+      else if (std::is_fundamental_v<T> || isBuffer)
+      {
+        using Pointer_T = Pointer<remove_cv_recursive_t<U>>;
+        return detail::wrap(Data_Type<Pointer_T>::klass(), Data_Type<Pointer_T>::ruby_data_type(), data, isOwner);
       }
       else
       {
@@ -254,26 +298,16 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template <typename T>
   class To_Ruby<T**>
   {
-    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
-                  "Data_Object cannot be used with fundamental types");
-
-    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
-                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
-                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
-                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
-                  !std::is_same_v<T, std::vector<T>>,
-                  "Please include rice/stl.hpp header for STL support");
-
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -282,11 +316,9 @@ namespace Rice::detail
     {
       if (data)
       {
-        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-        Buffer<T*> buffer((T**)data);
-        buffer.setOwner(isOwner);
-        using Buffer_T = Buffer<intrinsic_type<T>*>;
-        return detail::wrap(Data_Type<Buffer_T>::klass(), Data_Type<Buffer_T>::ruby_data_type(), buffer, true);
+        bool isOwner = this->arg_ && this->arg_->isOwner();
+        using Pointer_T = Pointer<remove_cv_recursive_t<U>*>;
+        return detail::wrap(Data_Type<Pointer_T>::klass(), Data_Type<Pointer_T>::ruby_data_type(), data, isOwner);
       }
       else
       {
@@ -295,7 +327,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -448,13 +480,9 @@ namespace Rice::detail
 
   // 99% of the time a T* represents a wrapped C++ object that we want to call methods on. However, T* 
   // could also be a pointer to an array of T objects, so T[]. OpenCV for example has API calls like this.
-  // In that case, the Ruby VALUE will be a Buffer<T> instance
   template<typename T>
   class From_Ruby<T*>
   {
-    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
-                  "Data_Object cannot be used with fundamental types");
-
     static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
                   !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
                   !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
@@ -475,22 +503,19 @@ namespace Rice::detail
     {
       switch (rb_type(value))
       {
+        case RUBY_T_NIL:
+          return Convertible::Exact;
+          break;
         case RUBY_T_DATA:
-          if (this->arg_ && this->arg_->isArray())
+          if (Data_Type<T>::is_descendant(value))
           {
-            return Data_Type<Buffer<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            return Convertible::Exact;
           }
-          else
+          else if (Data_Type<Pointer<T>>::is_descendant(value))
           {
-            return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            return Convertible::Exact;
           }
-          break;
-        case RUBY_T_NIL:
-          return Convertible::Exact;
-          break;
-        case RUBY_T_ARRAY:
-          return Convertible::Exact;
-          break;
+          [[fallthrough]];
         default:
           return Convertible::None;
       }
@@ -498,6 +523,8 @@ namespace Rice::detail
 
     T* convert(VALUE value)
     {
+      bool isOwner = this->arg_ && this->arg_->isOwner();
+
       switch (rb_type(value))
       {
         case RUBY_T_NIL:
@@ -507,20 +534,19 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          if (this->arg_ && this->arg_->isArray())
+          if (Data_Type<T>::is_descendant(value))
           {
-            using Buffer_T = Buffer<Intrinsic_T>;
-            Buffer_T* buffer = detail::unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
-            return buffer->ptr();
+            return detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), isOwner);
           }
-          else
+          else if (Data_Type<Pointer<T>>::is_descendant(value))
           {
-            return detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
+            return detail::unwrap<T>(value, Data_Type<Pointer<T>>::ruby_data_type(), isOwner);
           }
+          [[fallthrough]];
         }
         default:
         {
-          throw create_type_exception<Intrinsic_T>(value);
+          throw create_type_exception<T*>(value);
         }
       }
     }
@@ -532,9 +558,6 @@ 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");
-
     static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
                   !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
                   !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
@@ -582,9 +605,6 @@ 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");
-
     static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
                   !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
                   !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
@@ -605,14 +625,11 @@ namespace Rice::detail
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
-          return Data_Type<Buffer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          return Data_Type<Pointer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
           break;
         case RUBY_T_NIL:
           return Convertible::Exact;
           break;
-        case RUBY_T_ARRAY:
-          return Convertible::Exact;
-          break;
         default:
           return Convertible::None;
       }
@@ -620,12 +637,14 @@ namespace Rice::detail
 
     T** convert(VALUE value)
     {
+      bool isOwner = this->arg_ && this->arg_->isOwner();
+
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
         {
-          Buffer<Intrinsic_T*>* buffer = detail::unwrap<Buffer<Intrinsic_T*>>(value, Data_Type<Buffer<Intrinsic_T*>>::ruby_data_type(), false);
-          return buffer->ptr();
+          T** result = detail::unwrap<Intrinsic_T*>(value, Data_Type<Pointer<T*>>::ruby_data_type(), isOwner);
+          return result;
           break;
         }
         case RUBY_T_NIL:
@@ -635,7 +654,7 @@ namespace Rice::detail
         }
         default:
         {
-          throw create_type_exception<Intrinsic_T>(value);
+          throw create_type_exception<T**>(value);
         }
       }
     }

data/rice/Data_Type.hpp

@@ -12,8 +12,6 @@ namespace Rice
   template<typename T>
   class Data_Type : public Class
   {
-    static_assert(std::is_same_v<detail::intrinsic_type<T>, T>);
-
   public:
     using type = T;
 
@@ -137,10 +135,10 @@ namespace Rice
     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);
+    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, Return returnInfo = Return());
   
     template <typename Attribute_T>
-    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
+    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, Return returnInfo = Return());
 
     #include "cpp_api/shared_methods.hpp"
   protected:
@@ -163,11 +161,11 @@ 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);
+    template<typename Method_T>
+    void wrap_native_method(VALUE klass, std::string name, Method_T&& function, MethodInfo* methodInfo);
 
     template <typename Attribute_T>
-    Data_Type<T>& define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access);
+    Data_Type<T>& define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo);
 
   private:
     template<typename T_>

data/rice/Data_Type.ipp

@@ -37,7 +37,8 @@ namespace Rice
   {
     if (is_bound())
     {
-      std::string message = "Type " + detail::typeName(typeid(T)) + " is already bound to a different type";
+      detail::TypeMapper<T> typeMapper;
+      std::string message = "Type " + typeMapper.name() + " is already bound to a different type";
       throw std::runtime_error(message.c_str());
     }
 
@@ -56,9 +57,6 @@ namespace Rice
       rb_data_type_->parent = Data_Type<Base_T>::ruby_data_type();
     }
 
-    // Now register with the type registry
-    detail::Registries::instance.types.add<T>(klass_, rb_data_type_);
-
     auto instances = unbound_instances();
     for (auto instance: instances)
     {
@@ -66,7 +64,21 @@ namespace Rice
     }
     instances.clear();
 
-    return Data_Type<T>();
+    // Register with the type registry
+    detail::Registries::instance.types.add<T>(klass_, rb_data_type_);
+
+    // Add a method to get the source C++ class name from Ruby
+    Data_Type<T> dataType;
+    dataType.define_singleton_method("cpp_class", [](VALUE klass) -> VALUE
+    {
+      detail::TypeMapper<T> typeMapper;
+      std::string cppClassName = typeMapper.simplifiedName();
+      Return returnInfo;
+      returnInfo.takeOwnership();
+      return detail::To_Ruby<char*>(&returnInfo).convert(cppClassName.c_str());
+    }, Arg("klass").setValue(), Return().setValue());
+
+    return dataType;
   }
 
   template<typename T>
@@ -206,8 +218,14 @@ namespace Rice
   template<typename T>
   inline bool Data_Type<T>::is_descendant(VALUE value)
   {
-    check_is_bound();
-    return detail::protect(rb_obj_is_kind_of, value, klass_) == Qtrue;
+    if (is_bound())
+    {
+      return detail::protect(rb_obj_is_kind_of, value, klass_) == Qtrue;
+    }
+    else
+    {
+      return false;
+    }
   }
 
   template<typename T>
@@ -215,7 +233,8 @@ namespace Rice
   {
     if (!is_bound())
     {
-      std::string message = "Type is not defined with Rice: " + detail::typeName(typeid(T));
+      detail::TypeMapper<T> typeMapper;
+      std::string message = "Type is not defined with Rice: " + typeMapper.name();
       throw std::invalid_argument(message.c_str());
     }
   }
@@ -312,52 +331,58 @@ namespace Rice
 
   template <typename T>
   template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access)
+  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
   {
-    return this->define_attr_internal<Attribute_T>(this->klass_, name, std::forward<Attribute_T>(attribute), access);
+    return this->define_attr_internal<Attribute_T>(this->klass_, name, std::forward<Attribute_T>(attribute), access, returnInfo);
   }
 
   template <typename T>
   template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access)
+  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
   {
     VALUE singleton = detail::protect(rb_singleton_class, this->value());
-    return this->define_attr_internal<Attribute_T>(singleton, name, std::forward<Attribute_T>(attribute), access);
+    return this->define_attr_internal<Attribute_T>(singleton, name, std::forward<Attribute_T>(attribute), access, returnInfo);
   }
 
   template <typename T>
   template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access)
+  inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
   {
     using Attr_T = typename detail::attribute_traits<Attribute_T>::attr_type;
 
-    // Make sure the Attribute type has been previously seen by Rice
-    detail::verifyType<Attr_T>();
-
     // Define attribute getter
     if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
     {
-      detail::NativeAttributeGet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute));
+      detail::NativeAttributeGet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute), returnInfo);
     }
 
+    // Define attribute setter
     // Define attribute setter
     if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
     {
+      // This seems super hacky - must be a better way?
+      constexpr bool checkWriteAccess = !std::is_reference_v<Attr_T> && 
+                                        !std::is_pointer_v<Attr_T> &&
+                                        !std::is_fundamental_v<Attr_T> &&
+                                        !std::is_enum_v<Attr_T>;
+      
       if constexpr (std::is_const_v<Attr_T>)
       {
         throw std::runtime_error("Cannot define attribute writer for a const attribute: " + name);
       }
-      else if constexpr (!std::is_fundamental_v<Attr_T> && !std::is_assignable_v<Attr_T, Attr_T>)
+      // Attributes are set using assignment operator like this:
+      //   myInstance.attribute = newvalue
+      else if constexpr (checkWriteAccess && !std::is_assignable_v<Attr_T, Attr_T>)
       {
         throw std::runtime_error("Cannot define attribute writer for a non assignable attribute: " + name);
       }
-      else if constexpr (!std::is_fundamental_v<Attr_T> && !std::is_copy_constructible_v<Attr_T>)
+      // From_Ruby returns a copy of the value for non-reference and non-pointers, thus needs to be copy constructable
+      else if constexpr (checkWriteAccess && !std::is_copy_constructible_v<Attr_T>)
       {
         throw std::runtime_error("Cannot define attribute writer for a non copy constructible attribute: " + name);
       }
       else
       {
-        // Define native attribute setter
         detail::NativeAttributeSet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute));
       }
     }
@@ -366,15 +391,9 @@ namespace Rice
   }
 
   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)
+  template<typename Method_T>
+  inline void Data_Type<T>::wrap_native_method(VALUE klass, std::string name, Method_T&& method, 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>();
-
-    // Define a NativeFunction to bridge Ruby to C++
-    detail::NativeFunction<T, Function_T, IsMethod>::define(klass, name, std::forward<Function_T>(function), methodInfo);
+    Module::wrap_native_method<T, Method_T>(klass, name, std::forward<Method_T>(method), methodInfo);
   }
 }

data/rice/Enum.ipp

@@ -49,8 +49,8 @@ namespace Rice
         Enum_T otherEnum = (Enum_T)other;
 
         Array result;
-        result.push(self);
-        result.push(otherEnum);
+        result.push(self, false);
+        result.push(otherEnum, true);
         return result;
       })
       .define_method("inspect", [](Enum_T& self)
@@ -95,25 +95,19 @@ namespace Rice
         }
       });
 
-    // Add enumerable support
-    klass.include_module(rb_mEnumerable)
-      .define_singleton_method("each", [](VALUE ruby_klass) -> VALUE
-        {
-          if (!rb_block_given_p())
-          {
-            return rb_enumeratorize_with_size(ruby_klass, Identifier("each").to_sym(),
-              0, nullptr, 0);
-          }
-
-          for (auto& pair : valuesToNames_)
-          {
-            Enum_T enumValue = pair.first;
-            VALUE value = detail::To_Ruby<Enum_T>().convert(enumValue);
-            detail::protect(rb_yield, value);
-          }
-
-          return ruby_klass;
-        }, Return().setValue());
+    // Add ability to get enum values
+    klass.define_singleton_method("values", [](VALUE ruby_klass) -> VALUE
+    {
+      Array result;
+
+      for (auto& pair : valuesToNames_)
+      {
+        Object enumValue = Class(ruby_klass).const_get(pair.second);
+        result.push(enumValue, false);
+      }
+
+      return result;
+    }, Return().setValue());
 
     // Add bitwise operators
     klass.define_method("&", [](Enum_T& self, Enum_T& other) -> Underlying_T

data/rice/Function.hpp

@@ -0,0 +1,17 @@
+#ifndef Rice__Function__hpp_
+#define Rice__Function__hpp_
+
+namespace Rice
+{
+  class Function
+  {
+  public:
+    Function& setNoGvl();
+    bool isNoGvl() const;
+
+  private:
+    bool isNoGvl_ = false;
+  };
+} // Rice
+
+#endif // Rice__Function__hpp_

data/rice/Function.ipp

@@ -0,0 +1,13 @@
+namespace Rice
+{
+  inline Function& Function::setNoGvl()
+  {
+    this->isNoGvl_ = true;
+    return *this;
+  }
+
+  inline bool Function::isNoGvl() const
+  {
+    return this->isNoGvl_;
+  }
+}  // Rice

data/rice/Pointer.hpp

@@ -0,0 +1,15 @@
+#ifndef Rice__Pointer__hpp_
+#define Rice__Pointer__hpp_
+
+namespace Rice
+{
+  template<typename T>
+  class Pointer
+  {
+  };
+
+  template<typename T>
+  Data_Type<Pointer<T>> define_pointer(std::string klassName = "");
+}
+
+#endif // Rice__Pointer__hpp_