rice 4.8.0 → 4.9.0

data/rice/detail/Forwards.ipp

@@ -0,0 +1,60 @@
+namespace Rice::detail
+{
+  inline void define_forwarding(VALUE wrapper_klass, VALUE wrapped_klass)
+  {
+    protect(rb_require, "forwardable");
+    Object forwardable = Object(rb_cObject).const_get("Forwardable");
+    Object(wrapper_klass).extend(forwardable.value());
+
+    // Get wrapper class's method names to avoid conflicts
+    std::set<std::string> wrapperMethodSet;
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::Method))
+    {
+      wrapperMethodSet.insert(native->name());
+    }
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::AttributeReader))
+    {
+      wrapperMethodSet.insert(native->name());
+    }
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::AttributeWriter))
+    {
+      wrapperMethodSet.insert(native->name() + "=");
+    }
+
+    // Get wrapped class's method names from the registry, including ancestor classes
+    std::set<std::string> wrappedMethodSet;
+    Class klass(wrapped_klass);
+    while (klass.value() != rb_cObject && klass.value() != Qnil)
+    {
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::Method))
+      {
+        wrappedMethodSet.insert(native->name());
+      }
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::AttributeReader))
+      {
+        wrappedMethodSet.insert(native->name());
+      }
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::AttributeWriter))
+      {
+        wrappedMethodSet.insert(native->name() + "=");
+      }
+
+      klass = klass.superclass();
+    }
+
+    // Build the arguments array for def_delegators: [:get, :method1, :method2, ...]
+    // Skip methods that are already defined on the wrapper class
+    Array args;
+    args.push(Symbol("get"));
+    for (const std::string& method : wrappedMethodSet)
+    {
+      if (wrapperMethodSet.find(method) == wrapperMethodSet.end())
+      {
+        args.push(Symbol(method));
+      }
+    }
+
+    // Call def_delegators(*args)
+    Object(wrapper_klass).vcall("def_delegators", args);
+  }
+}

data/rice/detail/NativeRegistry.hpp

@@ -35,6 +35,7 @@ namespace Rice::detail
 
     const std::vector<Native*> lookup(VALUE klass);
     const std::vector<std::unique_ptr<Native>>& lookup(VALUE klass, ID methodId);
+    std::vector<Native*> lookup(VALUE klass, NativeKind kind);
 
   private:
     // Key - Ruby klass/method

data/rice/detail/NativeRegistry.ipp

@@ -72,4 +72,33 @@ namespace Rice::detail
     // Lookup items for method
     return this->natives_[key];
   }
+
+  inline std::vector<Native*> NativeRegistry::lookup(VALUE klass, NativeKind kind)
+  {
+    std::vector<Native*> result;
+
+    if (rb_type(klass) == T_ICLASS)
+    {
+      klass = detail::protect(rb_class_of, klass);
+    }
+
+    for (auto& pair : this->natives_)
+    {
+      const std::pair<VALUE, ID>& key = pair.first;
+
+      if (klass == key.first)
+      {
+        const std::vector<std::unique_ptr<Native>>& natives = pair.second;
+        for (auto& native : natives)
+        {
+          if (native->kind() == kind)
+          {
+            result.push_back(native.get());
+          }
+        }
+      }
+    }
+
+    return result;
+  }
 }

data/rice/detail/Type.ipp

@@ -209,6 +209,10 @@ namespace Rice::detail
     std::regex equalRegex(R"(,\s*std::equal_to)");
     removeGroup(base, equalRegex);
 
+    // Remove default_delete (std::unique_ptr)
+    std::regex defaultDeleteRegex(R"(,\s*std::default_delete)");
+    removeGroup(base, defaultDeleteRegex);
+
     // Remove spaces before pointers
     std::regex ptrRegex = std::regex(R"(\s+\*)");
     base = std::regex_replace(base, ptrRegex, "*");

data/rice/detail/Wrapper.hpp

@@ -6,9 +6,9 @@ namespace Rice::detail
   class WrapperBase
   {
   public:
-    WrapperBase() = default;
+    WrapperBase(rb_data_type_t* rb_data_type);
     virtual ~WrapperBase() = default;
-    virtual void* get() = 0;
+    virtual void* get(rb_data_type_t* requestedType) = 0;
     bool isConst();
 
     void ruby_mark();
@@ -16,6 +16,7 @@ namespace Rice::detail
     void setOwner(bool value);
 
   protected:
+    rb_data_type_t* rb_data_type_;
     bool isOwner_ = false;
     bool isConst_ = false;
 
@@ -30,10 +31,10 @@ namespace Rice::detail
   class Wrapper : public WrapperBase
   {
   public:
-    Wrapper(T& data);
-    Wrapper(T&& data);
+    Wrapper(rb_data_type_t* rb_data_type, T& data);
+    Wrapper(rb_data_type_t* rb_data_type, T&& data);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T data_;
@@ -43,9 +44,9 @@ namespace Rice::detail
   class Wrapper<T&> : public WrapperBase
   {
   public:
-    Wrapper(T& data);
+    Wrapper(rb_data_type_t* rb_data_type, T& data);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T& data_;
@@ -55,9 +56,9 @@ namespace Rice::detail
   class Wrapper<T*> : public WrapperBase
   {
   public:
-    Wrapper(T* data, bool isOwner);
+    Wrapper(rb_data_type_t* rb_data_type, T* data, bool isOwner);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T* data_ = nullptr;
@@ -67,9 +68,9 @@ namespace Rice::detail
   class Wrapper<T**> : public WrapperBase
   {
   public:
-    Wrapper(T** data, bool isOwner);
+    Wrapper(rb_data_type_t* rb_data_type, T** data, bool isOwner);
     ~Wrapper();
-    void* get() override;
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     T** data_ = nullptr;

data/rice/detail/Wrapper.ipp

@@ -2,6 +2,10 @@
 
 namespace Rice::detail
 {
+  inline WrapperBase::WrapperBase(rb_data_type_t* rb_data_type) : rb_data_type_(rb_data_type)
+  {
+  }
+
   inline bool WrapperBase::isConst()
   {
     return this->isConst_;
@@ -27,31 +31,40 @@ namespace Rice::detail
 
   // ----  Wrapper -----
   template <typename T>
-  inline Wrapper<T>::Wrapper(T& data): data_(data)
+  inline Wrapper<T>::Wrapper(rb_data_type_t* rb_data_type, T& data) : WrapperBase(rb_data_type), data_(data)
   {
     this->isConst_ = std::is_const_v<std::remove_reference_t<T>>;
   }
 
   template <typename T>
-  inline Wrapper<T>::Wrapper(T&& data) : data_(std::move(data))
+  inline Wrapper<T>::Wrapper(rb_data_type_t* rb_data_type, T&& data) : WrapperBase(rb_data_type), data_(std::move(data))
   {
   }
 
   template <typename T>
   inline Wrapper<T>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
   }
 
   template <typename T>
-  inline void* Wrapper<T>::Wrapper::get()
+  inline void* Wrapper<T>::get(rb_data_type_t* requestedType)
   {
-    return (void*)&this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)&this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ----  Wrapper& -----
   template <typename T>
-  inline Wrapper<T&>::Wrapper(T& data): data_(data)
+  inline Wrapper<T&>::Wrapper(rb_data_type_t* rb_data_type, T& data) : WrapperBase(rb_data_type), data_(data)
   {
     this->isConst_ = std::is_const_v<std::remove_reference_t<T>>;
   }
@@ -59,18 +72,27 @@ namespace Rice::detail
   template <typename T>
   inline Wrapper<T&>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
   }
 
   template <typename T>
-  inline void* Wrapper<T&>::get()
+  inline void* Wrapper<T&>::get(rb_data_type_t* requestedType)
   {
-    return (void*)&this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)&this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ----  Wrapper* -----
   template <typename T>
-  inline Wrapper<T*>::Wrapper(T* data, bool isOwner) : data_(data)
+  inline Wrapper<T*>::Wrapper(rb_data_type_t* rb_data_type, T* data, bool isOwner) : WrapperBase(rb_data_type), data_(data)
   {
     this->isOwner_ = isOwner;
     this->isConst_ = std::is_const_v<std::remove_pointer_t<T>>;
@@ -79,7 +101,8 @@ namespace Rice::detail
   template <typename T>
   inline Wrapper<T*>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+
     if constexpr (std::is_destructible_v<T>)
     {
       if (this->isOwner_)
@@ -90,14 +113,23 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void* Wrapper<T*>::get()
+  inline void* Wrapper<T*>::get(rb_data_type_t* requestedType)
   {
-    return (void*)this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ----  Wrapper** -----
   template <typename T>
-  inline Wrapper<T**>::Wrapper(T** data, bool isOwner) : data_(data)
+  inline Wrapper<T**>::Wrapper(rb_data_type_t* rb_data_type, T** data, bool isOwner) : WrapperBase(rb_data_type), data_(data)
   {
     this->isOwner_ = isOwner;
     this->isConst_ = std::is_const_v<std::remove_pointer_t<std::remove_pointer_t<T>>>;
@@ -106,7 +138,8 @@ namespace Rice::detail
   template <typename T>
   inline Wrapper<T**>::~Wrapper()
   {
-    Registries::instance.instances.remove(this->get());
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+
     if constexpr (std::is_destructible_v<T>)
     {
       if (this->isOwner_)
@@ -117,9 +150,18 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void* Wrapper<T**>::get()
+  inline void* Wrapper<T**>::get(rb_data_type_t* requestedType)
   {
-    return (void*)this->data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return (void*)this->data_;
+    }
+    else
+    {
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+                      this->rb_data_type_->wrap_struct_name,
+                      requestedType->wrap_struct_name);
+    }
   }
 
   // ---- Helper Functions -------
@@ -136,7 +178,7 @@ namespace Rice::detail
     // If Ruby is not the owner then wrap the reference
     if (!isOwner)
     {
-      wrapper = new Wrapper<T&>(data);
+      wrapper = new Wrapper<T&>(rb_data_type, data);
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
@@ -145,12 +187,12 @@ namespace Rice::detail
     {
       if constexpr (std::is_copy_constructible_v<typename T::value_type>)
       {
-        wrapper = new Wrapper<T>(data);
+        wrapper = new Wrapper<T>(rb_data_type, data);
         result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
       }
       else
       {
-        wrapper = new Wrapper<T>(std::move(data));
+        wrapper = new Wrapper<T>(rb_data_type, std::move(data));
         result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
       }
     }
@@ -158,14 +200,14 @@ namespace Rice::detail
     // Ruby is the owner so copy data
     else if constexpr (std::is_copy_constructible_v<T>)
     {
-      wrapper = new Wrapper<T>(data);
+      wrapper = new Wrapper<T>(rb_data_type, data);
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
     // Ruby is the owner so move data
     else if constexpr (std::is_move_constructible_v<T>)
     {
-      wrapper = new Wrapper<T>(std::move(data));
+      wrapper = new Wrapper<T>(rb_data_type, std::move(data));
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
@@ -177,7 +219,7 @@ namespace Rice::detail
       throw std::runtime_error(message);
     }
 
-    Registries::instance.instances.add(wrapper->get(), result);
+    Registries::instance.instances.add(wrapper->get(rb_data_type), result);
 
     return result;
   };
@@ -190,38 +232,40 @@ namespace Rice::detail
     if (result != Qnil)
       return result;
 
-    WrapperBase* wrapper = new Wrapper<T*>(data, isOwner);
+    WrapperBase* wrapper = new Wrapper<T*>(rb_data_type, data, isOwner);
     result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
 
-    Registries::instance.instances.add(wrapper->get(), result);
+    Registries::instance.instances.add(wrapper->get(rb_data_type), result);
     return result;
   };
 
   template <typename T>
   inline T* unwrap(VALUE value, rb_data_type_t* rb_data_type, bool takeOwnership)
   {
-    if (rb_type(value) != RUBY_T_DATA)
+    if (!RTYPEDDATA_P(value))
     {
       std::string message = "The Ruby object does not wrap a C++ object. It is actually a " +
         std::string(detail::protect(rb_obj_classname, value)) + ".";
       throw std::runtime_error(message);
     }
 
-    WrapperBase* wrapper = getWrapper(value, rb_data_type);
+    WrapperBase* wrapper = static_cast<WrapperBase*>(RTYPEDDATA_DATA(value));
 
     if (wrapper == nullptr)
     {
-      std::string message = "Wrapped C++ object is nil. Did you override " + 
-                            std::string(detail::protect(rb_obj_classname, value)) + 
+      std::string message = "Wrapped C++ object is nil. Did you override " +
+                            std::string(detail::protect(rb_obj_classname, value)) +
                             "#initialize and forget to call super?";
 
       throw std::runtime_error(message);
     }
 
     if (takeOwnership)
+    {
       wrapper->setOwner(false);
+    }
 
-    return static_cast<T*>(wrapper->get());
+    return static_cast<T*>(wrapper->get(rb_data_type));
   }
     
   template <typename Wrapper_T>
@@ -243,7 +287,8 @@ namespace Rice::detail
     if (!RTYPEDDATA_P(value))
     {
       throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
-        detail::protect(rb_obj_classname, value), "wrapped C++ object");
+                      detail::protect(rb_obj_classname, value),
+                      "wrapped C++ object");
     }
 
     return static_cast<WrapperBase*>(RTYPEDDATA_DATA(value));
@@ -257,18 +302,18 @@ namespace Rice::detail
   inline void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data)
   {
     using Wrapper_T = Wrapper<T*>;
-    
+
     Wrapper_T* wrapper = nullptr;
     TypedData_Get_Struct(value, Wrapper_T, rb_data_type, wrapper);
     if (wrapper)
     {
-      Registries::instance.instances.remove(wrapper->get());
+      Registries::instance.instances.remove(wrapper->get(rb_data_type));
       delete wrapper;
     }
 
-    wrapper = new Wrapper_T(data, true);
+    wrapper = new Wrapper_T(rb_data_type, data, true);
     RTYPEDDATA_DATA(value) = wrapper;
 
     Registries::instance.instances.add(data, value);
   }
-} // namespace
+}

data/rice/rice.hpp

@@ -156,6 +156,9 @@
 // Dependent on Module, Class, Array and String
 #include "forward_declares.ipp"
 
+// Dependent on Module, Array, Symbol - used by stl smart pointers
+#include "detail/Forwards.hpp"
+
 // For now include libc support - maybe should be separate header file someday
 #include "libc/file.hpp"
 

data/rice/rice_api/NativeRegistry.ipp

@@ -17,5 +17,18 @@ inline void Init_Native_Registry()
       }
 
       return result;
-    }, Arg("klass").setValue());
+    }, Arg("klass").setValue()).
+
+    define_method("lookup_by_kind", [](detail::NativeRegistry& self, VALUE klass, detail::NativeKind kind) -> Array
+    {
+      Array result;
+
+      const std::vector<detail::Native*> natives = self.lookup(klass, kind);
+      for (detail::Native* native : natives)
+      {
+        result.push(native, false);
+      }
+
+      return result;
+    }, Arg("klass").setValue(), Arg("kind"));
 }

data/rice/stl/shared_ptr.hpp

@@ -7,6 +7,22 @@ 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_;
+  };
+}
+
 #include "shared_ptr.ipp"
 
 #endif // Rice__stl__shared_ptr__hpp_

data/rice/stl/shared_ptr.ipp

@@ -1,6 +1,5 @@
 #include <memory>
 
-// --------- Enable creation of std::shared_ptr from Ruby ---------
 namespace Rice
 {
   template<typename T>
@@ -22,74 +21,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;
     }
   };
 }