rice 4.8.0 → 4.9.0

data/include/rice/stl.hpp

@@ -2687,11 +2687,26 @@ namespace Rice
   Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName = "");
 }
 
+namespace Rice::detail
+{
+  template<typename T>
+  class Wrapper<std::shared_ptr<T>> : public WrapperBase
+  {
+  public:
+    Wrapper(rb_data_type_t* rb_data_type, const std::shared_ptr<T>& data);
+    ~Wrapper();
+    void* get(rb_data_type_t* requestedType) override;
+
+  private:
+    std::shared_ptr<T> data_;
+    rb_data_type_t* inner_rb_data_type_;
+  };
+}
+
 
 // ---------   shared_ptr.ipp   ---------
 #include <memory>
 
-// --------- Enable creation of std::shared_ptr from Ruby ---------
 namespace Rice
 {
   template<typename T>
@@ -2713,74 +2728,98 @@ namespace Rice
     }
 
     Identifier id(klassName);
-    Data_Type_T result = define_class_under<SharedPtr_T>(rb_mStd, id);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<SharedPtr_T>>(rb_mStd, id).
+      define_method("get", &SharedPtr_T::get).
+      define_method("swap", &SharedPtr_T::swap).
+      define_method("use_count", &SharedPtr_T::use_count).
+      define_method("empty?", [](SharedPtr_T& self)->bool
+      {
+        return !self;
+      });
 
-    // std::shared_ptr<void> cannot be constructed from void* because void is incomplete
-    // and the deleter cannot be determined. So skip the constructor for void.
-    // std::shared_ptr<T[]> (array types) also skip constructor - arrays need special handling.
-    if constexpr (!std::is_void_v<T> && !std::is_array_v<T>)
+    if constexpr (!std::is_void_v<T>)
     {
       result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
     }
 
-    result.
-      define_method("get", &SharedPtr_T::get).
-      define_method("use_count", &SharedPtr_T::use_count).
-      define_method("empty?", &SharedPtr_T::operator bool);
+    // Setup delegation to forward T's methods via get (only for non-fundamental, non-void types)
+    if constexpr (!std::is_void_v<T> && !std::is_fundamental_v<T>)
+    {
+      detail::define_forwarding(result.klass(), Data_Type<T>::klass());
+    }
 
     return result;
   }
 }
 
-// --------- Type/To_Ruby/From_Ruby ---------
+// --------- Wrapper ---------
 namespace Rice::detail
 {
   template<typename T>
-  struct Type<std::shared_ptr<T>>
+  Wrapper<std::shared_ptr<T>>::Wrapper(rb_data_type_t* rb_data_type, const std::shared_ptr<T>& data)
+    : WrapperBase(rb_data_type), data_(data)
   {
-    static bool verify()
+    using Intrinsic_T = intrinsic_type<T>;
+
+    if constexpr (std::is_fundamental_v<Intrinsic_T>)
     {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        Type<Pointer<T>>::verify();
-        Type<Buffer<T>>::verify();
-      }
-      else
-      {
-        if (!Type<intrinsic_type<T>>::verify())
-        {
-          return false;
-        }
-      }
+      inner_rb_data_type_ = Data_Type<Pointer<Intrinsic_T>>::ruby_data_type();
+    }
+    else
+    {
+      inner_rb_data_type_ = Data_Type<Intrinsic_T>::ruby_data_type();
+    }
+  }
 
-      define_shared_ptr<T>();
+  template<typename T>
+  Wrapper<std::shared_ptr<T>>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+  }
 
-      return true;
+  template<typename T>
+  void* Wrapper<std::shared_ptr<T>>::get(rb_data_type_t* requestedType)
+  {
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return &this->data_;
     }
-  };
+    else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
+    {
+      return this->data_.get();
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type (expected %s)",
+          requestedType->wrap_struct_name);
+    }
+  }
+}
 
-  // Specialization for array types std::shared_ptr<T[]>
+// --------- Type ---------
+namespace Rice::detail
+{
   template<typename T>
-  struct Type<std::shared_ptr<T[]>>
+  struct Type<std::shared_ptr<T>>
   {
     static bool verify()
     {
+      bool result = true;
       if constexpr (std::is_fundamental_v<T>)
       {
-        Type<Pointer<T>>::verify();
-        Type<Buffer<T>>::verify();
+        result = result && Type<Pointer<T>>::verify();
       }
       else
       {
-        if (!Type<intrinsic_type<T>>::verify())
-        {
-          return false;
-        }
+        result = result && Type<T>::verify();
       }
 
-      define_shared_ptr<T[]>();
+      if (result)
+      {
+        define_shared_ptr<T>();
+      }
 
-      return true;
+      return result;
     }
   };
 }
@@ -3301,19 +3340,25 @@ namespace Rice::detail
 
 // =========   unique_ptr.hpp   =========
 
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::unique_ptr<T>> define_unique_ptr(std::string klassName = "");
+}
+
 namespace Rice::detail
 {
   template<typename T>
   class Wrapper<std::unique_ptr<T>> : public WrapperBase
   {
   public:
-    Wrapper(std::unique_ptr<T>&& data);
+    Wrapper(rb_data_type_t* rb_data_type, std::unique_ptr<T>&& data);
     ~Wrapper();
-    void* get() override;
-    std::unique_ptr<T>& data();
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     std::unique_ptr<T> data_;
+    rb_data_type_t* inner_rb_data_type_;
   };
 }
 
@@ -3321,136 +3366,124 @@ namespace Rice::detail
 // ---------   unique_ptr.ipp   ---------
 #include <memory>
 
-namespace Rice::detail
+namespace Rice
 {
   template<typename T>
-  inline Wrapper<std::unique_ptr<T>>::Wrapper(std::unique_ptr<T>&& data)
-    : data_(std::move(data))
+  Data_Type<std::unique_ptr<T>> define_unique_ptr(std::string klassName)
   {
-  }
-
-  template<typename T>
-  inline Wrapper<std::unique_ptr<T>>::~Wrapper()
-  {
-    Registries::instance.instances.remove(this->get());
-  }
+    using UniquePtr_T = std::unique_ptr<T>;
+    using Data_Type_T = Data_Type<UniquePtr_T>;
 
-  template<typename T>
-  inline void* Wrapper<std::unique_ptr<T>>::get()
-  {
-    return (void*)this->data_.get();
-  }
-
-  template<typename T>
-  inline std::unique_ptr<T>& Wrapper<std::unique_ptr<T>>::data()
-  {
-    return data_;
-  }
-
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>>
-  {
-  public:
-    To_Ruby() = default;
-
-    explicit To_Ruby(Arg* arg) : arg_(arg)
+    if (klassName.empty())
     {
+      detail::TypeMapper<UniquePtr_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
-    VALUE convert(std::unique_ptr<T>& data)
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+      return Data_Type_T();
     }
 
-    VALUE convert(std::unique_ptr<T>&& data)
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<UniquePtr_T>>(rb_mStd, id).
+      define_method("get", &UniquePtr_T::get).
+      define_method("release", &UniquePtr_T::release).
+      define_method("reset", &UniquePtr_T::reset).
+      define_method("swap", &UniquePtr_T::swap).
+      define_method("empty?", [](UniquePtr_T& self)->bool
+      {
+        return !self;
+      });
+
+    // Setup delegation to forward T's methods via get (only for non-fundamental, non-void types)
+    if constexpr (!std::is_void_v<T> && !std::is_fundamental_v<T>)
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+      detail::define_forwarding(result.klass(), Data_Type<T>::klass());
     }
 
-  private:
-    Arg* arg_ = nullptr;
-  };
+    return result;
+  }
+}
 
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>&>
+// --------- Wrapper ---------
+namespace Rice::detail
+{
+  template<typename T>
+  Wrapper<std::unique_ptr<T>>::Wrapper(rb_data_type_t* rb_data_type, std::unique_ptr<T>&& data)
+    : WrapperBase(rb_data_type), data_(std::move(data))
   {
-  public:
-    To_Ruby() = default;
+    using Intrinsic_T = intrinsic_type<T>;
 
-    explicit To_Ruby(Arg* arg) : arg_(arg)
+    if constexpr (std::is_fundamental_v<Intrinsic_T>)
     {
+      inner_rb_data_type_ = Data_Type<Pointer<Intrinsic_T>>::ruby_data_type();
     }
-
-    VALUE convert(std::unique_ptr<T>& data)
+    else
     {
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+      inner_rb_data_type_ = Data_Type<Intrinsic_T>::ruby_data_type();
     }
+  }
 
-  private:
-    Arg* arg_ = nullptr;
-  };
+  template<typename T>
+  Wrapper<std::unique_ptr<T>>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+  }
 
-  template <typename T>
-  class From_Ruby<std::unique_ptr<T>>
+  template<typename T>
+  void* Wrapper<std::unique_ptr<T>>::get(rb_data_type_t* requestedType)
   {
-  public:
-    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
     {
-      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
-      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
+      return &this->data_;
     }
-
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
+    else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
+      return this->data_.get();
     }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type (expected %s)",
+          requestedType->wrap_struct_name);
+    }
+  }
 
-    double is_convertible(VALUE value)
+}
+
+// --------- Type ---------
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<std::unique_ptr<T>>
+  {
+    static bool verify()
     {
-      if (!is_same_smart_ptr(value))
+      bool result = true;
+      if constexpr (std::is_fundamental_v<T>)
       {
-        return Convertible::None;
+        result = result && Type<Pointer<T>>::verify();
       }
-
-      switch (rb_type(value))
+      else
       {
-        case RUBY_T_DATA:
-          return Convertible::Exact;
-          break;
-        default:
-          return Convertible::None;
+        result = result && Type<T>::verify();
       }
-    }
 
-    std::unique_ptr<T> convert(VALUE value)
-    {
-      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
-      if (!wrapper)
+      if (result)
       {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
+        define_unique_ptr<T>();
       }
-      return std::move(wrapper->data());
-    }
 
-  private:
-    Arg* arg_ = nullptr;
+      return result;
+    }
   };
 
+  // --------- From_Ruby ---------
   template <typename T>
-  class From_Ruby<std::unique_ptr<T>&>
+  class From_Ruby<std::unique_ptr<T>>
   {
   public:
-    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
-    {
-      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
-      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
-    }
-
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -3459,11 +3492,6 @@ namespace Rice::detail
 
     double is_convertible(VALUE value)
     {
-      if (!is_same_smart_ptr(value))
-      {
-        return Convertible::None;
-      }
-
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
@@ -3474,43 +3502,16 @@ namespace Rice::detail
       }
     }
 
-    std::unique_ptr<T>& convert(VALUE value)
+    std::unique_ptr<T> convert(VALUE value)
     {
-      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
-      if (!wrapper)
-      {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
-      }
-      return wrapper->data();
+      std::unique_ptr<T>* result = detail::unwrap<std::unique_ptr<T>>(value, Data_Type<std::unique_ptr<T>>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
+      // The reason we need this overriden From_Ruby is to do this std::move.
+      return std::move(*result);
     }
 
   private:
     Arg* arg_ = nullptr;
   };
-
-  template<typename T>
-  struct Type<std::unique_ptr<T>>
-  {
-    static bool verify()
-    {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        return Type<Pointer<T>>::verify();
-        return Type<Buffer<T>>::verify();
-      }
-      else
-      {
-        return Type<T>::verify();
-      }
-    }
-
-    static VALUE rubyKlass()
-    {
-      TypeMapper<T> typeMapper;
-      return typeMapper.rubyKlass();
-    }
-  };
 }
 
 

data/lib/rice/doc/rice.rb

@@ -5,7 +5,8 @@ module Rice
 
 			CLASS_DOCS = {
 				/^Rice::Buffer/ => "ruby_api/buffer",
-				/^Rice::Pointer/ => "ruby_api/pointer"
+				/^Rice::Pointer/ => "ruby_api/pointer",
+				/^Rice::Reference/ => "ruby_api/reference"
 			}
 
 			def class_url(klass)

data/lib/rice/native_registry.rb

@@ -1,21 +1,16 @@
 module Rice
 	class NativeRegistry
 		def native_attributes(klass)
-			self.native_by_kind(klass, [Rice::NativeKind::AttributeReader, Rice::NativeKind::AttributeWriter])
+			self.lookup_by_kind(klass, Rice::NativeKind::AttributeReader) +
+				self.lookup_by_kind(klass, Rice::NativeKind::AttributeWriter)
 		end
 
 		def native_methods(klass)
-			self.native_by_kind(klass, [Rice::NativeKind::Method])
+			self.lookup_by_kind(klass, Rice::NativeKind::Method)
 		end
 
 		def native_functions(klass)
-			self.native_by_kind(klass, [Rice::NativeKind::Function])
-		end
-
-		def native_by_kind(klass, kinds)
-			self.lookup(klass).find_all do |native|
-				kinds.include?(native.kind)
-			end
+			self.lookup_by_kind(klass, Rice::NativeKind::Function)
 		end
 	end
 end

data/lib/rice/rbs.rb

@@ -12,7 +12,11 @@ module Rice
 
 		def generate
 			STDOUT << "Writing rbs files to #{@output}" << "\n"
+
+			# Add the extension directory the path in case it ships with extra libraries
+			ENV["PATH"] = "#{File.dirname(self.extension)}#{File::PATH_SEPARATOR}#{ENV["PATH"]}"
 			require self.extension
+
 			types = Registries.instance.types
 			types.klasses.each do |klass|
 				process_class(klass)
@@ -20,10 +24,6 @@ module Rice
 		end
 
 		def process_class(klass)
-			if ['Rice', 'Std'].include?(klass.name.split('::').first)
-				return
-			end
-
 			STDOUT << "  " << klass << "\n"
 
 			native_attributes = Registries.instance.natives.native_attributes(klass).sort.group_by(&:name)

data/lib/rice/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.8.0"
+  VERSION = "4.9.0"
 end

data/rice/Data_Type.ipp

@@ -5,17 +5,22 @@ namespace Rice
   template<typename T>
   inline void ruby_mark_internal(detail::WrapperBase* wrapper)
   {
-    // Tell the wrapper to mark the objects its keeping alive
-    wrapper->ruby_mark();
-
-    // Get the underlying data and call custom mark function (if any)
-    T* data = static_cast<T*>(wrapper->get());
-    ruby_mark<T>(data);
+    detail::cpp_protect([&]
+    {
+      // Tell the wrapper to mark the objects its keeping alive
+      wrapper->ruby_mark();
+
+      // Get the underlying data and call custom mark function (if any)
+      // Use the wrapper's stored rb_data_type to avoid type mismatch
+      T* data = static_cast<T*>(wrapper->get(Data_Type<T>::ruby_data_type()));
+      ruby_mark<T>(data);
+    });
   }
 
   template<typename T>
   inline void ruby_free_internal(detail::WrapperBase* wrapper)
   {
+    // Destructors are noexcept so we cannot use cpp_protect here
     delete wrapper;
   }
 

data/rice/cpp_api/Class.hpp

@@ -37,6 +37,11 @@ namespace Rice
      */
     const std::string base_name() const;
 
+    //! Return the superclass of this class
+    /*! \return Class.
+     */
+    Class superclass() const;
+
 #include "shared_methods.hpp"
   };
 

data/rice/cpp_api/Class.ipp

@@ -33,6 +33,11 @@ namespace Rice
     return result;
   }
 
+  inline Class Class::superclass() const
+  {
+    return detail::protect(rb_class_superclass, this->value());
+  }
+
   inline Class define_class_under(Object parent, Identifier id, const Class& superclass)
   {
     VALUE klass = detail::protect(rb_define_class_id_under, parent.value(), id, superclass.value());

data/rice/cpp_api/Object.hpp

@@ -9,6 +9,7 @@
 namespace Rice
 {
   class Class;
+  class Module;
   class String;
   class Array;
 
@@ -116,6 +117,11 @@ namespace Rice
      */
     bool is_a(Object klass) const;
 
+    //! Extend the object with a module.
+    /*! \param mod the module to extend with.
+     */
+    void extend(Module const& mod);
+
     //! Determine if the objects responds to a method.
     /*! \param id the name of the method
      *  \return true if the objects responds to the method, false

data/rice/cpp_api/Object.ipp

@@ -99,6 +99,11 @@ namespace Rice
     return RB_TEST(result);
   }
 
+  inline void Object::extend(Module const& mod)
+  {
+    detail::protect(rb_extend_object, this->value(), mod.value());
+  }
+
   inline bool Object::respond_to(Identifier id) const
   {
     return bool(rb_respond_to(this->value(), id.id()));

data/rice/detail/Forwards.hpp

@@ -0,0 +1,18 @@
+#ifndef Rice__detail__Forwards__hpp_
+#define Rice__detail__Forwards__hpp_
+
+namespace Rice::detail
+{
+  // Setup method forwarding from a wrapper class to its wrapped type using Ruby's Forwardable.
+  // This allows calling methods on the wrapper that get delegated to the wrapped object via
+  // a "get" method that returns the wrapped object.
+  //
+  // Parameters:
+  //   wrapper_klass - The Ruby class to add forwarding to (e.g., SharedPtr_MyClass)
+  //   wrapped_klass - The Ruby class whose methods should be forwarded (e.g., MyClass)
+  void define_forwarding(VALUE wrapper_klass, VALUE wrapped_klass);
+}
+
+#include "Forwards.ipp"
+
+#endif // Rice__detail__Forwards__hpp_