rice 4.11.1 → 4.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 935f187922d58bf0dc585e30ae66b5454bb8f87ac8c640ca38d9445371991dff
-  data.tar.gz: d00d336620c52f7e3a56941d6402109bcc20d3a73dc4090fd3d49395cbbdc7e7
+  metadata.gz: 2b52ff5ddc64209e1c252d529111695d833a57d1362e15b6d223777194dc6750
+  data.tar.gz: 214c2b675683e68d026440cc83499a7de0faa6282563c0bfa028c925e677f195
 SHA512:
-  metadata.gz: 9c006c97da6e586d836a08b51c2d1ed37e8921e11f0dc30f45d3fcfeb5166ae5172610b958e0b9fe35a8eddb199af05b88eec1bf272541b7a39d890b0856bacf
-  data.tar.gz: 7795809caf1d34330279d5fb454cb935b08422b531522d721d4ba3185442426d51fd1f8795dfbbbb34daff9a19d586e0e5554925d69eed7d57aebcbba9017a6a
+  metadata.gz: fdee833532115137ec7e375e83e377c5e21a634b44e0b67bb5954ea3ad04a2983ef3c6ffc5d5deb804b1d94c7b76f04d2cc94b73b054aaa0722f01fd39f58c37
+  data.tar.gz: 23e9990bbf398a067608c29028018840506254f3a8a00a7f6cc56840ec88e70007d0309656b297b20ab31776805b3deccb14e16fface820b0ec7d3340aafc0f3

data/CHANGELOG.md

@@ -1,12 +1,38 @@
 # Changelog
 
+## 4.11.3 (2026-03-11)
+
+### Bug Fixes
+
+* Fix C++20 compilation error with `std::ostringstream::str` overload (#395)
+* Add `function_traits` specializations for ref-qualified member functions (`&`, `const&`)
+
+### Enhancements
+
+* Support C++20 and C++23 compilation
+* Make C++ standard version configurable via `--with-cxx-standard` in mkmf-rice
+* Add `/Zc:__cplusplus` to MSVC build flags
+* Add CMake-based CI job testing C++17, C++20, and C++23
+* Add test case for function pointer struct attributes
+* Add support for `std::shared_ptr<const T>`
+* Add support for `std::unique_ptr<const T>`
+* Add support for non-constructible objects in std::pair, std::map, std::multimap
+* Add support for wrapping pointers to abstract types that cannot be created nor destroyed
+* Fix converting std::nullptr_t to Ruby
+
+## 4.11.2 (2026-02-21)
+
+### Enhancements
+
+* Add support for `long double`
+* Improve support for references to incomplete types
+
 ## 4.11.1 (2026-02-18)
 
 ### Enhancements
 
 * Be more lenient on wrapp Qnil values in the C++ API
 
-
 ## 4.11.0 (2026-02-17)
 
 This release focuses on improving memory management.

data/CMakePresets.json

@@ -116,7 +116,7 @@
       "toolchainFile": "$env{VCPKG_ROOT}\\scripts\\buildsystems\\vcpkg.cmake",
       "cacheVariables": {
         "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE"
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /Zc:__cplusplus /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE"
       },
       "condition": {
         "type": "equals",
@@ -155,7 +155,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_COMPILER": "clang-cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /Zc:__cplusplus /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
         "CMAKE_CXX_FLAGS_DEBUG": "/Od /Zi"
       }
     },
@@ -166,7 +166,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
         "CMAKE_CXX_COMPILER": "clang-cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /Zc:__cplusplus /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
         "CMAKE_CXX_FLAGS_RELEASE": "/O2 /DNDEBUG",
         "CMAKE_INTERPROCEDURAL_OPTIMIZATION": "ON"
       }

data/include/rice/rice.hpp

@@ -556,6 +556,27 @@ namespace Rice::detail
   {
   };
 
+  // ref-qualified member Functions on C++ classes (C++20 uses these for std library types)
+  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...)>
+  {
+  };
+
+  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...)>
+  {
+  };
+
+  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...)>
+  {
+  };
+
+  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...)>
+  {
+  };
+
   /*// Functors and lambdas
   template<class Function_T>
   struct function_traits<Function_T&> : public function_traits<Function_T>
@@ -3797,6 +3818,17 @@ namespace Rice::detail
     static inline std::string name = "Float";
   };
 
+  template<>
+  class RubyType<long double>
+  {
+  public:
+    using FromRuby_T = double(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2dbl;
+    static inline std::string packTemplate = "d*";
+    static inline std::string name = "Float";
+  };
+
   template<>
   class RubyType<void>
   {
@@ -6073,6 +6105,35 @@ namespace Rice::detail
     }
   };
 
+  template<>
+  struct Type<long double>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cFloat;
+    }
+  };
+
+  template<int N>
+  struct Type<long double[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<long double>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
   template<>
   struct Type<void>
   {
@@ -6601,6 +6662,62 @@ namespace Rice
       Arg* arg_ = nullptr;
     };
 
+    // ===========  long double  ============
+    template<>
+    class To_Ruby<long double>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {}
+
+      VALUE convert(const long double& native)
+      {
+        return protect(rb_float_new, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<long double&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {}
+
+      VALUE convert(const long double& native)
+      {
+        return protect(rb_float_new, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<long double[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {}
+
+      VALUE convert(long double data[N])
+      {
+        Buffer<long double> buffer(data, N);
+        Data_Object<Buffer<long double>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     // ===========  float  ============
     template<>
     class To_Ruby<float>
@@ -7879,6 +7996,86 @@ namespace Rice::detail
     Reference<double> reference_;
   };
 
+  // ===========  long double  ============
+  template<>
+  class From_Ruby<long double>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {}
+
+    long double is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<long double>::is_convertible(value);
+    }
+
+    long double convert(VALUE value)
+    {
+      return FromRubyFundamental<long double>::convert(value);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<long double&>
+  {
+  public:
+    using Reference_T = Reference<long double>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {}
+
+    long double is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Reference_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<long double>::is_convertible(value);
+        }
+      }
+    }
+
+    long double& convert(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Reference_T>::is_descendant(value))
+          {
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->reference_ = Reference<long double>(value);
+          return this->reference_.get();
+        }
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    Reference<long double> reference_;
+  };
+
   // ===========  float  ============
   template<>
   class From_Ruby<float>
@@ -8678,31 +8875,15 @@ namespace Rice::detail
       }
     }
 
-    void* convert(VALUE value)
+    std::nullptr_t convert(VALUE value)
     {
       if (value == Qnil)
       {
         return nullptr;
       }
 
-      if (this->arg_ && this->arg_->isOpaque())
-      {
-        return (void*)value;
-      }
-
-      switch (rb_type(value))
-      {
-        case RUBY_T_NIL:
-        {
-          return nullptr;
-          break;
-        }
-        default:
-        {
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
-            detail::protect(rb_obj_classname, value), "nil");
-        }
-      }
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+        detail::protect(rb_obj_classname, value), "nil");
     }
   private:
     Arg* arg_ = nullptr;
@@ -8973,6 +9154,12 @@ namespace Rice::detail
     {
       return std::type_index(typeid(T));
     }
+    else if constexpr (std::is_reference_v<T>)
+    {
+      // For incomplete reference types, strip the reference and use pointer.
+      // Can't form T* when T is a reference type (pointer-to-reference is illegal).
+      return std::type_index(typeid(std::remove_reference_t<T>*));
+    }
     else
     {
       return std::type_index(typeid(T*));
@@ -10095,7 +10282,9 @@ namespace Rice::detail
 
     if constexpr (is_complete_v<T>)
     {
-      if constexpr (std::is_destructible_v<T>)
+      // is_abstract_v requires a complete type, so nest inside is_complete_v.
+      // Deleting an abstract class through a non-virtual destructor is UB.
+      if constexpr (std::is_destructible_v<T> && !std::is_abstract_v<T>)
       {
         if (this->isOwner_)
         {
@@ -14845,8 +15034,6 @@ namespace Rice
   template <typename Attribute_T, typename Access_T, typename...Arg_Ts>
   inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, Access_T, const Arg_Ts&...args)
   {
-    using Attr_T = typename detail::attribute_traits<Attribute_T>::attr_type;
-
     // Define attribute getter
     if constexpr (std::is_same_v<Access_T, AttrAccess::ReadWriteType> || std::is_same_v<Access_T, AttrAccess::ReadType>)
     {

data/include/rice/stl.hpp

@@ -1133,8 +1133,12 @@ namespace Rice::stl
 
     void define_methods()
     {
+#if __cplusplus >= 202002L
+      klass_.define_method<std::string(std::ostringstream::*)() const&>("str", &std::ostringstream::str)
+#else
       klass_.define_method<std::string(std::ostringstream::*)() const>("str", &std::ostringstream::str)
-            .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
+#endif
+      .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
 
       rb_define_alias(klass_, "to_s", "str");
     }
@@ -1310,8 +1314,12 @@ namespace Rice
     private:
       void define_constructors()
       {
-        klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
+        if constexpr (std::is_default_constructible_v<T>)
+        {
+          klass_.define_constructor(Constructor<T>());
+        }
+
+        klass_.define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
 
         if constexpr (std::is_copy_constructible_v<First_T> && std::is_copy_constructible_v<Second_T>)
         {
@@ -1650,7 +1658,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              map[key] = value;
+              map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -1772,7 +1780,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }
@@ -3201,7 +3209,11 @@ namespace Rice
 
     if constexpr (detail::is_complete_v<T> && !std::is_void_v<T>)
     {
-      result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      // is_abstract_v requires a complete type, so it must be nested inside the is_complete_v check
+      if constexpr (!std::is_abstract_v<T>)
+      {
+        result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      }
     }
 
     // Forward methods to wrapped T
@@ -3256,7 +3268,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {
@@ -3931,7 +3943,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {
@@ -4171,7 +4183,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              unordered_map[key] = value;
+              unordered_map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -4293,7 +4305,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }

data/lib/mkmf-rice.rb

@@ -24,14 +24,16 @@ end
 # Now pull in the C++ support
 include MakeMakefile['C++']
 
-# Rice needs c++17.
+# Rice needs c++17 or higher. Use --with-cxx-standard=20 to override.
+std = with_config('cxx-standard', '17')
+
 if IS_MSWIN
-  $CXXFLAGS += " /std:c++17 /EHs /permissive- /bigobj /utf-8"
+  $CXXFLAGS += " /std:c++#{std} /EHs /permissive- /bigobj /utf-8 /Zc:__cplusplus"
   $CPPFLAGS += " -D_ALLOW_KEYWORD_MACROS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE"
 elsif IS_MINGW
-  $CXXFLAGS += " -std=c++17 -Wa,-mbig-obj"
+  $CXXFLAGS += " -std=c++#{std} -Wa,-mbig-obj"
 else
-  $CXXFLAGS += " -std=c++17"
+  $CXXFLAGS += " -std=c++#{std}"
 end
 
 # Rice needs to include its header. Let's setup the include path

data/lib/rice/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.11.1"
+  VERSION = "4.11.3"
 end

data/rice/Data_Type.ipp

@@ -376,8 +376,6 @@ namespace Rice
   template <typename Attribute_T, typename Access_T, typename...Arg_Ts>
   inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, Access_T, const Arg_Ts&...args)
   {
-    using Attr_T = typename detail::attribute_traits<Attribute_T>::attr_type;
-
     // Define attribute getter
     if constexpr (std::is_same_v<Access_T, AttrAccess::ReadWriteType> || std::is_same_v<Access_T, AttrAccess::ReadType>)
     {

data/rice/detail/RubyType.ipp

@@ -154,6 +154,17 @@ namespace Rice::detail
     static inline std::string name = "Float";
   };
 
+  template<>
+  class RubyType<long double>
+  {
+  public:
+    using FromRuby_T = double(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2dbl;
+    static inline std::string packTemplate = "d*";
+    static inline std::string name = "Float";
+  };
+
   template<>
   class RubyType<void>
   {

data/rice/detail/TypeRegistry.ipp

@@ -13,6 +13,12 @@ namespace Rice::detail
     {
       return std::type_index(typeid(T));
     }
+    else if constexpr (std::is_reference_v<T>)
+    {
+      // For incomplete reference types, strip the reference and use pointer.
+      // Can't form T* when T is a reference type (pointer-to-reference is illegal).
+      return std::type_index(typeid(std::remove_reference_t<T>*));
+    }
     else
     {
       return std::type_index(typeid(T*));

data/rice/detail/Types.ipp

@@ -404,6 +404,35 @@ namespace Rice::detail
     }
   };
 
+  template<>
+  struct Type<long double>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cFloat;
+    }
+  };
+
+  template<int N>
+  struct Type<long double[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<long double>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
   template<>
   struct Type<void>
   {

data/rice/detail/Wrapper.ipp

@@ -121,7 +121,9 @@ namespace Rice::detail
 
     if constexpr (is_complete_v<T>)
     {
-      if constexpr (std::is_destructible_v<T>)
+      // is_abstract_v requires a complete type, so nest inside is_complete_v.
+      // Deleting an abstract class through a non-virtual destructor is UB.
+      if constexpr (std::is_destructible_v<T> && !std::is_abstract_v<T>)
       {
         if (this->isOwner_)
         {

data/rice/detail/from_ruby.ipp

@@ -729,6 +729,86 @@ namespace Rice::detail
     Reference<double> reference_;
   };
 
+  // ===========  long double  ============
+  template<>
+  class From_Ruby<long double>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {}
+
+    long double is_convertible(VALUE value)
+    {
+      return FromRubyFundamental<long double>::is_convertible(value);
+    }
+
+    long double convert(VALUE value)
+    {
+      return FromRubyFundamental<long double>::convert(value);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<long double&>
+  {
+  public:
+    using Reference_T = Reference<long double>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {}
+
+    long double is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Reference_T>::is_descendant(value))
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          return FromRubyFundamental<long double>::is_convertible(value);
+        }
+      }
+    }
+
+    long double& convert(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Reference_T>::is_descendant(value))
+          {
+            Reference_T* reference = unwrap<Reference_T>(value, Data_Type<Reference_T>::ruby_data_type(), false);
+            return reference->get();
+          }
+          [[fallthrough]];
+        }
+        default:
+        {
+          this->reference_ = Reference<long double>(value);
+          return this->reference_.get();
+        }
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    Reference<long double> reference_;
+  };
+
   // ===========  float  ============
   template<>
   class From_Ruby<float>
@@ -1528,31 +1608,15 @@ namespace Rice::detail
       }
     }
 
-    void* convert(VALUE value)
+    std::nullptr_t convert(VALUE value)
     {
       if (value == Qnil)
       {
         return nullptr;
       }
 
-      if (this->arg_ && this->arg_->isOpaque())
-      {
-        return (void*)value;
-      }
-
-      switch (rb_type(value))
-      {
-        case RUBY_T_NIL:
-        {
-          return nullptr;
-          break;
-        }
-        default:
-        {
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
-            detail::protect(rb_obj_classname, value), "nil");
-        }
-      }
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+        detail::protect(rb_obj_classname, value), "nil");
     }
   private:
     Arg* arg_ = nullptr;

data/rice/detail/to_ruby.ipp

@@ -501,6 +501,62 @@ namespace Rice
       Arg* arg_ = nullptr;
     };
 
+    // ===========  long double  ============
+    template<>
+    class To_Ruby<long double>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {}
+
+      VALUE convert(const long double& native)
+      {
+        return protect(rb_float_new, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<>
+    class To_Ruby<long double&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {}
+
+      VALUE convert(const long double& native)
+      {
+        return protect(rb_float_new, native);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<int N>
+    class To_Ruby<long double[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {}
+
+      VALUE convert(long double data[N])
+      {
+        Buffer<long double> buffer(data, N);
+        Data_Object<Buffer<long double>> dataObject(std::move(buffer));
+        return dataObject.value();
+      }
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     // ===========  float  ============
     template<>
     class To_Ruby<float>

data/rice/stl/map.ipp

@@ -156,7 +156,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              map[key] = value;
+              map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -278,7 +278,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }

data/rice/stl/ostream.ipp

@@ -59,8 +59,12 @@ namespace Rice::stl
 
     void define_methods()
     {
+#if __cplusplus >= 202002L
+      klass_.define_method<std::string(std::ostringstream::*)() const&>("str", &std::ostringstream::str)
+#else
       klass_.define_method<std::string(std::ostringstream::*)() const>("str", &std::ostringstream::str)
-            .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
+#endif
+      .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
 
       rb_define_alias(klass_, "to_s", "str");
     }

data/rice/stl/pair.ipp

@@ -24,8 +24,12 @@ namespace Rice
     private:
       void define_constructors()
       {
-        klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
+        if constexpr (std::is_default_constructible_v<T>)
+        {
+          klass_.define_constructor(Constructor<T>());
+        }
+
+        klass_.define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
 
         if constexpr (std::is_copy_constructible_v<First_T> && std::is_copy_constructible_v<Second_T>)
         {

data/rice/stl/shared_ptr.ipp

@@ -32,7 +32,11 @@ namespace Rice
 
     if constexpr (detail::is_complete_v<T> && !std::is_void_v<T>)
     {
-      result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      // is_abstract_v requires a complete type, so it must be nested inside the is_complete_v check
+      if constexpr (!std::is_abstract_v<T>)
+      {
+        result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      }
     }
 
     // Forward methods to wrapped T
@@ -87,7 +91,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {

data/rice/stl/unique_ptr.ipp

@@ -83,7 +83,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {

data/rice/stl/unordered_map.ipp

@@ -156,7 +156,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              unordered_map[key] = value;
+              unordered_map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -278,7 +278,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }

data/rice/traits/function_traits.hpp

@@ -102,6 +102,27 @@ namespace Rice::detail
   {
   };
 
+  // ref-qualified member Functions on C++ classes (C++20 uses these for std library types)
+  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...)>
+  {
+  };
+
+  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...)>
+  {
+  };
+
+  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...)>
+  {
+  };
+
+  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...)>
+  {
+  };
+
   /*// Functors and lambdas
   template<class Function_T>
   struct function_traits<Function_T&> : public function_traits<Function_T>

data/test/test_Attribute.cpp

@@ -590,4 +590,35 @@ TESTCASE(KeepAlive)
   // This should work because keepAlive prevents MyClass2 from being GC'd
   ASSERT_NOT_EQUAL(nullptr, dataStruct->myClass2);
   ASSERT_EQUAL(43, dataStruct->myClass2->value);
+}
+
+namespace
+{
+  struct FuncPtrStruct
+  {
+    int (*callback)(int) = nullptr;
+  };
+}
+
+TESTCASE(function_pointer_attribute)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_class<FuncPtrStruct>("FuncPtrStruct")
+    .define_constructor(Constructor<FuncPtrStruct>())
+    .define_attr("callback", &FuncPtrStruct::callback);
+
+  Object o = c.call("new");
+
+  // Set the callback via Ruby using a lambda
+  std::string code = R"(struct = FuncPtrStruct.new
+                        struct.callback = lambda { |x| x * 2 }
+                        struct)";
+
+  Data_Object<FuncPtrStruct> funcPtrStruct = m.module_eval(code);
+
+  // Invoke the callback from C++ to verify it works
+  ASSERT_NOT_EQUAL(nullptr, funcPtrStruct->callback);
+  int result = funcPtrStruct->callback(5);
+  ASSERT_EQUAL(10, result);
 }

data/test/test_Callback.cpp

@@ -55,10 +55,8 @@ TESTCASE(LambdaCallBack)
   ASSERT((globalCallback != nullptr));
 
   int ref = 4;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wwrite-strings"
-  char* result = triggerCallback(1, 2, true, "hello", ref);
-#pragma GCC diagnostic pop
+  char hello[] = "hello";
+  char* result = triggerCallback(1, 2, true, hello, ref);
   ASSERT_EQUAL("1 - 2.0 - true - hello - 4", result);
 }
 

data/test/test_From_Ruby.cpp

@@ -615,3 +615,17 @@ TESTCASE(void_pointer_array)
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 }
+
+TESTCASE(nullptr_t)
+{
+  detail::From_Ruby<std::nullptr_t> fromRuby;
+
+  std::nullptr_t result = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(nullptr, result);
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    fromRuby.convert(rb_str_new2("not nil")),
+    ASSERT_EQUAL("wrong argument type String (expected nil)", ex.what())
+  );
+}

data/test/test_Stl_Map.cpp

@@ -365,6 +365,62 @@ TESTCASE(NotPrintable)
   ASSERT_EQUAL("[Not printable]", detail::From_Ruby<std::string>().convert(result));
 }
 
+namespace
+{
+  // Type with no default constructor - verifies insert_or_assign works in []=
+  class NoDefaultMap
+  {
+  public:
+    NoDefaultMap(int value) : value_(value) {}
+    int value() const { return value_; }
+
+    bool operator==(const NoDefaultMap& other) const
+    {
+      return this->value_ == other.value_;
+    }
+
+  private:
+    int value_;
+  };
+}
+
+TESTCASE(NoDefaultConstructor)
+{
+  define_class<NoDefaultMap>("NoDefaultMap").
+    define_constructor(Constructor<NoDefaultMap, int>(), Arg("value")).
+    define_method("value", &NoDefaultMap::value);
+
+  Class c = define_map<std::string, NoDefaultMap>("NoDefaultMap_Map");
+
+  Object map = c.call("new");
+
+  // Test []= (insert_or_assign) with non-default-constructible value
+  map.call("[]=", "one", NoDefaultMap(1));
+  map.call("[]=", "two", NoDefaultMap(2));
+
+  Object result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test [] access
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result.call("value")));
+
+  // Test update existing key
+  map.call("[]=", "one", NoDefaultMap(10));
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test delete
+  result = map.call("delete", "two");
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+}
+
 namespace
 {
   class Comparable

data/test/test_Stl_Pair.cpp

@@ -144,6 +144,38 @@ TESTCASE(AutoRegister)
   ASSERT(result.is_instance_of(pair.class_of()));
 }
 
+namespace
+{
+  // Type with no default constructor - like cv::detail::tracking::tbm::Track
+  class NoDefault
+  {
+  public:
+    NoDefault(int value) : value_(value) {}
+    int value() const { return value_; }
+  private:
+    int value_;
+  };
+}
+
+TESTCASE(PairNoDefaultConstructor)
+{
+  define_class<NoDefault>("NoDefault").
+    define_constructor(Constructor<NoDefault, int>(), Arg("value")).
+    define_method("value", &NoDefault::value);
+
+  // This should compile and work even though NoDefault has no default constructor.
+  // The pair's default constructor should be skipped, but the two-argument constructor should work.
+  Class c = define_pair<const int, NoDefault>("IntNoDefaultPair");
+
+  Object pair = c.call("new", 42, NoDefault(7));
+
+  Object result = pair.call("first");
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
+
+  result = pair.call("second");
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result.call("value")));
+}
+
 namespace
 {
   struct SomeStruct

data/test/test_Stl_SharedPtr.cpp

@@ -609,6 +609,99 @@ TESTCASE(InheritedForwarding)
   ASSERT_EQUAL(456, detail::From_Ruby<int>().convert(result));
 }
 
+// --- shared_ptr<const T> tests ---
+// When shared_ptr wraps a const T, the Wrapper::get() method must handle
+// the const-to-void* conversion. Without a cast, data_.get() returns
+// const T* which cannot implicitly convert to void*.
+namespace
+{
+  class ConstTarget
+  {
+  public:
+    int value;
+
+    ConstTarget() : value(0) {}
+    ConstTarget(int v) : value(v) {}
+
+    int getValue() const { return value; }
+  };
+
+  std::shared_ptr<const ConstTarget> createConstTarget(int v)
+  {
+    return std::make_shared<const ConstTarget>(v);
+  }
+
+  int extractConstTargetValue(std::shared_ptr<const ConstTarget> ptr)
+  {
+    return ptr->getValue();
+  }
+}
+
+TESTCASE(SharedPtrConstT)
+{
+  define_class<ConstTarget>("ConstTarget").
+    define_constructor(Constructor<ConstTarget, int>(),
+      Arg("v")).
+    define_method("get_value", &ConstTarget::getValue);
+
+  Module m = define_module("SharedPtrConstTest").
+    define_module_function("create_const_target", &createConstTarget).
+    define_module_function("extract_const_target_value", &extractConstTargetValue);
+
+  // Test that shared_ptr<const T> can be unwrapped to access the inner T
+  std::string code = R"(ptr = create_const_target(42)
+                        extract_const_target_value(ptr))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result.value()));
+}
+
+// Abstract class with non-virtual destructor - like cv::cudacodec::NVSurfaceToColorConverter
+namespace
+{
+  class AbstractClass
+  {
+  public:
+    virtual bool compute(int value) const = 0;
+    ~AbstractClass() {}  // non-virtual destructor
+  };
+
+  class ConcreteImpl : public AbstractClass
+  {
+  public:
+    bool compute(int value) const override { return value > 0; }
+  };
+
+  std::shared_ptr<AbstractClass> createAbstract()
+  {
+    return std::make_shared<ConcreteImpl>();
+  }
+
+  bool useAbstract(std::shared_ptr<AbstractClass> ptr, int value)
+  {
+    return ptr->compute(value);
+  }
+}
+
+TESTCASE(SharedPtrAbstractT)
+{
+  // shared_ptr<T> where T is abstract should NOT define a constructor taking T*,
+  // because deleting through a non-virtual destructor on an abstract class is UB.
+  define_class<AbstractClass>("AbstractClass").
+    define_method("compute", &AbstractClass::compute,
+      Arg("value"));
+
+  Module m = define_module("SharedPtrAbstractTest").
+    define_module_function("create_abstract", &createAbstract).
+    define_module_function("use_abstract", &useAbstract);
+
+  std::string code = R"(ptr = create_abstract
+                        use_abstract(ptr, 5))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
 // Forward declaration only - IncompleteClass is never defined
 class IncompleteClass;
 

data/test/test_Stl_UniquePtr.cpp

@@ -252,4 +252,51 @@ TESTCASE(Release)
     Exception,
     m.module_eval(code),
     ASSERT(std::string(ex.what()).find("undefined method") == 0));
+}
+
+// --- unique_ptr<const T> tests ---
+// When unique_ptr wraps a const T, the Wrapper::get() method must handle
+// the const-to-void* conversion. Without a cast, data_.get() returns
+// const T* which cannot implicitly convert to void*.
+namespace
+{
+  class ConstTarget
+  {
+  public:
+    int value;
+
+    ConstTarget() : value(0) {}
+    ConstTarget(int v) : value(v) {}
+
+    int getValue() const { return value; }
+  };
+
+  std::unique_ptr<const ConstTarget> createConstTarget(int v)
+  {
+    return std::make_unique<const ConstTarget>(v);
+  }
+
+  int extractConstTargetValue(const std::unique_ptr<const ConstTarget>& ptr)
+  {
+    return ptr->getValue();
+  }
+}
+
+TESTCASE(UniquePtrConstT)
+{
+  define_class<ConstTarget>("ConstTarget").
+    define_constructor(Constructor<ConstTarget, int>(),
+      Arg("v")).
+    define_method("get_value", &ConstTarget::getValue);
+
+  Module m = define_module("UniquePtrConstTest").
+    define_module_function("create_const_target", &createConstTarget).
+    define_module_function("extract_const_target_value", &extractConstTargetValue);
+
+  // Test that unique_ptr<const T> can be unwrapped to access the inner T
+  std::string code = R"(ptr = create_const_target(42)
+                        extract_const_target_value(ptr))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result.value()));
 }

data/test/test_Stl_Unordered_Map.cpp

@@ -357,6 +357,62 @@ TESTCASE(NotPrintable)
   ASSERT_EQUAL("[Not printable]", detail::From_Ruby<std::string>().convert(result));
 }
 
+namespace
+{
+  // Type with no default constructor - verifies insert_or_assign works in []=
+  class NoDefaultUnorderedMap
+  {
+  public:
+    NoDefaultUnorderedMap(int value) : value_(value) {}
+    int value() const { return value_; }
+
+    bool operator==(const NoDefaultUnorderedMap& other) const
+    {
+      return this->value_ == other.value_;
+    }
+
+  private:
+    int value_;
+  };
+}
+
+TESTCASE(NoDefaultConstructor)
+{
+  define_class<NoDefaultUnorderedMap>("NoDefaultUnorderedMap").
+    define_constructor(Constructor<NoDefaultUnorderedMap, int>(), Arg("value")).
+    define_method("value", &NoDefaultUnorderedMap::value);
+
+  Class c = define_unordered_map<std::string, NoDefaultUnorderedMap>("NoDefaultUnorderedMap_Map");
+
+  Object map = c.call("new");
+
+  // Test []= (insert_or_assign) with non-default-constructible value
+  map.call("[]=", "one", NoDefaultUnorderedMap(1));
+  map.call("[]=", "two", NoDefaultUnorderedMap(2));
+
+  Object result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test [] access
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result.call("value")));
+
+  // Test update existing key
+  map.call("[]=", "one", NoDefaultUnorderedMap(10));
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test delete
+  result = map.call("delete", "two");
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+}
+
 namespace
 {
   class Comparable

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.11.1
+  version: 4.11.3
 platform: ruby
 authors:
 - Paul Brannan