rice 4.7.0 → 4.8.0

data/rice/cpp_api/Array.ipp

@@ -186,7 +186,7 @@ namespace Rice
   }
 
   template<typename Array_Ptr_T, typename Value_T>
-  inline Value_T Array::Iterator<Array_Ptr_T, Value_T>::operator*()
+  inline Value_T Array::Iterator<Array_Ptr_T, Value_T>::operator*() const
   {
     return (*array_)[index_];
   }
@@ -212,6 +212,99 @@ namespace Rice
     return !(*this == rhs);
   }
 
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline bool Array::Iterator<Array_Ptr_T, Value_T>::operator<(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const
+  {
+    return index_ < rhs.index_;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline bool Array::Iterator<Array_Ptr_T, Value_T>::operator>(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const
+  {
+    return index_ > rhs.index_;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline bool Array::Iterator<Array_Ptr_T, Value_T>::operator<=(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const
+  {
+    return index_ <= rhs.index_;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  template<typename Array_Ptr_T_, typename Value_T_>
+  inline bool Array::Iterator<Array_Ptr_T, Value_T>::operator>=(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const
+  {
+    return index_ >= rhs.index_;
+  }
+
+  // Bidirectional iterator operations
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T>& Array::Iterator<Array_Ptr_T, Value_T>::operator--()
+  {
+    --index_;
+    return *this;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T> Array::Iterator<Array_Ptr_T, Value_T>::operator--(int)
+  {
+    Iterator copy(*this);
+    --(*this);
+    return copy;
+  }
+
+  // Random access iterator operations
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T>& Array::Iterator<Array_Ptr_T, Value_T>::operator+=(difference_type n)
+  {
+    index_ += n;
+    return *this;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T>& Array::Iterator<Array_Ptr_T, Value_T>::operator-=(difference_type n)
+  {
+    index_ -= n;
+    return *this;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T> Array::Iterator<Array_Ptr_T, Value_T>::operator+(difference_type n) const
+  {
+    return Iterator(array_, index_ + n);
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T> Array::Iterator<Array_Ptr_T, Value_T>::operator-(difference_type n) const
+  {
+    return Iterator(array_, index_ - n);
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline typename Array::Iterator<Array_Ptr_T, Value_T>::difference_type
+  Array::Iterator<Array_Ptr_T, Value_T>::operator-(Iterator const& rhs) const
+  {
+    return index_ - rhs.index_;
+  }
+
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Value_T Array::Iterator<Array_Ptr_T, Value_T>::operator[](difference_type n) const
+  {
+    return (*array_)[index_ + n];
+  }
+
+  // Non-member operator+ (allows n + iterator syntax)
+  template<typename Array_Ptr_T, typename Value_T>
+  inline Array::Iterator<Array_Ptr_T, Value_T> operator+(
+    long n,
+    Array::Iterator<Array_Ptr_T, Value_T> const& it)
+  {
+    return it + n;
+  }
+
   template<typename Array_Ptr_T, typename Value_T>
   Array_Ptr_T Array::Iterator<Array_Ptr_T, Value_T>::array() const
   {
@@ -267,7 +360,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -277,7 +370,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -286,7 +379,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -296,7 +389,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -305,7 +398,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -315,7 +408,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -324,11 +417,11 @@ 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)
     {
       switch (rb_type(value))
       {
@@ -344,6 +437,9 @@ namespace Rice::detail
     {
       return Array(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }
 #endif // Rice__Array__ipp_

data/rice/cpp_api/Class.hpp

@@ -24,8 +24,8 @@ namespace Rice
     Class & undef_creation_funcs();
 
     // Create a new instance
-    template<typename ...Arg_Ts>
-    Object create(Arg_Ts ...args);
+    template<typename ...Parameter_Ts>
+    Object create(Parameter_Ts ...args);
 
     //! Class name
     /*! \return std::string.

data/rice/cpp_api/Class.ipp

@@ -13,8 +13,8 @@ namespace Rice
     return *this;
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Class::create(Arg_Ts ...args)
+  template<typename ...Parameter_Ts>
+  inline Object Class::create(Parameter_Ts ...args)
   {
     return this->call("new", args...);
   }
@@ -91,7 +91,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -101,7 +101,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>

data/rice/cpp_api/Hash.ipp

@@ -234,7 +234,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -244,7 +244,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -253,11 +253,11 @@ 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)
     {
       switch (rb_type(value))
       {
@@ -273,5 +273,8 @@ namespace Rice::detail
     {
       return Hash(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/Module.hpp

@@ -49,11 +49,11 @@ namespace Rice
 
     #include "shared_methods.hpp"
   protected:
-    template<typename Function_T>
-    void wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+    template<typename Function_T, typename ...Arg_Ts>
+    void wrap_native_function(VALUE klass, std::string name, Function_T&& function, const Arg_Ts&...args);
 
-    template<typename Class_T = VALUE, typename Method_T>
-    void wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo);
+    template<typename Class_T = VALUE, typename Method_T, typename ...Arg_Ts>
+    void wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args);
   };
 
   //! Define a new module in the namespace given by module.

data/rice/cpp_api/Module.ipp

@@ -32,16 +32,18 @@ namespace Rice
     this->set_value(result);
   }
 
-  template<typename Function_T>
-  inline void Module::wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo)
+  template<typename Function_T, typename ...Arg_Ts>
+  inline void Module::wrap_native_function(VALUE klass, std::string name, Function_T&& function, const Arg_Ts&...args)
   {
-    detail::NativeFunction<Function_T>::define(klass, name, std::forward<Function_T>(function), methodInfo);
+    constexpr bool isNoGVL = detail::tuple_element_index_v<std::tuple<Arg_Ts...>, NoGVL> < (sizeof...(Arg_Ts));
+    detail::NativeFunction<Function_T, isNoGVL>::define(klass, name, std::forward<Function_T>(function), args...);
   }
 
-  template<typename Class_T, typename Method_T>
-  inline void Module::wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo)
+  template<typename Class_T, typename Method_T, typename ...Arg_Ts>
+  inline void Module::wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args)
   {
-    detail::NativeMethod<Class_T, Method_T>::define(klass, name, std::forward<Method_T>(method), methodInfo);
+    constexpr bool isNoGVL = detail::tuple_element_index_v<std::tuple<Arg_Ts...>, NoGVL> < (sizeof...(Arg_Ts));
+    detail::NativeMethod<Class_T, Method_T, isNoGVL>::define(klass, name, std::forward<Method_T>(method), args...);
   }
 
   inline Module define_module_under(Object parent, char const* name)
@@ -94,7 +96,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -104,7 +106,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
 
@@ -114,7 +116,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -124,7 +126,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>

data/rice/cpp_api/Object.hpp

@@ -181,8 +181,8 @@ namespace Rice
     *    float ret = x.call<float>("foo", z, 42);
     *  \endcode
     */
-    template<typename ...Arg_Ts>
-    Object call(Identifier id, Arg_Ts... args) const;
+    template<typename ...Parameter_Ts>
+    Object call(Identifier id, Parameter_Ts... args) const;
 
     //! Call the Ruby method specified by 'id' on object 'obj'.
     /*! Pass in arguments (arg1, arg2, ...).  The arguments will be converted to
@@ -204,8 +204,8 @@ namespace Rice
     *    float ret = x.call_kw<float>("foo", kw);
     *  \endcode
     */
-    template<typename ...Arg_Ts>
-    Object call_kw(Identifier id, Arg_Ts... args) const;
+    template<typename ...Parameter_Ts>
+    Object call_kw(Identifier id, Parameter_Ts... args) const;
 
     //! Vectorized call.
     /*! Calls the method identified by id with the list of arguments

data/rice/cpp_api/Object.ipp

@@ -27,8 +27,8 @@ namespace Rice
     return *this;
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Object::call(Identifier id, Arg_Ts... args) const
+  template<typename ...Parameter_Ts>
+  inline Object Object::call(Identifier id, Parameter_Ts... args) const
   {
     /* IMPORTANT - We store VALUEs in an array that is a local variable.
        That allows the Ruby garbage collector to find them when scanning
@@ -37,15 +37,15 @@ namespace Rice
        to the destination method resulting in a segmentation fault. This is
        easy to duplicate by setting GC.stress to true and calling a constructor
        that takes multiple values like a std::pair wrapper. */
-    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>().convert(std::forward<Arg_Ts>(args))... };
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(std::forward<Parameter_Ts>(args))... };
     return detail::protect(rb_funcallv, value(), id.id(), (int)values.size(), (const VALUE*)values.data());
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Object::call_kw(Identifier id, Arg_Ts... args) const
+  template<typename ...Parameter_Ts>
+  inline Object Object::call_kw(Identifier id, Parameter_Ts... args) const
   {
     /* IMPORTANT - See call() above */
-    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>().convert(args)... };
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(args)... };
     return detail::protect(rb_funcallv_kw, value(), id.id(), (int)values.size(), (const VALUE*)values.data(), RB_PASS_KEYWORDS);
   }
 
@@ -202,7 +202,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -212,7 +212,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -221,7 +221,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -231,7 +231,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -240,11 +240,11 @@ 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)
     {
       switch (rb_type(value))
       {
@@ -260,5 +260,8 @@ namespace Rice::detail
     {
       return Object(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/String.hpp

@@ -38,8 +38,8 @@ namespace Rice
     String(std::string_view const& s);
 
     //! Format a string using printf-style formatting.
-    template <typename... Arg_Ts>
-    static inline String format(char const* fmt, Arg_Ts&&...args);
+    template <typename... Parameter_Ts>
+    static inline String format(char const* fmt, Parameter_Ts&&...args);
 
     //! Get the length of the String.
     /*! \return the length of the string.

data/rice/cpp_api/String.ipp

@@ -28,16 +28,16 @@ namespace Rice
   {
   }
 
-  template <typename... Arg_Ts>
-  inline String String::format(char const* fmt, Arg_Ts&&...args)
+  template <typename... Parameter_Ts>
+  inline String String::format(char const* fmt, Parameter_Ts&&...args)
   {
-    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Arg_Ts>(args)...);
+    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Parameter_Ts>(args)...);
     std::string temp(size, '\0');
 
     // size+1 avoids truncating the string. Otherwise snprintf writes n - 1 characters
     // to allow space for null character but we don't need that since std::string
     // will add a null character internally at n + 1
-    std::snprintf(&temp[0], size + 1, fmt, std::forward<Arg_Ts>(args)...);
+    std::snprintf(&temp[0], size + 1, fmt, std::forward<Parameter_Ts>(args)...);
 
     String s = String(temp.c_str());
     return s;
@@ -97,7 +97,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -107,7 +107,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -116,11 +116,11 @@ 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)
     {
       switch (rb_type(value))
       {
@@ -136,5 +136,8 @@ namespace Rice::detail
     {
       return String(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/Symbol.ipp

@@ -67,7 +67,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -77,7 +77,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
 
@@ -87,7 +87,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -97,22 +97,28 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
   class From_Ruby<Symbol>
   {
   public:
-    Convertible is_convertible(VALUE value)
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_SYMBOL:
           return Convertible::Exact;
           break;
-      case RUBY_T_STRING:
-          return Convertible::Cast;
+        case RUBY_T_STRING:
+          return Convertible::Exact;
           break;
         default:
           return Convertible::None;
@@ -123,5 +129,8 @@ namespace Rice::detail
     {
       return Symbol(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/shared_methods.hpp

@@ -33,8 +33,7 @@ inline auto& include_module(Module const& inc)
 template<typename Method_T, typename...Arg_Ts>
 inline auto& define_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
-  this->wrap_native_method(this->value(), name, std::forward<Method_T>(method), methodInfo);
+  this->wrap_native_method(this->value(), name, std::forward<Method_T>(method), args...);
   return *this;
 }
 
@@ -52,8 +51,7 @@ inline auto& define_method(std::string name, Method_T&& method, const Arg_Ts&...
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
-  this->wrap_native_function(this->value(), name, std::forward<Function_T>(func), methodInfo);
+  this->wrap_native_function(this->value(), name, std::forward<Function_T>(func), args...);
   return *this;
 }
 
@@ -75,8 +73,7 @@ inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&.
 template<typename Method_T, typename...Arg_Ts>
 inline auto& define_singleton_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
-  this->wrap_native_method(rb_singleton_class(*this), name, std::forward<Method_T>(method), methodInfo);
+  this->wrap_native_method(rb_singleton_class(*this), name, std::forward<Method_T>(method), args...);
   return *this;
 }
 
@@ -94,8 +91,7 @@ inline auto& define_singleton_method(std::string name, Method_T&& method, const
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_singleton_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
-  this->wrap_native_function(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
+  this->wrap_native_function(rb_singleton_class(*this), name, std::forward<Function_T>(func), args...);
   return *this;
 }
 
@@ -112,7 +108,7 @@ inline auto& define_singleton_function(std::string name, Function_T&& func, cons
  *  \return *this
  */
 template<typename Function_T, typename...Arg_Ts>
-inline auto& define_module_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
+inline auto& define_module_function(std::string name, Function_T&& func, Arg_Ts&& ...args)
 {
   if (this->rb_type() != T_MODULE)
   {

data/rice/detail/InstanceRegistry.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__detail__InstanceRegistry__hpp_
 #define Rice__detail__InstanceRegistry__hpp_
 
-#include <map>
-
 namespace Rice::detail
 {
   class InstanceRegistry