rice 4.7.1 → 4.8.0

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_

data/rice/traits/rice_traits.hpp

@@ -19,6 +19,10 @@ namespace Rice
     template<typename T>
     constexpr bool is_const_any_v = std::is_const_v<std::remove_pointer_t<std::remove_pointer_t<std::remove_reference_t<T>>>>;
 
+    // Helper to detect char types
+    template<typename T>
+    constexpr bool is_char_type_v = std::is_same_v<T, char> || std::is_same_v<T, signed char> || std::is_same_v<T, unsigned char>;
+
     // Recursively remove const/volatile
     template<typename T>
     struct remove_cv_recursive
@@ -109,45 +113,6 @@ namespace Rice
     template <typename T>
     constexpr bool is_std_vector_v = is_std_vector<T>::value;
 
-
-    // -- Tuple Helpers ---
-    template<typename T>
-    struct tuple_shift;
-
-    template<typename T, typename...Arg_Ts>
-    struct tuple_shift<std::tuple<T, Arg_Ts...>>
-    {
-      using type = std::tuple<Arg_Ts...>;
-    };
-
-    template<typename T, typename...Arg_Ts>
-    struct tuple_unshift;
-      
-    template<typename T, typename...Arg_Ts>
-    struct tuple_unshift<T, std::tuple<Arg_Ts...>>
-    {
-      using type = std::tuple<T, Arg_Ts...>;
-    };
-
-    template<template<typename, typename...> typename T, typename...Arg_Ts>
-    struct tuple_map;
-
-    template<template<typename, typename...> typename T, typename...Arg_Ts>
-    struct tuple_map<T, std::tuple<Arg_Ts...>>
-    {
-      using type = std::tuple<T<Arg_Ts>...>;
-    };
-
-
-    template<typename...Arg_Ts>
-    struct tuple_to_variant;
-
-    template<typename...Arg_Ts>
-    struct tuple_to_variant<std::tuple<Arg_Ts...>>
-    {
-      using type = std::variant<Arg_Ts...>;
-    };
-
     template<class T>
     struct is_pointer_pointer : std::false_type {};
 
@@ -186,6 +151,164 @@ namespace Rice
 
     template<typename T>
     constexpr bool is_wrapped_v = is_wrapped<T>::value;
+
+    // -- Tuple Helpers ---
+    template<typename T>
+    struct tuple_shift;
+
+    template<typename T, typename...Parameter_Ts>
+    struct tuple_shift<std::tuple<T, Parameter_Ts...>>
+    {
+      using type = std::tuple<Parameter_Ts...>;
+    };
+
+    template<typename T, typename...Parameter_Ts>
+    struct tuple_unshift;
+
+    template<typename T, typename...Parameter_Ts>
+    struct tuple_unshift<T, std::tuple<Parameter_Ts...>>
+    {
+      using type = std::tuple<T, Parameter_Ts...>;
+    };
+
+    template<template<typename, typename...> typename T, typename...Parameter_Ts>
+    struct tuple_map;
+
+    template<template<typename, typename...> typename T, typename...Parameter_Ts>
+    struct tuple_map<T, std::tuple<Parameter_Ts...>>
+    {
+      using type = std::tuple<T<Parameter_Ts>...>;
+    };
+
+    template<typename...Parameter_Ts>
+    struct tuple_to_variant;
+
+    template<typename...Parameter_Ts>
+    struct tuple_to_variant<std::tuple<Parameter_Ts...>>
+    {
+      using type = std::variant<Parameter_Ts...>;
+    };
+
+    template <typename T, typename... List>
+    struct is_one_of : std::disjunction<std::is_same<T, List>...> {};
+
+    template <typename T, typename... List>
+    constexpr bool is_one_of_v = is_one_of<T, List...>::value;
+
+    template<typename... FilterTypes, typename... Arg_Ts>
+    auto tuple_filter(const Arg_Ts&... args)
+    {
+      return std::tuple_cat([&args]()
+        {
+          if constexpr (is_one_of_v<Arg_Ts, FilterTypes...>)
+          {
+            return std::tuple<const Arg_Ts&>(args);
+          }
+          else
+          {
+            return std::tuple<>();
+          }
+        }()...);
+    };
+
+    // --- filter_types: recursively builds a new tuple of allowed types ---
+    template <typename Tuple, typename... Allowed>
+    struct tuple_filter_types;
+
+    template <typename... Ts, typename... Allowed>
+    struct tuple_filter_types<std::tuple<Ts...>, Allowed...>
+    {
+      using type = decltype(std::tuple_cat(std::declval<
+        std::conditional_t<is_one_of_v<std::decay_t<Ts>, Allowed...>, std::tuple<Ts>, std::tuple<>>>()...));
+    };
+
+    template <typename Tuple, typename... Allowed>
+    using tuple_filter_types_t = typename tuple_filter_types<Tuple, Allowed...>::type;
+
+    template <typename T, std::size_t... Is>
+    auto vector_to_tuple(const std::vector<T>& vec, std::index_sequence<Is...>)
+    {
+      return std::make_tuple(vec[Is]...);
+    }
+
+    template <typename Tuple, typename T, typename Seq>
+    struct tuple_pad_type;
+
+    template <typename... Ts, typename T, std::size_t... Is>
+    struct tuple_pad_type<std::tuple<Ts...>, T, std::index_sequence<Is...>>
+    {
+      // Use Is only to repeat T N times.
+      // std::conditional_t<true, T, something<Is>> is always T, but expands N times.
+      using type = std::tuple<
+        Ts...,
+        std::conditional_t<true, T, std::integral_constant<std::size_t, Is>>...
+      >;
+    };
+
+    template <typename Tuple, typename T, std::size_t N>
+    using tuple_pad_type_t = typename tuple_pad_type<Tuple, T, std::make_index_sequence<N>>::type;
+
+    // Pad tuple with values from a vector (vector size must match N)
+    template <std::size_t N, typename T, typename... Ts>
+    auto pad_tuple(const std::tuple<Ts...>& original, const std::vector<T>& padding)
+    {
+      if (padding.size() != N)
+      {
+        throw std::invalid_argument("Vector size doesn't match template parameter N");
+      }
+
+      auto padding_tuple = vector_to_tuple(padding, std::make_index_sequence<N>{});
+      return std::tuple_cat(original, padding_tuple);
+    }
+
+    template <typename Tuple, typename... Ts>
+    struct tuple_element_index_impl;
+
+    template <typename... Ts>
+    struct tuple_element_index_impl<std::tuple<>, Ts...>
+    {
+      static constexpr std::size_t value = 0;
+    };
+
+    template <typename First, typename... Rest, typename... Ts>
+    struct tuple_element_index_impl<std::tuple<First, Rest...>, Ts...>
+    {
+      static constexpr bool matches = (std::is_same_v<std::decay_t<First>, Ts> || ...);
+      static constexpr std::size_t value =
+        matches ? 0 : 1 + tuple_element_index_impl<std::tuple<Rest...>, Ts...>::value;
+    };
+
+    template <typename Tuple, typename... Ts>
+    struct tuple_element_index
+    {
+      static constexpr std::size_t value = tuple_element_index_impl<Tuple, Ts...>::value;
+    };
+
+    template <typename Tuple, typename... Ts>
+    inline constexpr std::size_t tuple_element_index_v = tuple_element_index<Tuple, Ts...>::value;
+
+    /* template<typename Target, typename T>
+     constexpr auto tuple_predicate(T&& element)
+     {
+       using U = std::decay_t<T>;
+       if constexpr (std::is_same_v<U, Target>)
+       {
+         return std::tuple<U>{ std::forward<T>(element) };
+       }
+       else
+       {
+         return std::tuple<>{};
+       }
+     }
+
+     template<typename Class_T, typename... Ts>
+     constexpr auto tuple_filter(Ts&&... args)
+     {
+       return std::tuple_cat(tuple_predicate<Class_T>(std::forward<Ts>(args))...);
+     }*/
+
+
+
   } // detail
 } // Rice
 

data/rice.gemspec

@@ -48,9 +48,7 @@ Ruby extensions with C++ easier.
     'FindRuby.cmake',
 
     # Include files
-    'include/rice/rice.hpp',
-    'include/rice/stl.hpp',
-    'include/rice/ruby-api.hpp',
+    'include/rice/*.hpp',
 
     # Bin files
     'bin/rice-rbs.rb',