rice 4.6.0 → 4.7.0

data/rice/stl/vector.ipp

@@ -38,12 +38,10 @@ namespace Rice
       // Helper method to translate Ruby indices to vector indices
       Difference_T normalizeIndex(Size_T size, Difference_T index, bool enforceBounds = false)
       {
-        // Negative indices mean count from the right. Note that negative indices
-        // wrap around!
-        if (index < 0)
+        // Negative indices mean count from the right
+        if (index < 0 && (-index <= size))
         {
-          index = ((-index) % size);
-          index = index > 0 ? size - index : index;
+          index = size + index;
         }
 
         if (enforceBounds && (index < 0 || index >= (Difference_T)size))
@@ -56,9 +54,13 @@ namespace Rice
 
       void define_constructors()
       {
-        klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, Size_T, const Parameter_T>())
-              .define_constructor(Constructor<T, const T&>());
+        klass_.define_constructor(Constructor<T>());
+
+        if constexpr (std::is_copy_constructible_v<Value_T>)
+        {
+          klass_.define_constructor(Constructor<T, const T&>())
+                .define_constructor(Constructor<T, Size_T, const Parameter_T>());
+        }
 
         if constexpr (std::is_default_constructible_v<Value_T>)
         {
@@ -120,19 +122,21 @@ namespace Rice
 
       void define_access_methods()
       {
-        // Access methods
-        klass_.define_method("first", [](const T& vector) -> std::optional<Value_T>
+        if constexpr (!std::is_same_v<Value_T, bool>)
         {
-          if (vector.size() > 0)
+          // Access methods
+          klass_.define_method("first", [](T& vector) -> std::optional<std::reference_wrapper<Value_T>>
           {
-            return vector.front();
-          }
-          else
-          {
-            return std::nullopt;
-          }
-        })
-        .define_method("last", [](const T& vector) -> std::optional<Value_T>
+            if (vector.size() > 0)
+            {
+              return vector.front();
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("last", [](T& vector) -> std::optional<std::reference_wrapper<Value_T>>
           {
             if (vector.size() > 0)
             {
@@ -143,7 +147,7 @@ namespace Rice
               return std::nullopt;
             }
           })
-        .define_method("[]", [this](const T& vector, Difference_T index) -> std::optional<Value_T>
+          .define_method("[]", [this](T& vector, Difference_T index) -> std::optional<std::reference_wrapper<Value_T>>
           {
             index = normalizeIndex(vector.size(), index);
             if (index < 0 || index >= (Difference_T)vector.size())
@@ -155,46 +159,80 @@ namespace Rice
               return vector[index];
             }
           })
-        .define_method("[]", [this](const T& vector, Difference_T start, Difference_T length) -> VALUE
+          .template define_method<Value_T*(T::*)()>("data", &T::data, Return().setBuffer());
+        }
+        else
+        {
+          // Access methods
+          klass_.define_method("first", [](T& vector) -> std::optional<Value_T>
+          {
+            if (vector.size() > 0)
+            {
+              return vector.front();
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("last", [](T& vector) -> std::optional<Value_T>
+          {
+            if (vector.size() > 0)
+            {
+              return vector.back();
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("[]", [this](T& vector, Difference_T index) -> std::optional<Value_T>
           {
-            start = normalizeIndex(vector.size(), start);
-            if (start < 0 || start >= (Difference_T)vector.size())
+            index = normalizeIndex(vector.size(), index);
+            if (index < 0 || index >= (Difference_T)vector.size())
             {
-              return rb_ary_new();
+              return std::nullopt;
             }
             else
             {
-              auto begin = vector.begin() + start;
+              return vector[index];
+            }
+          });
+        }
 
-              // Ruby does not throw an exception when the length is too long
-              Difference_T size = (Difference_T)vector.size();
-              if (start + length > size)
-              {
-                length = size - start;
-              }
+        klass_.define_method("[]", [this](T& vector, Difference_T start, Difference_T length) -> VALUE
+        {
+          start = normalizeIndex(vector.size(), start);
+          if (start < 0 || start >= (Difference_T)vector.size())
+          {
+            return rb_ary_new();
+          }
+          else
+          {
+            auto begin = vector.begin() + start;
 
-              auto finish = vector.begin() + start + length;
-              T slice(begin, finish);
+            // Ruby does not throw an exception when the length is too long
+            Difference_T size = (Difference_T)vector.size();
+            if (start + length > size)
+            {
+              length = size - start;
+            }
 
-              VALUE result = rb_ary_new();
-              std::for_each(slice.begin(), slice.end(), [&result](const Reference_T element)
-              {
-                VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
-                rb_ary_push(result, value);
-              });
+            auto finish = vector.begin() + start + length;
 
-              return result;
+            VALUE result = rb_ary_new();
+            for (auto iter = begin; iter != finish; iter++)
+            {
+              const Reference_T element = *iter;
+              VALUE value = detail::To_Ruby<Reference_T>().convert(element);
+              rb_ary_push(result, value);
             }
-          }, Return().setValue());
 
-          if constexpr (!std::is_same_v<Value_T, bool>)
-          {
-            define_buffer<Value_T>();
-            define_buffer<Value_T*>();
-            klass_.template define_method<Value_T*(T::*)()>("data", &T::data);
+            return result;
           }
+        }, Return().setValue());
 
-          rb_define_alias(klass_, "at", "[]");
+        rb_define_alias(klass_, "at", "[]");
       }
 
       // Methods that require Value_T to support operator==
@@ -203,35 +241,39 @@ namespace Rice
         if constexpr (detail::is_comparable_v<T>)
         {
           klass_.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())
             {
-              auto iter = std::find(vector.begin(), vector.end(), element);
-              if (iter == vector.end())
-              {
-                return std::nullopt;
-              }
-              else
-              {
-                Value_T result = *iter;
-                vector.erase(iter);
-                return result;
-              }
-            })
-          .define_method("include?", [](T& vector, Parameter_T element)
+              return std::nullopt;
+            }
+            else if constexpr (std::is_copy_assignable_v<Value_T>)
             {
-              return std::find(vector.begin(), vector.end(), element) != vector.end();
-            })
+              Value_T result = *iter;
+              vector.erase(iter);
+              return result;
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("include?", [](T& vector, Parameter_T element)
+          {
+            return std::find(vector.begin(), vector.end(), element) != vector.end();
+          })
           .define_method("index", [](T& vector, Parameter_T element) -> std::optional<Difference_T>
+          {
+            auto iter = std::find(vector.begin(), vector.end(), element);
+            if (iter == vector.end())
             {
-              auto iter = std::find(vector.begin(), vector.end(), element);
-              if (iter == vector.end())
-              {
-                return std::nullopt;
-              }
-              else
-              {
-                return iter - vector.begin();
-              }
-            });
+              return std::nullopt;
+            }
+            else
+            {
+              return iter - vector.begin();
+            }
+          });
         }
         else
         {
@@ -253,45 +295,65 @@ namespace Rice
       void define_modify_methods()
       {
         klass_.define_method("clear", &T::clear)
-          .define_method("delete_at", [](T& vector, const size_t& pos)
+          .define_method("delete_at", [](T& vector, const size_t& pos) -> std::optional<Value_T>
+          {
+            auto iter = vector.begin() + pos;
+
+            if constexpr (std::is_copy_assignable_v<Value_T>)
             {
-              auto iter = vector.begin() + pos;
               Value_T result = *iter;
               vector.erase(iter);
               return result;
-            })
+            }
+            else
+            {
+              vector.erase(iter);
+              return std::nullopt;
+            }
+          })
           .define_method("insert", [this](T& vector, Difference_T index, Parameter_T element) -> T&
+          {
+            int 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.
+            if (index < 0)
             {
-              index = normalizeIndex(vector.size(), index, true);
-              auto iter = vector.begin() + index;
-              vector.insert(iter, element);
-              return vector;
-            })
+              normalized++;
+            }
+            auto iter = vector.begin() + normalized;
+            vector.insert(iter, std::move(element));
+            return vector;
+          })
           .define_method("pop", [](T& vector) -> std::optional<Value_T>
+          {
+            if constexpr (!std::is_copy_assignable_v<Value_T>)
             {
-              if (vector.size() > 0)
-              {
-                Value_T result = vector.back();
-                vector.pop_back();
-                return result;
-              }
-              else
-              {
-                return std::nullopt;
-              }
-            })
-          .define_method("push", [](T& vector, Parameter_T element) -> T&
+              vector.pop_back();
+              return std::nullopt;
+            }
+            else if (vector.empty())
             {
-              vector.push_back(element);
-              return vector;
-            })
-          .define_method("shrink_to_fit", &T::shrink_to_fit)
-          .define_method("[]=", [this](T& vector, Difference_T index, Parameter_T element) -> Parameter_T
+              return std::nullopt;
+            }
+            else
             {
-              index = normalizeIndex(vector.size(), index, true);
-              vector[index] = element;
-              return element;
-            });
+              Value_T result = vector.back();
+              vector.pop_back();
+              return result;
+            }
+          })
+          .define_method("push", [](T& vector, Parameter_T element) -> T&
+          {
+            vector.push_back(std::move(element));
+            return vector;
+          })
+        .define_method("shrink_to_fit", &T::shrink_to_fit)
+        .define_method("[]=", [this](T& vector, Difference_T index, Parameter_T element) -> void
+          {
+            index = normalizeIndex(vector.size(), index, true);
+            vector[index] = std::move(element);
+          });
 
         rb_define_alias(klass_, "push_back", "push");
         rb_define_alias(klass_, "<<", "push");
@@ -312,7 +374,7 @@ namespace Rice
           VALUE result = rb_ary_new();
           std::for_each(vector.begin(), vector.end(), [&result](const Reference_T element)
           {
-            VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
+            VALUE value = detail::To_Ruby<Reference_T>().convert(element);
             rb_ary_push(result, value);
           });
 
@@ -370,8 +432,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Vector_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Vector_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -523,6 +585,12 @@ namespace Rice
     class From_Ruby<std::vector<T>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -570,6 +638,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::vector<T> converted_;
     };
   }
@@ -581,10 +650,19 @@ namespace Rice
     class To_Ruby<std::vector<bool>::reference>
     {
     public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+      {
+      }
+
       VALUE convert(const std::vector<bool>::reference& value)
       {
         return value ? Qtrue : Qfalse;
       }
+
+    private:
+      Return* returnInfo_ = nullptr;
     };
   }
 }

data/rice/stl.hpp

@@ -6,6 +6,7 @@
 #include "stl/string.hpp"
 #include "stl/string_view.hpp"
 #include "stl/complex.hpp"
+#include "stl/filesystem.hpp"
 #include "stl/optional.hpp"
 #include "stl/reference_wrapper.hpp"
 #include "stl/pair.hpp"

data/rice/traits/attribute_traits.hpp

@@ -9,17 +9,17 @@ namespace Rice::detail
   template<typename Attribute_T>
   struct attribute_traits;
 
-  template<typename Attr_T>
-  struct attribute_traits<Attr_T*>
+  template<typename Attribute_T>
+  struct attribute_traits<Attribute_T*>
   {
-    using attr_type = Attr_T;
+    using attr_type = Attribute_T;
     using class_type = std::nullptr_t;
   };
 
-  template<typename Attr_T, typename Class_T>
-  struct attribute_traits<Attr_T Class_T::*> 
+  template<typename Attribute_T, typename Class_T>
+  struct attribute_traits<Attribute_T(Class_T::*)>
   {
-    using attr_type = Attr_T;
+    using attr_type = Attribute_T;
     using class_type = Class_T;
   };
 }

data/rice/traits/function_traits.hpp

@@ -17,7 +17,7 @@ namespace Rice::detail
     static constexpr std::size_t arity = sizeof...(Arg_Ts);
 
     template<std::size_t N>
-    using nth_arg = typename std::tuple_element<N, arg_types>::type;
+    using nth_arg = typename std::tuple_element_t<N, arg_types>;
 
     using return_type = Return_T;
     using class_type = Class_T;
@@ -32,7 +32,7 @@ namespace Rice::detail
 
   public:
     using arg_types = typename functor_t::arg_types;
-    static constexpr std::size_t arity = functor_t::arity - 1;
+    static constexpr std::size_t arity = functor_t::arity;
     using class_type = std::nullptr_t;
   };
 

data/rice/traits/method_traits.hpp

@@ -6,26 +6,15 @@
 namespace Rice::detail
 {
   // Declare struct
-  template<typename Function_T, bool IsMethod, typename = void>
+  template<typename Function_T, typename = void>
   struct method_traits;
 
-  // Functions that do not have a self parameter:
-  //   doSomething(int a)
-  template<typename Function_T, bool IsMethod>
-  struct method_traits<Function_T, IsMethod, std::enable_if_t<!IsMethod>>
-  {
-    using Return_T = typename function_traits<Function_T>::return_type;
-    using Class_T = std::nullptr_t;
-    using Arg_Ts = typename function_traits<Function_T>::arg_types;
-    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
-  };
-
   /* Functions that have a self parameter and thus we treat them as free standing
     "methods" versus member functions. 
     
        doSomething(VALUE self, int a) */
-  template<typename Function_T, bool IsMethod>
-  struct method_traits<Function_T, IsMethod, std::enable_if_t<IsMethod && std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
+  template<typename Function_T>
+  struct method_traits<Function_T, std::enable_if_t<std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
   {
     using Return_T = typename function_traits<Function_T>::return_type;
     using Class_T = typename function_traits<Function_T>::template nth_arg<0>;
@@ -35,8 +24,8 @@ namespace Rice::detail
 
   // Member functions that have an implied self parameter of an object instance
   //   foo.doSomething(int a)
-  template<typename Function_T, bool IsMethod>
-  struct method_traits<Function_T, IsMethod, std::enable_if_t<IsMethod && !std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
+  template<typename Function_T>
+  struct method_traits<Function_T, std::enable_if_t<!std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
   {
     using Return_T = typename function_traits<Function_T>::return_type;
     using Class_T = typename function_traits<Function_T>::class_type;

data/rice/traits/rice_traits.hpp

@@ -2,6 +2,7 @@
 #define Rice__detail__traits__hpp_
 
 #include <ostream>
+#include <tuple>
 #include <type_traits>
 #include <variant>
 #include <vector>
@@ -49,11 +50,11 @@ namespace Rice
       using type = typename remove_cv_recursive<T>::type&;
     };
 
-   /* template<typename T>
+    template<typename T>
     struct remove_cv_recursive<T&&>
     {
       using type = typename remove_cv_recursive<T>::type&&;
-    };*/
+    };
 
     template<typename T>
     struct remove_cv_recursive<T*>
@@ -99,6 +100,16 @@ namespace Rice
       static const bool value = is_comparable_v<T>;
     };
 
+    template<typename>
+    struct is_std_vector : std::false_type {};
+
+    template<typename T, typename A>
+    struct is_std_vector<std::vector<T, A>> : std::true_type {};
+
+    template <typename T>
+    constexpr bool is_std_vector_v = is_std_vector<T>::value;
+
+
     // -- Tuple Helpers ---
     template<typename T>
     struct tuple_shift;
@@ -108,16 +119,26 @@ namespace Rice
     {
       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<remove_cv_recursive_t<Arg_Ts>>...>;
+      using type = std::tuple<T<Arg_Ts>...>;
     };
 
+
     template<typename...Arg_Ts>
     struct tuple_to_variant;
 
@@ -154,6 +175,17 @@ namespace Rice
           (callable(std::forward<decltype(args)>(args)), ...);
         }, std::forward<Tuple_T>(tuple));
     }
+
+    template<typename T, typename = void>
+    struct is_wrapped : std::true_type {};
+
+    template<typename T>
+    struct is_wrapped<T, std::enable_if_t<std::is_fundamental_v<detail::intrinsic_type<T>> ||
+                                          std::is_same_v<detail::intrinsic_type<T>, std::string>>
+                     >: std::false_type {};
+
+    template<typename T>
+    constexpr bool is_wrapped_v = is_wrapped<T>::value;
   } // detail
 } // Rice
 

data/rice.gemspec

@@ -23,6 +23,9 @@ Ruby extensions with C++ easier.
     "source_code_uri"   => "https://github.com/ruby-rice/rice",
   }
 
+  s.bindir = "bin"
+  s.executables = ["rice-doc.rb", "rice-rbs.rb"]
+
   s.test_files = Dir['test/ruby/*.rb']
   s.extra_rdoc_files = ['README.md']
   s.require_paths = ['lib']
@@ -44,41 +47,27 @@ Ruby extensions with C++ easier.
     'CMakePresets.json',
     'FindRuby.cmake',
 
-    # rice.hpp
+    # Include files
     'include/rice/rice.hpp',
     'include/rice/stl.hpp',
+    'include/rice/ruby-api.hpp',
+
+    # Bin files
+    'bin/rice-rbs.rb',
 
     # Source files
     'rice/**/*.?pp',
 
-    # Ruby files
+    # Library files
     'lib/**/*.rb',
 
-    # Samples
-    'sample/enum/extconf.rb',
-    'sample/enum/*.?pp',
-    'sample/enum/*.rb',
-    'sample/map/extconf.rb',
-    'sample/map/*.?pp',
-    'sample/map/*.rb',
-    'sample/inheritance/extconf.rb',
-    'sample/inheritance/*.?pp',
-    'sample/inheritance/*.rb',
-    'sample/callbacks/extconf.rb',
-    'sample/callbacks/*.?pp',
-    'sample/callbacks/*.rb',
-
     # Test source files
     'test/*.?pp',
-    'test/extconf.rb',
-    'test/ext/t1/extconf.rb',
-    'test/ext/t1/*.*pp',
-    'test/ext/t2/extconf.rb',
-    'test/ext/t2/*.*pp'
+    'test/extconf.rb'
   ]
 
   s.required_ruby_version = ">= 3.1"
-
+  s.add_dependency "ostruct"
   s.add_development_dependency "bundler"
   s.add_development_dependency "rake"
   s.add_development_dependency "minitest"

data/test/embed_ruby.cpp

@@ -25,8 +25,5 @@ void embed_ruby()
 #endif
 
     initialized__ = true;
-
-    // Initialize Rice
-    Rice::init();
   }
 }