rice 4.9.0 → 4.9.1

data/rice/detail/NativeMethod.ipp

@@ -107,30 +107,33 @@ namespace Rice::detail
     {
       return self;
     }
-    /* This case happens when a class wrapped by Rice is calling a method
-       defined on an ancestor class. For example, the std::map size method
-       is defined on _Tree not map. Rice needs to know the actual type
-       that was wrapped so it can correctly extract the C++ object from 
-       the Ruby object. */
-    else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> && 
-                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
-                        std::is_pointer_v<Receiver_T>)
-    {
-      Class_T* instance = From_Ruby<Class_T*>().convert(self);
-      return dynamic_cast<Receiver_T>(instance);
-    }
-    else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> &&
-                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
-                        std::is_reference_v<Receiver_T>)
-    {
-      Class_T& instance = From_Ruby<Class_T&>().convert(self);
-      return dynamic_cast<Receiver_T>(instance);
-    }
-    // Self parameter could be derived from Object or it is an C++ instance and
-    // needs to be unwrapped from Ruby
     else
     {
-      return From_Ruby<Receiver_T>().convert(self);
+      /* When a class wrapped by Rice calls a method defined on an ancestor class
+         (e.g., std::map calling a method from _Tree), we need to unwrap as Class_T
+         and dynamic_cast to the base class. Otherwise unwrap directly as Receiver_T. */
+      constexpr bool isDerived = !std::is_same_v<intrinsic_type<Receiver_T>, Class_T> &&
+                                  std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T>;
+
+      if constexpr (isDerived)
+      {
+        if constexpr (std::is_pointer_v<Receiver_T>)
+        {
+          Class_T* instance = From_Ruby<Class_T*>().convert(self);
+          return dynamic_cast<Receiver_T>(instance);
+        }
+        else if constexpr (std::is_reference_v<Receiver_T>)
+        {
+          Class_T& instance = From_Ruby<Class_T&>().convert(self);
+          return dynamic_cast<Receiver_T>(instance);
+        }
+      }
+      else
+      {
+        // Note GCC has a false warning: function may return address of local variable [-Wreturn-local-addr].
+        // From_Ruby returns a reference to data in the Ruby object, not the temporary.
+        return From_Ruby<Receiver_T>().convert(self);
+      }
     }
   }
 

data/rice/detail/NativeRegistry.hpp

@@ -31,10 +31,11 @@ namespace Rice::detail
     NativeRegistry& operator=(const NativeRegistry& other) = delete;
 
     void add(VALUE klass, ID methodId, std::unique_ptr<Native>& native);
+    void replace(VALUE klass, ID methodId, std::unique_ptr<Native>& native);
     void reset(VALUE klass);
 
-    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);
+    std::vector<std::unique_ptr<Native>>& lookup(VALUE klass, ID methodId);
     std::vector<Native*> lookup(VALUE klass, NativeKind kind);
 
   private:

data/rice/detail/NativeRegistry.ipp

@@ -3,17 +3,21 @@ namespace Rice::detail
 {
   inline void NativeRegistry::add(VALUE klass, ID methodId, std::unique_ptr<Native>& native)
   {
-    if (rb_type(klass) == T_ICLASS)
-    {
-      klass = detail::protect(rb_class_of, klass);
-    }
+    // Lookup items for method
+    std::vector<std::unique_ptr<Native>>& natives = NativeRegistry::lookup(klass, methodId);
 
-    // Create the key
-    std::pair<VALUE, ID> key = std::make_pair(klass, methodId);
+    // Add new native
+    natives.push_back(std::move(native));
+  }
 
+  inline void NativeRegistry::replace(VALUE klass, ID methodId, std::unique_ptr<Native>& native)
+  {
     // Lookup items for method
-    std::vector<std::unique_ptr<Native>>& natives = this->natives_[key];
+    std::vector<std::unique_ptr<Native>>& natives = NativeRegistry::lookup(klass, methodId);
 
+    // Clear existing natives
+    natives.clear();
+    // Add new native
     natives.push_back(std::move(native));
   }
 
@@ -33,7 +37,7 @@ namespace Rice::detail
     }
   }
   
-  inline const std::vector<Native*> NativeRegistry::lookup(VALUE klass)
+  inline std::vector<Native*> NativeRegistry::lookup(VALUE klass)
   {
     std::vector<Native*> result;
 
@@ -59,7 +63,7 @@ namespace Rice::detail
     return result;
   }
 
-  inline const std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
+  inline std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
   {
     if (rb_type(klass) == T_ICLASS)
     {

data/rice/detail/Parameter.ipp

@@ -43,17 +43,16 @@ namespace Rice::detail
     // One caveat - procs are also RUBY_T_DATA so don't check if this is a function type
     if (result == Convertible::Exact && rb_type(value) == RUBY_T_DATA && !std::is_function_v<std::remove_pointer_t<T>>)
     {
-      // Check the constness of the Ruby wrapped value and the parameter
-      WrapperBase* wrapper = getWrapper(value);
+      bool isConst = WrapperBase::isConst(value);
 
       // Do not send a const value to a non-const parameter
-      if (wrapper->isConst() && !is_const_any_v<T>)
+      if (isConst && !is_const_any_v<T>)
       {
         result = Convertible::None;
       }
       // It is ok to send a non-const value to a const parameter but
       // prefer non-const to non-const by slightly decreasing the score
-      else if (!wrapper->isConst() && is_const_any_v<T>)
+      else if (!isConst && is_const_any_v<T>)
       {
         result = Convertible::ConstMismatch;
       }

data/rice/detail/Wrapper.hpp

@@ -5,6 +5,10 @@ namespace Rice::detail
 {
   class WrapperBase
   {
+  public:
+    static void addKeepAlive(VALUE object, VALUE keepAlive);
+    static bool isConst(VALUE object);
+
   public:
     WrapperBase(rb_data_type_t* rb_data_type);
     virtual ~WrapperBase() = default;
@@ -78,7 +82,7 @@ namespace Rice::detail
 
   // ---- Helper Functions ---------
   template <typename T>
-  void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data);
+  Wrapper<T*>* wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data);
 
   template <typename T>
   VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T& data, bool isOwner);

data/rice/detail/Wrapper.ipp

@@ -2,6 +2,18 @@
 
 namespace Rice::detail
 {
+  inline void WrapperBase::addKeepAlive(VALUE object, VALUE keepAlive)
+  {
+    WrapperBase* wrapper = getWrapper(object);
+    wrapper->addKeepAlive(keepAlive);
+  }
+
+  inline bool WrapperBase::isConst(VALUE object)
+  {
+    WrapperBase* wrapper = getWrapper(object);
+    return wrapper->isConst();
+  }
+
   inline WrapperBase::WrapperBase(rb_data_type_t* rb_data_type) : rb_data_type_(rb_data_type)
   {
   }
@@ -299,7 +311,7 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data)
+  inline Wrapper<T*>* wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data)
   {
     using Wrapper_T = Wrapper<T*>;
 
@@ -315,5 +327,7 @@ namespace Rice::detail
     RTYPEDDATA_DATA(value) = wrapper;
 
     Registries::instance.instances.add(data, value);
+
+    return wrapper;
   }
 }

data/rice/stl/exception.ipp

@@ -13,7 +13,7 @@ namespace Rice::stl
       define_method("message", &std::exception::what);
 
     define_class_under<std::runtime_error>(rb_mStd, "RuntimeError", rb_eRuntimeError).
-      define_constructor(Constructor<std::runtime_error, const char*>()).
+      define_constructor(Constructor<std::runtime_error, const char*>(), Arg("what")).
       define_method("message", &std::runtime_error::what);
   }
 }

data/rice/stl/filesystem.ipp

@@ -11,7 +11,7 @@ namespace Rice
 
       define_class_under<std::filesystem::path>(rb_mFileSystem, "Path").
         define_constructor(Constructor<std::filesystem::path>()).
-        define_constructor(Constructor<std::filesystem::path, std::string>());
+        define_constructor(Constructor<std::filesystem::path, std::string>(), Arg("source"));
     }
   }
 }

data/rice/stl/map.ipp

@@ -14,6 +14,8 @@ namespace Rice
       using Size_T = typename T::size_type;
       using Difference_T = typename T::difference_type;
       using To_Ruby_T = typename detail::remove_cv_recursive_t<Mapped_T>;
+      // For pointer types, use the pointer directly; for non-pointer types, use a reference
+      using Mapped_Parameter_T = std::conditional_t<std::is_pointer_v<Mapped_T>, Mapped_T, Mapped_T&>;
 
     public:
       MapHelper(Data_Type<T> klass) : klass_(klass)
@@ -42,7 +44,7 @@ namespace Rice
 
         if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_constructor(Constructor<T, const T&>());
+          klass_.define_constructor(Constructor<T, const T&>(), Arg("other"));
         }
       }
 
@@ -71,11 +73,11 @@ namespace Rice
             {
               return std::nullopt;
             }
-          })
+          }, Arg("key"))
           .define_method("include?", [](T& map, Key_T& key) -> bool
           {
               return map.find(key) != map.end();
-          })
+          }, Arg("key"))
           .define_method("keys", [](T& map) -> std::vector<Key_T>
             {
               std::vector<Key_T> result;
@@ -110,8 +112,8 @@ namespace Rice
           klass_.define_method("==", [](T& map, T& other)->bool
           {
             return map == other;
-          })
-          .define_method("value?", [](T& map, Mapped_T& value) -> bool
+          }, Arg("other"))
+          .define_method("value?", [](T& map, Mapped_Parameter_T value) -> bool
           {
             auto it = std::find_if(map.begin(), map.end(),
             [&value](auto& pair)
@@ -120,15 +122,15 @@ namespace Rice
               });
 
             return it != map.end();
-          });
+          }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
+          klass_.define_method("value?", [](T&, Mapped_Parameter_T) -> bool
           {
               return false;
-          });
+          }, Arg("value"));
         }
 
         rb_define_alias(klass_, "has_value", "value?");
@@ -151,12 +153,12 @@ namespace Rice
               {
                 return std::nullopt;
               }
-            })
-          .define_method("[]=", [](T& map, Key_T key, Mapped_T& value) -> Mapped_T
+            }, Arg("key"))
+          .define_method("[]=", [](T& map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
               map[key] = value;
               return value;
-            });
+            }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
           rb_define_alias(klass_, "store", "[]=");
       }

data/rice/stl/multimap.ipp

@@ -14,6 +14,8 @@ namespace Rice
       using Size_T = typename T::size_type;
       using Difference_T = typename T::difference_type;
       using To_Ruby_T = typename detail::remove_cv_recursive_t<Mapped_T>;
+      // For pointer types, use the pointer directly; for non-pointer types, use a reference
+      using Mapped_Parameter_T = std::conditional_t<std::is_pointer_v<Mapped_T>, Mapped_T, Mapped_T&>;
 
     public:
       MultimapHelper(Data_Type<T> klass) : klass_(klass)
@@ -41,7 +43,7 @@ namespace Rice
 
         if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_constructor(Constructor<T, const T&>());
+          klass_.define_constructor(Constructor<T, const T&>(), Arg("other"));
         }
       }
 
@@ -70,11 +72,11 @@ namespace Rice
             }
 
             return result;
-          })
+          }, Arg("key"))
           .define_method("include?", [](T& multimap, Key_T& key) -> bool
           {
               return multimap.find(key) != multimap.end();
-          })
+          }, Arg("key"))
           .define_method("keys", [](T& multimap) -> std::vector<Key_T>
             {
               std::vector<Key_T> result;
@@ -109,8 +111,8 @@ namespace Rice
           klass_.define_method("==", [](T& multimap, T& other)->bool
           {
             return multimap == other;
-          })
-          .define_method("value?", [](T& multimap, Mapped_T& value) -> bool
+          }, Arg("other"))
+          .define_method("value?", [](T& multimap, Mapped_Parameter_T value) -> bool
           {
             auto it = std::find_if(multimap.begin(), multimap.end(),
             [&value](auto& pair)
@@ -119,15 +121,15 @@ namespace Rice
               });
 
             return it != multimap.end();
-          });
+          }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
+          klass_.define_method("value?", [](T&, Mapped_Parameter_T) -> bool
           {
               return false;
-          });
+          }, Arg("value"));
         }
 
         rb_define_alias(klass_, "has_value", "value?");
@@ -150,13 +152,13 @@ namespace Rice
             {
               return std::nullopt;
             }
-          })
-          .define_method("insert", [](T& map, Key_T key, Mapped_T& value) -> Mapped_T
+          }, Arg("key"))
+          .define_method("insert", [](T& map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
           {
             Value_T element{ key, value };
             map.insert(element);
             return value;
-          });
+          }, Arg("key").keepAlive(), Arg("value").keepAlive());
       }
 
       void define_enumerable()

data/rice/stl/pair.ipp

@@ -7,6 +7,12 @@ namespace Rice
     template<typename T>
     class PairHelper
     {
+      using First_T = typename T::first_type;
+      using Second_T = typename T::second_type;
+      // For pointer types, use the pointer directly; for non-pointer types, use a reference
+      using First_Parameter_T = std::conditional_t<std::is_pointer_v<First_T>, First_T, First_T&>;
+      using Second_Parameter_T = std::conditional_t<std::is_pointer_v<Second_T>, Second_T, Second_T&>;
+
     public:
       PairHelper(Data_Type<T> klass) : klass_(klass)
       {
@@ -19,33 +25,33 @@ namespace Rice
       void define_constructors()
       {
         klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
-      
-        if constexpr (std::is_copy_constructible_v<typename T::first_type> && std::is_copy_constructible_v<typename T::second_type>)
+              .define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
+
+        if constexpr (std::is_copy_constructible_v<First_T> && std::is_copy_constructible_v<Second_T>)
         {
-          klass_.define_constructor(Constructor<T, const T&>());
+          klass_.define_constructor(Constructor<T, const T&>(), Arg("other"));
         }
       }
 
       void define_attributes()
       {
         // Access methods
-        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::first_type>>>)
+        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<First_T>>>)
         {
           klass_.define_attr("first", &T::first, Rice::AttrAccess::Read);
         }
         else
         {
-          klass_.define_attr("first", &T::first, Rice::AttrAccess::ReadWrite);
+          klass_.define_attr("first", &T::first, Rice::AttrAccess::ReadWrite, Arg("value").keepAlive());
         }
 
-        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::second_type>>>)
+        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<Second_T>>>)
         {
           klass_.define_attr("second", &T::second, Rice::AttrAccess::Read);
         }
         else
         {
-          klass_.define_attr("second", &T::second, Rice::AttrAccess::ReadWrite);
+          klass_.define_attr("second", &T::second, Rice::AttrAccess::ReadWrite, Arg("value").keepAlive());
         }
       }
 

data/rice/stl/set.ipp

@@ -38,7 +38,7 @@ namespace Rice
       void define_constructors()
       {
         klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, const T&>());
+              .define_constructor(Constructor<T, const T&>(), Arg("other"));
       }
 
       void define_capacity_methods()
@@ -58,11 +58,11 @@ namespace Rice
           {
             auto iter = self.find(element);
             return iter != self.end();
-          })
+          }, Arg("key"))
           .define_method("count", [](T& self, const Key_T element) -> Size_T
           {
             return self.count(element);
-          });
+          }, Arg("key"));
       }
 
       void define_modify_methods()
@@ -73,17 +73,17 @@ namespace Rice
           {
             self.erase(key);
             return self;
-          })
-          .define_method("insert", [](T& self, const Value_T value) -> T&
+          }, Arg("key"))
+          .define_method("insert", [](T& self, Parameter_T value) -> T&
           {
             self.insert(value);
             return self;
-          })
+          }, Arg("value").keepAlive())
           .define_method("merge", [](T& self, T& other) -> T&
           {
             self.merge(other);
             return self;
-          });
+          }, Arg("source"));
 
         rb_define_alias(klass_, "erase", "delete");
       }
@@ -91,11 +91,11 @@ namespace Rice
       void define_operators()
       {
         klass_
-          .define_method("<<", [](T& self, const Value_T value) -> T&
+          .define_method("<<", [](T& self, Parameter_T value) -> T&
           {
             self.insert(value);
             return self;
-          })
+          }, Arg("value").keepAlive())
           .define_method("==", [](const T& self, const T& other) -> bool
           {
             if constexpr (detail::is_comparable_v<Value_T>)
@@ -106,7 +106,7 @@ namespace Rice
             {
               return false;
             }
-          })
+          }, Arg("other"))
           .define_method("&", [](const T& self, const T& other) -> T
           {
             T result;
@@ -115,7 +115,7 @@ namespace Rice
                                   std::inserter(result, result.begin()));
 
             return result;
-          })
+          }, Arg("other"))
           .define_method("|", [](const T& self, const T& other) -> T
           {
             T result;
@@ -124,7 +124,7 @@ namespace Rice
                            std::inserter(result, result.begin()));
 
             return result;
-          })
+          }, Arg("other"))
           .define_method("-", [](const T& self, const T& other) -> T
           {
             T result;
@@ -133,7 +133,7 @@ namespace Rice
                                 std::inserter(result, result.begin()));
 
             return result;
-          })
+          }, Arg("other"))
           .define_method("^", [](const T& self, const T& other) -> T
           {
             T result;
@@ -142,17 +142,17 @@ namespace Rice
                                           std::inserter(result, result.begin()));
 
             return result;
-          })
+          }, Arg("other"))
           .define_method("<", [](const T& self, const T& other) -> bool
           {
             return std::includes(other.begin(), other.end(),
                                  self.begin(), self.end());
-          })
+          }, Arg("other"))
           .define_method(">", [](const T& self, const T& other) -> bool
           {
             return std::includes(self.begin(), self.end(),
                                  other.begin(), other.end());
-          });
+          }, Arg("other"));
         
           rb_define_alias(klass_, "eql?", "==");
           rb_define_alias(klass_, "intersection", "&");

data/rice/stl/shared_ptr.ipp

@@ -23,7 +23,7 @@ namespace Rice
     Identifier id(klassName);
     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("swap", &SharedPtr_T::swap, Arg("r")).
       define_method("use_count", &SharedPtr_T::use_count).
       define_method("empty?", [](SharedPtr_T& self)->bool
       {
@@ -115,4 +115,18 @@ namespace Rice::detail
       return result;
     }
   };
+
+#ifdef __GLIBCXX__
+  // libstdc++ implementation detail: std::shared_ptr inherits from
+  // std::__shared_ptr<T, _Lock_policy>. Methods like swap() expose this
+  // internal type through their parameter signatures.
+  template<typename T, __gnu_cxx::_Lock_policy Policy>
+  struct Type<std::__shared_ptr<T, Policy>>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+#endif
 }

data/rice/stl/type_index.ipp

@@ -6,7 +6,7 @@ namespace Rice::stl
   {
     Module rb_mStd = define_module("Std");
     return define_class_under<std::type_index>(rb_mStd, "TypeIndex").
-      define_constructor(Constructor<std::type_index, const std::type_info&>()).
+      define_constructor(Constructor<std::type_index, const std::type_info&>(), Arg("target")).
       define_method("hash_code", &std::type_index::hash_code).
       define_method("name", &std::type_index::name);
   }

data/rice/stl/unique_ptr.ipp

@@ -24,8 +24,8 @@ namespace Rice
     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("reset", &UniquePtr_T::reset, Arg("ptr")).
+      define_method("swap", &UniquePtr_T::swap, Arg("other")).
       define_method("empty?", [](UniquePtr_T& self)->bool
       {
         return !self;