rice 4.8.0 → 4.9.0

data/rice/stl/unique_ptr.hpp

@@ -1,19 +1,25 @@
 #ifndef Rice__stl__unique_ptr__hpp_
 #define Rice__stl__unique_ptr__hpp_
 
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::unique_ptr<T>> define_unique_ptr(std::string klassName = "");
+}
+
 namespace Rice::detail
 {
   template<typename T>
   class Wrapper<std::unique_ptr<T>> : public WrapperBase
   {
   public:
-    Wrapper(std::unique_ptr<T>&& data);
+    Wrapper(rb_data_type_t* rb_data_type, std::unique_ptr<T>&& data);
     ~Wrapper();
-    void* get() override;
-    std::unique_ptr<T>& data();
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     std::unique_ptr<T> data_;
+    rb_data_type_t* inner_rb_data_type_;
   };
 }
 

data/rice/stl/unique_ptr.ipp

@@ -1,135 +1,123 @@
 #include <memory>
 
-namespace Rice::detail
+namespace Rice
 {
   template<typename T>
-  inline Wrapper<std::unique_ptr<T>>::Wrapper(std::unique_ptr<T>&& data)
-    : data_(std::move(data))
-  {
-  }
-
-  template<typename T>
-  inline Wrapper<std::unique_ptr<T>>::~Wrapper()
-  {
-    Registries::instance.instances.remove(this->get());
-  }
-
-  template<typename T>
-  inline void* Wrapper<std::unique_ptr<T>>::get()
-  {
-    return (void*)this->data_.get();
-  }
-
-  template<typename T>
-  inline std::unique_ptr<T>& Wrapper<std::unique_ptr<T>>::data()
+  Data_Type<std::unique_ptr<T>> define_unique_ptr(std::string klassName)
   {
-    return data_;
-  }
+    using UniquePtr_T = std::unique_ptr<T>;
+    using Data_Type_T = Data_Type<UniquePtr_T>;
 
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>>
-  {
-  public:
-    To_Ruby() = default;
-
-    explicit To_Ruby(Arg* arg) : arg_(arg)
+    if (klassName.empty())
     {
+      detail::TypeMapper<UniquePtr_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
-    VALUE convert(std::unique_ptr<T>& data)
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
     {
-      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);
+      return Data_Type_T();
     }
 
-    VALUE convert(std::unique_ptr<T>&& data)
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<UniquePtr_T>>(rb_mStd, id).
+      define_method("get", &UniquePtr_T::get).
+      define_method("release", &UniquePtr_T::release).
+      define_method("reset", &UniquePtr_T::reset).
+      define_method("swap", &UniquePtr_T::swap).
+      define_method("empty?", [](UniquePtr_T& self)->bool
+      {
+        return !self;
+      });
+
+    // Setup delegation to forward T's methods via get (only for non-fundamental, non-void types)
+    if constexpr (!std::is_void_v<T> && !std::is_fundamental_v<T>)
     {
-      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);
+      detail::define_forwarding(result.klass(), Data_Type<T>::klass());
     }
 
-  private:
-    Arg* arg_ = nullptr;
-  };
+    return result;
+  }
+}
 
-  template <typename T>
-  class To_Ruby<std::unique_ptr<T>&>
+// --------- Wrapper ---------
+namespace Rice::detail
+{
+  template<typename T>
+  Wrapper<std::unique_ptr<T>>::Wrapper(rb_data_type_t* rb_data_type, std::unique_ptr<T>&& data)
+    : WrapperBase(rb_data_type), data_(std::move(data))
   {
-  public:
-    To_Ruby() = default;
+    using Intrinsic_T = intrinsic_type<T>;
 
-    explicit To_Ruby(Arg* arg) : arg_(arg)
+    if constexpr (std::is_fundamental_v<Intrinsic_T>)
     {
+      inner_rb_data_type_ = Data_Type<Pointer<Intrinsic_T>>::ruby_data_type();
     }
-
-    VALUE convert(std::unique_ptr<T>& data)
+    else
     {
-      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);
+      inner_rb_data_type_ = Data_Type<Intrinsic_T>::ruby_data_type();
     }
+  }
 
-  private:
-    Arg* arg_ = nullptr;
-  };
+  template<typename T>
+  Wrapper<std::unique_ptr<T>>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
+  }
 
-  template <typename T>
-  class From_Ruby<std::unique_ptr<T>>
+  template<typename T>
+  void* Wrapper<std::unique_ptr<T>>::get(rb_data_type_t* requestedType)
   {
-  public:
-    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
     {
-      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
-      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
+      return &this->data_;
     }
-
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg* arg) : arg_(arg)
+    else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
+    {
+      return this->data_.get();
+    }
+    else
     {
+      throw Exception(rb_eTypeError, "wrong argument type (expected %s)",
+          requestedType->wrap_struct_name);
     }
+  }
 
-    double is_convertible(VALUE value)
+}
+
+// --------- Type ---------
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<std::unique_ptr<T>>
+  {
+    static bool verify()
     {
-      if (!is_same_smart_ptr(value))
+      bool result = true;
+      if constexpr (std::is_fundamental_v<T>)
       {
-        return Convertible::None;
+        result = result && Type<Pointer<T>>::verify();
       }
-
-      switch (rb_type(value))
+      else
       {
-        case RUBY_T_DATA:
-          return Convertible::Exact;
-          break;
-        default:
-          return Convertible::None;
+        result = result && Type<T>::verify();
       }
-    }
 
-    std::unique_ptr<T> convert(VALUE value)
-    {
-      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
-      if (!wrapper)
+      if (result)
       {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
+        define_unique_ptr<T>();
       }
-      return std::move(wrapper->data());
-    }
 
-  private:
-    Arg* arg_ = nullptr;
+      return result;
+    }
   };
 
+  // --------- From_Ruby ---------
   template <typename T>
-  class From_Ruby<std::unique_ptr<T>&>
+  class From_Ruby<std::unique_ptr<T>>
   {
   public:
-    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
-    {
-      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
-      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
-    }
-
     From_Ruby() = default;
 
     explicit From_Ruby(Arg* arg) : arg_(arg)
@@ -138,11 +126,6 @@ namespace Rice::detail
 
     double is_convertible(VALUE value)
     {
-      if (!is_same_smart_ptr(value))
-      {
-        return Convertible::None;
-      }
-
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
@@ -153,41 +136,14 @@ namespace Rice::detail
       }
     }
 
-    std::unique_ptr<T>& convert(VALUE value)
+    std::unique_ptr<T> convert(VALUE value)
     {
-      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
-      if (!wrapper)
-      {
-        std::string message = "Invalid smart pointer wrapper";
-        throw std::runtime_error(message.c_str());
-      }
-      return wrapper->data();
+      std::unique_ptr<T>* result = detail::unwrap<std::unique_ptr<T>>(value, Data_Type<std::unique_ptr<T>>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
+      // The reason we need this overriden From_Ruby is to do this std::move.
+      return std::move(*result);
     }
 
   private:
     Arg* arg_ = nullptr;
   };
-
-  template<typename T>
-  struct Type<std::unique_ptr<T>>
-  {
-    static bool 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/test/test_Inheritance.cpp

@@ -128,12 +128,12 @@ TESTCASE(base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
-                                         notification.message)EOS");
+  Object message = m.module_eval(R"(notification = EmailNotification.new
+                                    notification.message)");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = PushNotification.new
-                                  notification.message)EOS");
+  message = m.module_eval(R"(notification = PushNotification.new
+                             notification.message)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -151,12 +151,12 @@ TESTCASE(base_pointer_function_argument)
   define_global_function("process_notification", &processNotification);
 
   Module m = define_module("Testing");
-  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
-                                         process_notification(notification))EOS");
+  Object message = m.module_eval(R"(notification = EmailNotification.new
+                                    process_notification(notification))");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = PushNotification.new
-                                  process_notification(notification))EOS");
+  message = m.module_eval(R"(notification = PushNotification.new
+                             process_notification(notification))");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -175,12 +175,12 @@ TESTCASE(module_base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.module_eval(R"EOS(notification = Inheritance::EmailNotification.new
-                                       notification.message)EOS");
+  Object message = m.module_eval(R"(notification = Inheritance::EmailNotification.new
+                                    notification.message)");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = Inheritance::PushNotification.new
-                                  notification.message)EOS");
+  message = m.module_eval(R"(notification = Inheritance::PushNotification.new
+                             notification.message)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -219,8 +219,8 @@ TESTCASE(base_pointer_constructor)
 
   Module m = define_module("Testing");
 
-  Object result = m.module_eval(R"EOS(notification = PushNotification.new
+  Object result = m.module_eval(R"(notification = PushNotification.new
                                         processor = Processor.new(notification)
-                                        processor.process)EOS");
+                                        processor.process)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(result));
 }

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -75,11 +75,15 @@ TESTCASE(test_keep_alive_no_wrapper)
   Module m = define_module("TestingModule");
   Object zoo = m.module_eval("@zoo = Zoo.new");
 
+  std::string code = R"(@zoo.get_pets.each do |pet|
+                          puts pet.get_name
+                        end)";
+
   // get_pets returns an Array (builtin type) so Return().keepAlive()
-  // shall result in std::runtime_error
+  // should result in std::runtime_error
   ASSERT_EXCEPTION_CHECK(
     Exception,
-    m.module_eval("@zoo.get_pets.each do |pet| puts pet.name; end"),
+    m.module_eval(code),
     ASSERT_EQUAL("wrong argument type Array (expected wrapped C++ object)",
                  ex.what())
   );