rice 4.7.0 → 4.8.0

data/rice/Data_Type.ipp

@@ -20,13 +20,13 @@ namespace Rice
   }
 
   template<typename T>
-  inline size_t ruby_size_internal(const T* data)
+  inline size_t ruby_size_internal(const T*)
   {
     return sizeof(T);
   }
 
   template<>
-  inline size_t ruby_size_internal(const void* data)
+  inline size_t ruby_size_internal(const void*)
   {
     return sizeof(void*);
   }
@@ -37,8 +37,8 @@ namespace Rice
   {
     if (is_bound())
     {
-      detail::TypeMapper<T> typeMapper;
-      std::string message = "Type " + typeMapper.name() + " is already bound to a different type";
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+      std::string message = "Type " + typeIndexParser.name() + " is already bound to a different type";
       throw std::runtime_error(message.c_str());
     }
 
@@ -69,10 +69,10 @@ namespace Rice
 
     // Add a method to get the source C++ class name from Ruby
     Data_Type<T> dataType;
-    dataType.define_singleton_method("cpp_class", [](VALUE klass) -> VALUE
+    dataType.define_singleton_method("cpp_class", [](VALUE) -> VALUE
     {
-      detail::TypeMapper<T> typeMapper;
-      std::string cppClassName = typeMapper.simplifiedName();
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+      std::string cppClassName = typeIndexParser.simplifiedName();
       Return returnInfo;
       returnInfo.takeOwnership();
       return detail::To_Ruby<char*>(&returnInfo).convert(cppClassName.c_str());
@@ -148,7 +148,7 @@ namespace Rice
 
   template<typename T>
   template<typename Constructor_T, typename...Rice_Arg_Ts>
-  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T constructor, Rice_Arg_Ts const& ...args)
+  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T, Rice_Arg_Ts const& ...args)
   {
     check_is_bound();
 
@@ -187,9 +187,6 @@ namespace Rice
   template<typename Function_T>
   inline Data_Type<T>& Data_Type<T>::define(Function_T func)
   {
-    // The passed in this pointer is an RValue, so we need to keep it alive by
-    // assigning it to a const lvalue
-    const auto& dummy = *this;
     func(*this);
     return *this;
   }
@@ -233,8 +230,8 @@ namespace Rice
   {
     if (!is_bound())
     {
-      detail::TypeMapper<T> typeMapper;
-      std::string message = "Type is not defined with Rice: " + typeMapper.name();
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+      std::string message = "Type is not defined with Rice: " + typeIndexParser.name();
       throw std::invalid_argument(message.c_str());
     }
   }
@@ -330,30 +327,30 @@ namespace Rice
   }
 
   template <typename T>
-  template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
+  template <typename Attribute_T, typename...Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args)
   {
-    return this->define_attr_internal<Attribute_T>(this->klass_, name, std::forward<Attribute_T>(attribute), access, returnInfo);
+    return this->define_attr_internal<Attribute_T>(this->klass_, name, std::forward<Attribute_T>(attribute), access, args...);
   }
 
   template <typename T>
-  template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
+  template <typename Attribute_T, typename...Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args)
   {
     VALUE singleton = detail::protect(rb_singleton_class, this->value());
-    return this->define_attr_internal<Attribute_T>(singleton, name, std::forward<Attribute_T>(attribute), access, returnInfo);
+    return this->define_attr_internal<Attribute_T>(singleton, name, std::forward<Attribute_T>(attribute), access, args...);
   }
 
   template <typename T>
-  template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
+  template <typename Attribute_T, typename...Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args)
   {
     using Attr_T = typename detail::attribute_traits<Attribute_T>::attr_type;
 
     // Define attribute getter
     if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
     {
-      detail::NativeAttributeGet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute), returnInfo);
+      detail::NativeAttributeGet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute), args...);
     }
 
     // Define attribute setter
@@ -391,9 +388,9 @@ namespace Rice
   }
 
   template <typename T>
-  template<typename Method_T>
-  inline void Data_Type<T>::wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo)
+  template<typename Method_T, typename ...Arg_Ts>
+  inline void Data_Type<T>::wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args)
   {
-    Module::wrap_native_method<T, Method_T>(klass, name, std::forward<Method_T>(method), methodInfo);
+    Module::wrap_native_method<T, Method_T>(klass, name, std::forward<Method_T>(method), args...);
   }
 }

data/rice/Director.hpp

@@ -23,6 +23,7 @@ namespace Rice
       /*! If a Ruby script calls 'super' on a method that's otherwise a pure virtual
        *  method, use this method to throw an exception in this case.
        */
+      [[noreturn]]
       void raisePureVirtual() const
       {
         rb_raise(rb_eNotImpError, "Cannot call super() into a pure-virtual C++ method");

data/rice/Enum.ipp

@@ -29,48 +29,52 @@ namespace Rice
     klass.define_constructor(Constructor<Enum_T>());
 
     klass.define_method("to_s", [](Enum_T& self) -> String
-      {
-        return String(valuesToNames_[self]);
-      })
-      .define_method("to_int", [](Enum_T& self) ->  Underlying_T
-      {
-        return (Underlying_T)(self);
-      })
-      .define_method("coerce", [](Enum_T& self, Underlying_T& other) -> Array
-      {
-        /* Other will be a numeric value that matches the underlying type of the enum, for example an int.
-           Convert that to the enum type and then create new Ruby object to wrap it. This then enables code
-           like this:
+    {
+      return String(valuesToNames_[self]);
+    })
+    .define_method("to_int", [](Enum_T& self) ->  Underlying_T
+    {
+      return (Underlying_T)(self);
+    })
+    .define_method("coerce", [](Enum_T& self, Underlying_T& other) -> Array
+    {
+      /* Other will be a numeric value that matches the underlying type of the enum, for example an int.
+          Convert that to the enum type and then create new Ruby object to wrap it. This then enables code
+          like this:
         
-           Colors::Red | Colors:Blue | Colors:Green
+          Colors::Red | Colors:Blue | Colors:Green
 
-        Colors::Red | Colors:Blue returns an integer. Then this method converts the integer back into an Enum
-        instance so that Colors:Blue | Colors:Green works. */
-        Enum_T otherEnum = (Enum_T)other;
+      Colors::Red | Colors:Blue returns an integer. Then this method converts the integer back into an Enum
+      instance so that Colors:Blue | Colors:Green works. */
+      Enum_T otherEnum = (Enum_T)other;
 
-        Array result;
-        result.push(self, false);
-        result.push(otherEnum, true);
-        return result;
-      })
-      .define_method("inspect", [](Enum_T& self)
-      {
-        std::stringstream result;
-        VALUE rubyKlass = Enum<Enum_T>::klass().value();
-        result << "#<" << detail::protect(rb_class2name, rubyKlass)
-          << "::" << Enum<Enum_T>::valuesToNames_[self] << ">";
-
-        // We have to return string because we don't know if std::string support has
-        // been included by the user
-        return String(result.str());
-      })
-      .define_method("hash", [](Enum_T& self) ->  Underlying_T
-      {
-        return (Underlying_T)self;
-      })
-      .define_method("eql?", [](Enum_T& self, Enum_T& other)
-      {
-        return self == other;
+      Array result;
+      result.push(otherEnum, true);
+      result.push(self, false);
+      return result;
+    })
+    .define_method("inspect", [](Enum_T& self)
+    {
+      std::stringstream result;
+      VALUE rubyKlass = Enum<Enum_T>::klass().value();
+      result << "#<" << detail::protect(rb_class2name, rubyKlass)
+        << "::" << Enum<Enum_T>::valuesToNames_[self] << ">";
+
+      // We have to return string because we don't know if std::string support has
+      // been included by the user
+      return String(result.str());
+    })
+    .define_method("hash", [](Enum_T& self) ->  Underlying_T
+    {
+      return (Underlying_T)self;
+    })
+    .define_method("eql?", [](Enum_T& self, Enum_T& other)
+    {
+      return self == other;
+    })
+    .define_method("eql?", [](Enum_T& self, Underlying_T& other)
+    {
+      return self == (Enum_T)other;
     });
 
     // Add aliases
@@ -93,6 +97,21 @@ namespace Rice
         {
           return 1;
         }
+      })
+      .define_method("<=>", [](Enum_T& self, Underlying_T& other)
+      {
+        if (self == (Enum_T)other)
+        {
+          return 0;
+        }
+        else if (self < (Enum_T)other)
+        {
+          return -1;
+        }
+        else
+        {
+          return 1;
+        }
       });
 
     // Add ability to get enum values

data/rice/Exception.hpp

@@ -28,8 +28,8 @@ namespace Rice
      *  \param fmt a printf-style format string
      *  \param ... the arguments to the format string.
      */
-    template <typename... Arg_Ts>
-    Exception(const Exception& other, char const* fmt, Arg_Ts&&...args);
+    template <typename... Parameter_Ts>
+    Exception(const Exception& other, char const* fmt, Parameter_Ts&&...args);
 
     //! Construct a Exception with printf-style formatting.
     /*! \param exc either an exception object or a class that inherits
@@ -37,8 +37,8 @@ namespace Rice
      *  \param fmt a printf-style format string
      *  \param ... the arguments to the format string.
      */
-    template <typename... Arg_Ts>
-    Exception(const VALUE exceptionType, char const* fmt, Arg_Ts&&...args);
+    template <typename... Parameter_Ts>
+    Exception(const VALUE exceptionType, char const* fmt, Parameter_Ts&&...args);
 
     //! Destructor
     virtual ~Exception() noexcept = default;

data/rice/Exception.ipp

@@ -5,27 +5,27 @@ namespace Rice
   {
   }
 
-  template <typename... Arg_Ts>
-  inline Exception::Exception(const Exception& other, char const* fmt, Arg_Ts&&...args)
-    : Exception(other.class_of(), fmt, std::forward<Arg_Ts>(args)...)
+  template <typename... Parameter_Ts>
+  inline Exception::Exception(const Exception& other, char const* fmt, Parameter_Ts&&...args)
+    : Exception(other.class_of(), fmt, std::forward<Parameter_Ts>(args)...)
   {
   }
 
-  template <typename... Arg_Ts>
-  inline Exception::Exception(const VALUE exceptionClass, char const* fmt, Arg_Ts&&...args)
+  template <typename... Parameter_Ts>
+  inline Exception::Exception(const VALUE exceptionClass, char const* fmt, Parameter_Ts&&...args)
   {
     #if defined(__GNUC__) || defined(__clang__)
     #pragma GCC diagnostic push
     #pragma GCC diagnostic ignored "-Wformat-security"
     #endif
 
-    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)...);
     this->message_ = std::string(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(&this->message_[0], size + 1, fmt, std::forward<Arg_Ts>(args)...);
+    std::snprintf(&this->message_[0], size + 1, fmt, std::forward<Parameter_Ts>(args)...);
 
     #if defined(__GNUC__) || defined(__clang__)
     #pragma GCC diagnostic pop

data/rice/NoGVL.hpp

@@ -0,0 +1,13 @@
+#ifndef Rice__NoGVL__hpp_
+#define Rice__NoGVL__hpp_
+
+namespace Rice
+{
+  class NoGVL
+  {
+  public:
+    NoGVL() = default;
+  };
+} // Rice
+
+#endif // Rice__NoGVL__hpp_

data/rice/Reference.hpp

@@ -0,0 +1,56 @@
+#ifndef Rice__Reference__hpp_
+#define Rice__Reference__hpp_
+
+namespace Rice
+{
+  template<typename T>
+  class Reference
+  {
+    static_assert(!detail::is_wrapped_v<detail::intrinsic_type<T>>,
+      "Reference can only be used with fundamental types");
+
+  public:
+    Reference();
+    Reference(T& data);
+    Reference(VALUE value);
+    T& get();
+
+  private:
+    T data_;
+  };
+
+  // Specialization needed when VALUE type matches T, causing constructor ambiguity
+  // between Reference(T&) and Reference(VALUE). VALUE is unsigned long when
+  // SIZEOF_LONG == SIZEOF_VOIDP (Linux/macOS) and unsigned long long when
+  // SIZEOF_LONG_LONG == SIZEOF_VOIDP (Windows x64).
+#if SIZEOF_LONG == SIZEOF_VOIDP
+  template<>
+  class Reference<unsigned long>
+  {
+  public:
+    Reference();
+    Reference(unsigned long value, bool isValue = true);
+    unsigned long& get();
+
+  private:
+    unsigned long data_;
+  };
+#else
+  template<>
+  class Reference<unsigned long long>
+  {
+  public:
+    Reference();
+    Reference(unsigned long long value, bool isValue = true);
+    unsigned long long& get();
+
+  private:
+    unsigned long long data_;
+  };
+#endif
+
+  template<typename T>
+  Data_Type<Reference<T>> define_reference(std::string klassName = "");
+}
+
+#endif // Rice__Reference__hpp_

data/rice/Reference.ipp

@@ -0,0 +1,96 @@
+namespace Rice
+{
+  template<typename T>
+  inline Reference<T>::Reference() : data_{}
+  {
+  }
+
+  template<typename T>
+  inline Reference<T>::Reference(T& data) : data_(data)
+  {
+  }
+
+  template<typename T>
+  inline Reference<T>::Reference(VALUE value) : data_(detail::FromRubyFundamental<T>::convert(value))
+  {
+  }
+
+  template<typename T>
+  inline T& Reference<T>::get()
+  {
+    return data_;
+  }
+
+  // Specialization implementations - only one is compiled per platform
+#if SIZEOF_LONG == SIZEOF_VOIDP
+  // VALUE is unsigned long on Linux/macOS
+  inline Reference<unsigned long>::Reference() : data_{}
+  {
+  }
+
+  inline Reference<unsigned long>::Reference(unsigned long value, bool isValue) :
+    data_(isValue ? detail::FromRubyFundamental<unsigned long>::convert(value) : value)
+  {
+  }
+
+  inline unsigned long& Reference<unsigned long>::get()
+  {
+    return data_;
+  }
+#else
+  // VALUE is unsigned long long on Windows x64
+  inline Reference<unsigned long long>::Reference() : data_{}
+  {
+  }
+
+  inline Reference<unsigned long long>::Reference(unsigned long long value, bool isValue) :
+    data_(isValue ? detail::FromRubyFundamental<unsigned long long>::convert(value) : value)
+  {
+  }
+
+  inline unsigned long long& Reference<unsigned long long>::get()
+  {
+    return data_;
+  }
+#endif
+
+  template<typename T>
+  inline Data_Type<Reference<T>> define_reference(std::string klassName)
+  {
+    using Reference_T = Reference<T>;
+    using Data_Type_T = Data_Type<Reference_T>;
+
+    if (klassName.empty())
+    {
+      detail::TypeMapper<Reference_T> typeMapper;
+      klassName = typeMapper.rubyName();
+    }
+
+    Module rb_mRice = define_module("Rice");
+
+    if (Data_Type_T::check_defined(klassName, rb_mRice))
+    {
+      return Data_Type_T();
+    }
+
+    Data_Type<Reference<T>> result = define_class_under<Reference_T>(rb_mRice, klassName).
+      define_constructor(Constructor<Reference_T, T>()).
+      define_method("value", &Reference_T::get);
+
+    return result;
+  }
+}
+
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<Reference<T>>
+  {
+    static bool verify()
+    {
+      detail::verifyType<T>();
+      define_reference<T>();
+      return true;
+    }
+  };
+}

data/rice/Return.hpp

@@ -13,7 +13,10 @@ namespace Rice
     Return& setValue() override;
     Return& setOpaque() override;
     Return& takeOwnership() override;
-    Return& setBuffer() override;
+  };
+
+  class ReturnBuffer : public Return
+  {
   };
 } // Rice
 

data/rice/Return.ipp

@@ -29,10 +29,4 @@ namespace Rice
     Arg::takeOwnership();
     return *this;
   }
-
-  inline Return& Return::setBuffer()
-  {
-    Arg::setBuffer();
-    return *this;
-  }
 }  // Rice

data/rice/cpp_api/Array.hpp

@@ -12,8 +12,8 @@ namespace Rice
    *  Example:
    *  \code
    *    Array a;
-   *    a.push(String("some string"));
-   *    a.push(42);
+   *    a.push(String("some string"), false);
+   *    a.push(42, false);
    *  \endcode
    */
   class Array
@@ -92,7 +92,7 @@ namespace Rice
      *  \return the object which was pushed onto the array.
      */
     template<typename T>
-    Object push(T&& obj, bool takeOwnership);
+    Object push(T&& obj, bool takeOwnership = false);
 
     //! Pop an element from the end of the array
     /*! \return the object which was popped from the array, or Qnil if
@@ -116,6 +116,12 @@ namespace Rice
     template<typename Array_Ptr_T, typename Value_T>
     class Iterator;
 
+    // Friend declaration for non-member operator+
+    template<typename Array_Ptr_T, typename Value_T>
+    friend Iterator<Array_Ptr_T, Value_T> operator+(
+      long n,
+      Iterator<Array_Ptr_T, Value_T> const& it);
+
     long position_of(long index) const;
 
   public:
@@ -164,13 +170,12 @@ namespace Rice
     long index_;
   };
 
-  //! A helper class for implementing iterators for a Array.
-  // TODO: This really should be a random-access iterator.
+  //! A random-access iterator for Array.
   template<typename Array_Ptr_T, typename Value_T>
   class Array::Iterator
   {
   public:
-    using iterator_category = std::forward_iterator_tag;
+    using iterator_category = std::random_access_iterator_tag;
     using value_type = Value_T;
     using difference_type = long;
     using pointer = Object*;
@@ -184,17 +189,43 @@ namespace Rice
     template<typename Array_Ptr_T_, typename Value_T_>
     Iterator& operator=(Iterator<Array_Ptr_T_, Value_T_> const& rhs);
 
+    // Forward iterator operations
     Iterator& operator++();
     Iterator operator++(int);
-    Value_T operator*();
+    Value_T operator*() const;
     Object* operator->();
 
+    // Bidirectional iterator operations
+    Iterator& operator--();
+    Iterator operator--(int);
+
+    // Random access iterator operations
+    Iterator& operator+=(difference_type n);
+    Iterator& operator-=(difference_type n);
+    Iterator operator+(difference_type n) const;
+    Iterator operator-(difference_type n) const;
+    difference_type operator-(Iterator const& rhs) const;
+    Value_T operator[](difference_type n) const;
+
+    // Comparison operators
     template<typename Array_Ptr_T_, typename Value_T_>
     bool operator==(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
 
     template<typename Array_Ptr_T_, typename Value_T_>
     bool operator!=(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
 
+    template<typename Array_Ptr_T_, typename Value_T_>
+    bool operator<(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
+
+    template<typename Array_Ptr_T_, typename Value_T_>
+    bool operator>(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
+
+    template<typename Array_Ptr_T_, typename Value_T_>
+    bool operator<=(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
+
+    template<typename Array_Ptr_T_, typename Value_T_>
+    bool operator>=(Iterator<Array_Ptr_T_, Value_T_> const& rhs) const;
+
     Array_Ptr_T array() const;
     long index() const;
 
@@ -204,6 +235,12 @@ namespace Rice
 
     Object tmp_;
   };
+
+  // Non-member operator+ for n + iterator (allows n + iterator syntax)
+  template<typename Array_Ptr_T, typename Value_T>
+  Array::Iterator<Array_Ptr_T, Value_T> operator+(
+    long n,
+    Array::Iterator<Array_Ptr_T, Value_T> const& it);
 } // namespace Rice
 
 #endif // Rice__Array__hpp_