rice 4.6.1 → 4.7.0

data/rice/stl/string.ipp

@@ -9,59 +9,186 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<int N>
+  struct Type<std::string[N]>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<std::string*>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      using Pointer_T = Pointer<std::string>;
+      std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<Pointer_T>();
+      return pair.first;
+    }
+  };
+
+  template<>
+  struct Type<std::string**>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      using Pointer_T = Pointer<std::string*>;
+      std::pair<VALUE, rb_data_type_t*> pair = Registries::instance.types.getType<Pointer_T>();
+      return pair.first;
+    }
   };
 
   template<>
   class To_Ruby<std::string>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::string& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::string& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };
+
+  template<int N>
+  class To_Ruby<std::string[N]>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(std::string data[N])
+    {
+      Buffer<std::string> buffer(data, N);
+      Data_Object<Buffer<std::string>> dataObject(std::move(buffer));
+      return dataObject.value();
+    }
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string*>
   {
   public:
-    VALUE convert(const std::string* x)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
     {
-      return detail::protect(rb_external_str_new, x->data(), (long)x->size());
     }
+
+    VALUE convert(const std::string* value)
+    {
+      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+      bool isBuffer = this->returnInfo_ && this->returnInfo_->isBuffer();
+
+      if (isBuffer)
+      {
+        using Pointer_T = Pointer<std::string>;
+        return detail::wrap(Data_Type<Pointer_T>::klass(), Data_Type<Pointer_T>::ruby_data_type(), value, isOwner);
+      }
+      else
+      {
+        return detail::protect(rb_external_str_new, value->data(), (long)value->size());
+      }
+    }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string*&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::string* x)
     {
       return detail::protect(rb_external_str_new, x->data(), (long)x->size());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
-  template<>
+  /*template<>
   class To_Ruby<std::string**>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(std::string** data)
     {
       Buffer<std::string*> buffer(data);
       Data_Object<Buffer<std::string*>> dataObject(std::move(buffer));
       return dataObject.value();
     }
-  };
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };*/
 
   template<>
   class From_Ruby<std::string>
@@ -87,7 +214,7 @@ namespace Rice::detail
 
     std::string convert(VALUE value)
     {
-      detail::protect(rb_check_type, value, (int)T_STRING);
+      detail::protect(rb_check_type, value, (int)RUBY_T_STRING);
       return std::string(RSTRING_PTR(value), RSTRING_LEN(value));
     }
 
@@ -119,7 +246,7 @@ namespace Rice::detail
 
     std::string& convert(VALUE value)
     {
-      detail::protect(rb_check_type, value, (int)T_STRING);
+      detail::protect(rb_check_type, value, (int)RUBY_T_STRING);
       this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
       return this->converted_;
     }
@@ -129,10 +256,50 @@ namespace Rice::detail
     std::string converted_ = "";
   };
 
+  template<>
+  class From_Ruby<std::string&&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::string&& convert(VALUE value)
+    {
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
+      return std::move(this->converted_);
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    std::string converted_ = "";
+  };
+
   template<>
   class From_Ruby<std::string*>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -147,12 +314,13 @@ namespace Rice::detail
 
     std::string* convert(VALUE value)
     {
-      detail::protect(rb_check_type, value, (int)T_STRING);
+      detail::protect(rb_check_type, value, (int)RUBY_T_STRING);
       this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
       return &this->converted_;
     }
 
   private:
+    Arg* arg_ = nullptr;
     std::string converted_;
   };
 }

data/rice/stl/string_view.ipp

@@ -9,6 +9,11 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
   };
 
   template<>

data/rice/stl/tuple.ipp

@@ -19,42 +19,65 @@ namespace Rice::detail
       auto indices = std::make_index_sequence<std::tuple_size_v<std::tuple<Types...>>>{};
       return verifyTypes(indices);
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cArray;
+    }
   };
 
   template<typename...Types>
   class To_Ruby<std::tuple<Types...>>
   {
   public:
-    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::tuple<Types...>& data)
     {
       Array result;
 
       for_each_tuple(data, [&](auto element)
       {
-        using Element_T = decltype(element);
-        result.push<Element_T>((Element_T)element);
+        result.push(element, true);
       });
 
       return result.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
   class To_Ruby<std::tuple<Types...>&>
   {
   public:
-    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::tuple<Types...>& data)
     {
       Array result;
 
-      for_each_tuple(data, [&](auto& value)
-        {
-          VALUE element = detail::To_Ruby<decltype(value)>().convert(value);
-          result.push(element);
-        });
+      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
+
+      for_each_tuple(data, [&](auto& element)
+      {
+        result.push(element, isOwner);
+      });
 
       return result.value();
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
@@ -69,6 +92,12 @@ namespace Rice::detail
       return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
 
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       Convertible result = Convertible::None;

data/rice/stl/unique_ptr.ipp

@@ -30,6 +30,12 @@ namespace Rice::detail
   class To_Ruby<std::unique_ptr<T>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(std::unique_ptr<T>& data)
     {
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
@@ -41,17 +47,29 @@ namespace Rice::detail
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
       return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template <typename T>
   class To_Ruby<std::unique_ptr<T>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(std::unique_ptr<T>& data)
     {
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
-      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, std::move(data), true);
+      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template <typename T>
@@ -64,6 +82,12 @@ namespace Rice::detail
       return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
     }
 
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       if (!is_same_smart_ptr(value))
@@ -101,6 +125,12 @@ namespace Rice::detail
       return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
     }
 
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       if (!is_same_smart_ptr(value))
@@ -133,7 +163,21 @@ 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()
+    {
+      TypeMapper<T> typeMapper;
+      return typeMapper.rubyKlass();
     }
   };
 }

data/rice/stl/unordered_map.ipp

@@ -19,8 +19,7 @@ namespace Rice
       UnorderedMapHelper(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();
@@ -37,27 +36,13 @@ namespace Rice
         define_pair<const Key_T, 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& unordered_map) -> T
-            {
-              return unordered_map;
-            });
-        }
-        else
+        if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& unordered_map) -> T
-            {
-              throw std::runtime_error("Cannot copy unordered_maps with non-copy constructible types");
-              return unordered_map;
-            });
+          klass_.define_constructor(Constructor<T, const T&>());
         }
       }
 
@@ -240,8 +225,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(UnorderedMap_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<UnorderedMap_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -418,6 +403,12 @@ namespace Rice
     class From_Ruby<std::unordered_map<T, U>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -463,6 +454,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::unordered_map<T, U> converted_;
     };
   }

data/rice/stl/variant.ipp

@@ -13,27 +13,37 @@ namespace Rice::detail
       return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
     }
 
-    template<std::size_t... I>
     constexpr static bool verify()
     {
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
       return verifyTypes(indices);
     }
+
+    static VALUE rubyKlass()
+    {
+      // There is no direct mapping to Ruby, so just return Object
+      return rb_cObject;
+    }
   };
 
   template<typename...Types>
   class To_Ruby<std::variant<Types...>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
 
     template<typename U, typename V>
-    static VALUE convertElement(U& data, bool takeOwnership)
+    VALUE convertElement(U& data, bool takeOwnership)
     {
       return To_Ruby<V>().convert(std::forward<V>(std::get<V>(data)));
     }
 
     template<typename U, std::size_t... I>
-    static VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -76,26 +86,36 @@ namespace Rice::detail
     }
 
     template<typename U>
-    static VALUE convert(U& data, bool takeOwnership = false)
+    VALUE convert(U& data)
     {
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      return convertIterator(data, true, indices);
     }
 
     template<typename U>
-    static VALUE convert(U&& data, bool takeOwnership = false)
+    VALUE convert(U&& data)
     {
+      bool isOwner = true;
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      return convertIterator(data, isOwner, indices);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
   class To_Ruby<std::variant<Types...>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     template<typename U, typename V>
-    static VALUE convertElement(U& data, bool takeOwnership)
+    VALUE convertElement(U& data, bool takeOwnership)
     {
       if constexpr (std::is_const_v<U>)
       {
@@ -108,7 +128,7 @@ namespace Rice::detail
     }
 
     template<typename U, std::size_t... I>
-    static VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
+    VALUE convertIterator(U& data, bool takeOwnership, std::index_sequence<I...>& indices)
     {
       // Create a tuple of the variant types so we can look over the tuple's types
       using Tuple_T = std::tuple<Types...>;
@@ -132,17 +152,27 @@ namespace Rice::detail
     }
 
     template<typename U>
-    static VALUE convert(U& data, bool takeOwnership = false)
+    VALUE convert(U& data)
     {
+      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
       auto indices = std::make_index_sequence<std::variant_size_v<std::variant<Types...>>>{};
-      return convertIterator(data, takeOwnership, indices);
+      return convertIterator(data, isOwner, indices);
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename...Types>
   class From_Ruby<std::variant<Types...>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       Convertible result = Convertible::None;
@@ -229,6 +259,12 @@ namespace Rice::detail
   class From_Ruby<std::variant<Types...>&> : public From_Ruby<std::variant<Types...>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     std::variant<Types...>& convert(VALUE value)
     {
       int index = this->figureIndex(value);