rice 4.7.1 → 4.9.0

data/rice/stl/unordered_map.ipp

@@ -107,7 +107,11 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<Mapped_T>)
         {
-          klass_.define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
+          klass_.define_method("==", [](T& unordered_map, T& other)->bool
+          {
+            return unordered_map == other;
+          })
+          .define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
             {
               auto it = std::find_if(unordered_map.begin(), unordered_map.end(),
               [&value](auto& pair)
@@ -117,10 +121,11 @@ namespace Rice
 
               return it != unordered_map.end();
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
+          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
           {
               return false;
           });
@@ -205,10 +210,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& unordered_map)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -299,7 +304,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -307,7 +312,7 @@ namespace Rice
             return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -333,7 +338,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::unordered_map");
           }
         }
@@ -353,7 +358,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -361,7 +366,7 @@ namespace Rice
             return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -388,7 +393,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::unordered_map");
           }
         }
@@ -409,7 +414,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -420,7 +425,7 @@ namespace Rice
             return Convertible::Exact;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -447,7 +452,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::unordered_map");
           }
         }

data/rice/stl/variant.ipp

@@ -8,7 +8,7 @@ namespace Rice::detail
     using Tuple_T = std::tuple<Types...>;
 
     template<std::size_t... I>
-    constexpr static bool verifyTypes(std::index_sequence<I...>& indices)
+    constexpr static bool verifyTypes(std::index_sequence<I...>&)
     {
       return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
@@ -32,18 +32,23 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
     template<typename U, typename V>
     VALUE convertElement(U& data, bool takeOwnership)
     {
-      return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
+      Arg arg("arg1");
+      if (takeOwnership)
+      {
+        arg.takeOwnership();
+      }
+      return To_Ruby<V>(&arg).convert(std::forward<V>(std::get<V>(data)));
     }
 
     template<typename U, std::size_t... I>
-    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>&)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -101,7 +106,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename...Types>
@@ -110,25 +115,31 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
     template<typename U, typename V>
     VALUE convertElement(U& data, bool takeOwnership)
     {
+      Arg arg("arg1");
+      if (takeOwnership)
+      {
+        arg.takeOwnership();
+      }
+
       if constexpr (std::is_const_v<U>)
       {
-        return To_Ruby<V>().convert(std::get<V>(data));
+        return To_Ruby<V>(&arg).convert(std::get<V>(data));
       }
       else
       {
-        return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
+        return To_Ruby<V>(&arg).convert(std::forward<V>(std::get<V>(data)));
       }
     }
 
     template<typename U, std::size_t... I>
-    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>&)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -154,13 +165,13 @@ namespace Rice::detail
     template<typename U>
     VALUE convert(U& data)
     {
-      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
+      bool isOwner = (this->arg_ && this->arg_->isOwner());
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
       return convertIterator(data, isOwner, indices);
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename...Types>
@@ -169,18 +180,18 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      Convertible result = Convertible::None;
+      double result = Convertible::None;
 
       for_each_tuple(this->fromRubys_,
         [&](auto& fromRuby)
         {
-          result = result | fromRuby.is_convertible(value);
+          result = (std::max)(result, fromRuby.is_convertible(value));
         });
 
       return result;
@@ -192,17 +203,17 @@ namespace Rice::detail
     {
       int i = 0;
       int index = -1;
-      Convertible foundConversion = Convertible::None;
+      double foundScore = Convertible::None;
 
       for_each_tuple(this->fromRubys_,
         [&](auto& fromRuby)
         {
-          Convertible isConvertible = fromRuby.is_convertible(value);
+          double score = fromRuby.is_convertible(value);
 
-          if (isConvertible > foundConversion)
+          if (score > foundScore)
           {
             index = i;
-            foundConversion = isConvertible;
+            foundScore = score;
           }
           i++;
         });
@@ -240,7 +251,10 @@ namespace Rice::detail
           return convertInternal<I + 1>(value, index);
         }
       }
-      rb_raise(rb_eArgError, "Could not find converter for variant");
+      else
+      {
+        rb_raise(rb_eArgError, "Could not find converter for variant");
+      }
     }
 
     std::variant<Types...> convert(VALUE value)
@@ -250,6 +264,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     // Possible converters we could use for this variant
     using From_Ruby_Ts = std::tuple<From_Ruby<Types>...>;
     From_Ruby_Ts fromRubys_;
@@ -261,7 +276,7 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -273,6 +288,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     std::variant<Types...> converted_;
   };
 }

data/rice/stl/vector.ipp

@@ -39,7 +39,7 @@ namespace Rice
       Difference_T normalizeIndex(Size_T size, Difference_T index, bool enforceBounds = false)
       {
         // Negative indices mean count from the right
-        if (index < 0 && (-index <= size))
+        if (index < 0 && ((Size_T)(-index) <= size))
         {
           index = size + index;
         }
@@ -83,7 +83,7 @@ namespace Rice
           }
 
           // Wrap the vector
-          detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+          detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
         });
       }
 
@@ -99,10 +99,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("resize", [](const T& vector, Size_T newSize)
-              {
-                // Do nothing
-              });
+          klass_.define_method("resize", [](const T&, Size_T)
+          {
+            // Do nothing
+          });
         }
       }
 
@@ -159,7 +159,7 @@ namespace Rice
               return vector[index];
             }
           })
-          .template define_method<Value_T*(T::*)()>("data", &T::data, Return().setBuffer());
+          .template define_method<Value_T*(T::*)()>("data", &T::data, ReturnBuffer());
         }
         else
         {
@@ -240,7 +240,11 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<T>)
         {
-          klass_.define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
+          klass_.define_method("==", [](T& vector, T& other)->bool
+          {
+            return vector == other;
+          })
+          .define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
           {
             auto iter = std::find(vector.begin(), vector.end(), element);
             if (iter == vector.end())
@@ -274,21 +278,22 @@ namespace Rice
               return iter - vector.begin();
             }
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
-            {
-              return std::nullopt;
-            })
-          .define_method("include?", [](const T& vector, Parameter_T element)
-            {
-              return false;
-            })
-          .define_method("index", [](const T& vector, Parameter_T element) -> std::optional<Difference_T>
-            {
-              return std::nullopt;
-            });
+          klass_.define_method("delete", [](T&, Parameter_T) -> std::optional<Value_T>
+          {
+            return std::nullopt;
+          })
+          .define_method("include?", [](const T&, Parameter_T)
+          {
+            return false;
+          })
+          .define_method("index", [](const T&, Parameter_T) -> std::optional<Difference_T>
+          {
+            return std::nullopt;
+          });
         }
       }
 
@@ -313,7 +318,7 @@ namespace Rice
           })
           .define_method("insert", [this](T& vector, Difference_T index, Parameter_T element) -> T&
           {
-            int normalized = normalizeIndex(vector.size(), index, true);
+            size_t normalized = normalizeIndex(vector.size(), index, true);
             // For a Ruby array a positive index means insert the element before the index. But
             // a negative index means insert the element *after* the index. std::vector
             // inserts *before* the index. So add 1 if this is a negative index.
@@ -412,10 +417,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& vector)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -477,7 +482,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -487,7 +492,7 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           default:
             return Convertible::None;
@@ -513,7 +518,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::vector");
           }
         }
@@ -533,7 +538,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -543,7 +548,7 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           default:
             return Convertible::None;
@@ -570,7 +575,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::vector");
           }
         }
@@ -591,7 +596,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -604,7 +609,7 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           default:
             return Convertible::None;
@@ -631,7 +636,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::vector");
           }
         }
@@ -652,7 +657,7 @@ namespace Rice
     public:
       To_Ruby() = default;
 
-      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      explicit To_Ruby(Arg* arg) : arg_(arg)
       {
       }
 
@@ -662,7 +667,7 @@ namespace Rice
       }
 
     private:
-      Return* returnInfo_ = nullptr;
+      Arg* arg_ = nullptr;
     };
   }
 }

data/rice/traits/function_traits.hpp

@@ -9,12 +9,12 @@ namespace Rice::detail
   template<typename Function_T>
   struct function_traits;
 
-  template<typename Return_T, typename Class_T, typename...Arg_Ts>
-  struct function_traits<Return_T(Class_T, Arg_Ts...)>
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T, Parameter_Ts...)>
   {
-    using arg_types = std::tuple<Arg_Ts...>;
+    using arg_types = std::tuple<Parameter_Ts...>;
 
-    static constexpr std::size_t arity = sizeof...(Arg_Ts);
+    static constexpr std::size_t arity = sizeof...(Parameter_Ts);
 
     template<std::size_t N>
     using nth_arg = typename std::tuple_element_t<N, arg_types>;
@@ -37,47 +37,47 @@ namespace Rice::detail
   };
 
   // C functions and static member functions passed by pointer
-  template<typename Return_T, typename ...Arg_Ts>
-  struct function_traits<Return_T(*)(Arg_Ts...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  template<typename Return_T, typename ...Parameter_Ts>
+  struct function_traits<Return_T(*)(Parameter_Ts...)> : public function_traits<Return_T(std::nullptr_t, Parameter_Ts...)>
   {
-    using Function_T = Return_T(*)(Arg_Ts...);
+    using Function_T = Return_T(*)(Parameter_Ts...);
   };
   
   // C functions passed by pointer that take one or more defined parameter than a variable 
   // number of parameters (the second ...)
-  template<typename Return_T, typename ...Arg_Ts>
-  struct function_traits<Return_T(*)(Arg_Ts..., ...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  template<typename Return_T, typename ...Parameter_Ts>
+  struct function_traits<Return_T(*)(Parameter_Ts..., ...)> : public function_traits<Return_T(std::nullptr_t, Parameter_Ts...)>
   {
   };
 
   // C Functions or static member functions passed by reference
-  template<typename Return_T, typename ...Arg_Ts>
-  struct function_traits<Return_T(&)(Arg_Ts...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  template<typename Return_T, typename ...Parameter_Ts>
+  struct function_traits<Return_T(&)(Parameter_Ts...)> : public function_traits<Return_T(std::nullptr_t, Parameter_Ts...)>
   {
   };
 
   // Member Functions on C++ classes
-  template<typename Return_T, typename Class_T, typename...Arg_Ts>
-  struct function_traits<Return_T(Class_T::*)(Arg_Ts...)> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...)> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
   {
   };
 
   // const member Functions on C++ classes
-  template<typename Return_T, typename Class_T, typename...Arg_Ts>
-  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) const> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) const> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
   {
   };
 
   // noexcept member Functions on C++ classes
-  template<typename Return_T, typename Class_T, typename...Arg_Ts>
-  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) noexcept> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) noexcept> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
   {
   };
 
 
   // const noexcept member Functions on C++ classes
-  template<typename Return_T, typename Class_T, typename...Arg_Ts>
-  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) const noexcept> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) const noexcept> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
   {
   };
 

data/rice/traits/method_traits.hpp

@@ -18,8 +18,8 @@ namespace Rice::detail
   {
     using Return_T = typename function_traits<Function_T>::return_type;
     using Class_T = typename function_traits<Function_T>::template nth_arg<0>;
-    using Arg_Ts = typename tuple_shift<typename function_traits<Function_T>::arg_types>::type;
-    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+    using Parameter_Ts = typename tuple_shift<typename function_traits<Function_T>::arg_types>::type;
+    static constexpr std::size_t arity = std::tuple_size_v<Parameter_Ts>;
   };
 
   // Member functions that have an implied self parameter of an object instance
@@ -29,8 +29,8 @@ namespace Rice::detail
   {
     using Return_T = typename function_traits<Function_T>::return_type;
     using Class_T = typename function_traits<Function_T>::class_type;
-    using Arg_Ts = typename function_traits<Function_T>::arg_types;
-    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+    using Parameter_Ts = typename function_traits<Function_T>::arg_types;
+    static constexpr std::size_t arity = std::tuple_size_v<Parameter_Ts>;
   };
 }
 #endif // Rice__detail__method_traits__hpp_