rice 4.7.1 → 4.8.0

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

@@ -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_

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<>