rice 4.6.1 → 4.7.0

data/rice/stl/multimap.ipp

@@ -19,8 +19,7 @@ namespace Rice
       MultimapHelper(Data_Type<T> klass) : klass_(klass)
       {
         this->register_pair();
-        this->define_constructor();
-        this->define_copyable_methods();
+        this->define_constructors();
         this->define_capacity_methods();
         this->define_access_methods();
         this->define_comparable_methods();
@@ -36,27 +35,13 @@ namespace Rice
         define_pair<const Key_T, Mapped_T>();
       }
 
-      void define_constructor()
+      void define_constructors()
       {
         klass_.define_constructor(Constructor<T>());
-      }
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<Value_T>)
-        {
-          klass_.define_method("copy", [](T& multimap) -> T
-            {
-              return multimap;
-            });
-        }
-        else
+        if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& multimap) -> T
-            {
-              throw std::runtime_error("Cannot copy multimaps with non-copy constructible types");
-              return multimap;
-            });
+          klass_.define_constructor(Constructor<T, const T&>());
         }
       }
 
@@ -74,14 +59,14 @@ namespace Rice
       {
         // Access methods
         klass_.
-          define_method("[]", [](const T& multimap, const Key_T& key) -> Array
+          define_method("[]", [](T& multimap, const Key_T& key) -> Array
           {
             Array result;
             auto range = multimap.equal_range(key);
 
             for (auto iter = range.first; iter != range.second; iter++)
             {
-              result.push<Mapped_T>(iter->second);
+              result.push(iter->second, false);
             }
 
             return result;
@@ -184,7 +169,8 @@ namespace Rice
               auto iter = multimap.begin();
 
               std::stringstream stream;
-              stream << "<" << detail::rubyClassName(detail::typeName(typeid(T))) << ":";
+              detail::TypeMapper<T> typeMapper;
+              stream << "<" << typeMapper.rubyName() << ":";
               stream << "{";
 
               for (; iter != multimap.end(); iter++)
@@ -222,8 +208,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(MultiMap_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<MultiMap_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -397,6 +383,12 @@ namespace Rice
     class From_Ruby<std::multimap<T, U>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -442,6 +434,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::multimap<T, U> converted_;
     };
   }

data/rice/stl/optional.ipp

@@ -9,23 +9,44 @@ namespace Rice::detail
     {
       return Type<intrinsic_type<T>>::verify();
     }
+
+    static VALUE rubyKlass()
+    {
+      TypeMapper<T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
   };
 
   template<>
   class To_Ruby<std::nullopt_t>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::nullopt_t& _)
     {
       return Qnil;
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class To_Ruby<std::optional<T>>
   {
   public:
-    static VALUE convert(const std::optional<T>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(std::optional<T>& data)
     {
       if (data.has_value())
       {
@@ -36,13 +57,22 @@ namespace Rice::detail
         return Qnil;
       }
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class To_Ruby<std::optional<T>&>
   {
   public:
-    static VALUE convert(const std::optional<T>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::optional<T>& data)
     {
       if (data.has_value())
       {
@@ -53,12 +83,21 @@ namespace Rice::detail
         return Qnil;
       }
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class From_Ruby<std::optional<T>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -88,6 +127,12 @@ namespace Rice::detail
   class From_Ruby<std::optional<T>&>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))

data/rice/stl/pair.ipp

@@ -10,78 +10,43 @@ namespace Rice
     public:
       PairHelper(Data_Type<T> klass) : klass_(klass)
       {
-        this->define_constructor();
-        this->define_copyable_methods();
-        this->define_access_methods();
-        this->define_modify_methods();
+        this->define_constructors();
+        this->define_attributes();
         this->define_to_s();
       }
 
     private:
-      void define_constructor()
+      void define_constructors()
       {
-        klass_.define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
+        klass_.define_constructor(Constructor<T>())
+              .define_constructor(Constructor<T, typename T::first_type&, typename T::second_type&>());
+      
+        if constexpr (std::is_copy_constructible_v<typename T::first_type> && std::is_copy_constructible_v<typename T::second_type>)
+        {
+          klass_.define_constructor(Constructor<T, const T&>());
+        }
       }
 
-      void define_copyable_methods()
+      void define_attributes()
       {
-        if constexpr (std::is_copy_constructible_v<typename T::first_type> && std::is_copy_constructible_v<typename T::second_type>)
+        // Access methods
+        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::first_type>>>)
         {
-          klass_.define_method("copy", [](T& pair) -> T
-            {
-              return pair;
-            });
+          klass_.define_attr("first", &T::first, Rice::AttrAccess::Read);
         }
         else
         {
-          klass_.define_method("copy", [](T& pair) -> T
-            {
-              throw std::runtime_error("Cannot copy pair with non-copy constructible types");
-              return pair;
-            });
+          klass_.define_attr("first", &T::first, Rice::AttrAccess::ReadWrite);
         }
-      }
 
-      void define_access_methods()
-      {
-        // Access methods
-        klass_.define_method("first", [](T& pair) -> typename T::first_type&
-          {
-            return pair.first;
-          })
-        .define_method("second", [](T& pair) -> typename T::second_type&
-          {
-            return pair.second;
-          });
-      }
-
-      void define_modify_methods()
-      {
-        // Access methods
-        klass_.define_method("first=", [](T& pair, typename T::first_type& value) -> typename T::first_type&
+        if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::second_type>>>)
         {
-          if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::first_type>>>)
-          {
-            throw std::runtime_error("Cannot set pair.first since it is a constant");
-          }
-          else
-          {
-            pair.first = value;
-            return pair.first;
-          }
-        })
-        .define_method("second=", [](T& pair, typename T::second_type& value) -> typename T::second_type&
+          klass_.define_attr("second", &T::second, Rice::AttrAccess::Read);
+        }
+        else
         {
-          if constexpr (std::is_const_v<std::remove_reference_t<std::remove_pointer_t<typename T::second_type>>>)
-          {
-            throw std::runtime_error("Cannot set pair.second since it is a constant");
-          }
-          else
-          {
-            pair.second = value;
-            return pair.second;
-          }
-        });
+          klass_.define_attr("second", &T::second, Rice::AttrAccess::ReadWrite);
+        }
       }
 
       void define_to_s()
@@ -117,8 +82,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Pair_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Pair_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");

data/rice/stl/reference_wrapper.ipp

@@ -9,22 +9,43 @@ namespace Rice::detail
     {
       return Type<T>::verify();
     }
+
+    static VALUE rubyKlass()
+    {
+      TypeMapper<T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
   };
 
   template<typename T>
   class To_Ruby<std::reference_wrapper<T>>
   {
   public:
-    VALUE convert(const std::reference_wrapper<T>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::reference_wrapper<T>& data)
     {
       return To_Ruby<T&>().convert(data.get());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class From_Ruby<std::reference_wrapper<T>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       return this->converter_.is_convertible(value);

data/rice/stl/set.ipp

@@ -176,9 +176,9 @@ namespace Rice
         klass_.define_method("to_a", [](T& self) -> VALUE
         {
           Array array;
-          for (const Value_T& element: self)
+          for (auto element: self)
           {
-            array.push(element);
+            array.push(element, false);
           }
 
           return array.value();
@@ -195,7 +195,8 @@ namespace Rice
             auto finish = self.end();
 
             std::stringstream stream;
-            stream << "<" << detail::rubyClassName(detail::typeName(typeid(T))) << ":";
+            detail::TypeMapper<T> typeMapper;
+            stream << "<" << typeMapper.rubyName() << ":";
             stream << "{";
 
             for (; iter != finish; iter++)
@@ -236,8 +237,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Set_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Set_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -268,11 +269,11 @@ namespace Rice
         return Qnil;
       };
       
-      using NativeFunction_T = NativeFunction<void, decltype(block), false>;
+      using Proc_T = decltype(block);
+      using NativeProc_T = NativeProc<Proc_T>;
+      std::unique_ptr<NativeProc_T> proc(NativeProc_T::define(std::forward<Proc_T>(block)));
 
-      // It is ok to use the address of native because it will remain valid while we iterate the set
-      NativeFunction_T native(block);
-      detail::protect<Function_T>(rb_block_call, rubySet, identifier.id(), 0, nullptr, NativeFunction_T::procEntry, (VALUE)&native);
+      detail::protect<Function_T>(rb_block_call, rubySet, identifier.id(), 0, nullptr, NativeProc_T::resolve, (VALUE)proc.get());
       
       return result;
     }
@@ -433,6 +434,12 @@ namespace Rice
     private:
       static inline std::string setName = "Set";
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -489,6 +496,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::set<T> converted_;
     };
   }

data/rice/stl/shared_ptr.ipp

@@ -11,8 +11,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(SharedPtr_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<SharedPtr_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -65,7 +65,29 @@ namespace Rice::detail
   {
     static bool verify()
     {
-      return Type<T>::verify();
+      if constexpr (std::is_fundamental_v<T>)
+      {
+        return Type<Pointer<T>>::verify();
+        return Type<Buffer<T>>::verify();
+      }
+      else
+      {
+        return Type<T>::verify();
+      }
+    }
+
+    static VALUE rubyKlass()
+    {
+      if (Data_Type<std::shared_ptr<T>>::is_defined())
+      {
+        std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<std::shared_ptr<T>>();
+        return pair.first;
+      }
+      else
+      {
+        TypeMapper<T> typeMapper;
+        return typeMapper.rubyKlass();
+      }
     }
   };
 
@@ -73,11 +95,17 @@ namespace Rice::detail
   class To_Ruby<std::shared_ptr<T>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arv)
+    {
+    }
+
     VALUE convert(std::shared_ptr<T>& data)
     {
       if constexpr (std::is_fundamental_v<T>)
       {
-        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+        return detail::wrap<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<T>>::ruby_data_type(), data, true);
       }
       else
       {
@@ -89,7 +117,7 @@ namespace Rice::detail
     {
       if constexpr (std::is_fundamental_v<T>)
       {
-        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+        return detail::wrap<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<T>>::ruby_data_type(), data, true);
       }
       else
       {
@@ -134,10 +162,10 @@ namespace Rice::detail
         std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
         return *ptr;
       }
-      else if constexpr (std::is_fundamental_v<T>)
+      else if (std::is_fundamental_v<T>)
       {
         // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<Pointer<T>>::ruby_data_type());
         return wrapper->data();
       }
       else
@@ -155,16 +183,15 @@ namespace Rice::detail
   class To_Ruby<std::shared_ptr<T>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg)
+    {
+    }
+
     VALUE convert(std::shared_ptr<T>& data)
     {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
-      }
-      else
-      {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
-      }
+      return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
     }
   };
 
@@ -204,10 +231,10 @@ namespace Rice::detail
         std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
         return *ptr;
       }
-      else if constexpr (std::is_fundamental_v<T>)
+      else if (std::is_fundamental_v<T>)
       {
         // Get the wrapper again to validate T's type
-        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<Pointer<T>>::ruby_data_type());
         return wrapper->data();
       }
       else