rice 4.7.1 → 4.9.0

data/rice/stl/optional.ipp

@@ -23,17 +23,17 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    VALUE convert(const std::nullopt_t& _)
+    VALUE convert(const std::nullopt_t&)
     {
       return Qnil;
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -42,7 +42,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -58,8 +58,20 @@ namespace Rice::detail
       }
     }
 
+    VALUE convert(const std::optional<T>& data)
+    {
+      if (data.has_value())
+      {
+        return To_Ruby<T>().convert(data.value());
+      }
+      else
+      {
+        return Qnil;
+      }
+    }
+
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -68,7 +80,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -85,7 +97,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -94,11 +106,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))
       {
@@ -121,6 +133,9 @@ namespace Rice::detail
         return From_Ruby<T>().convert(value);
       }
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -129,11 +144,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))
       {
@@ -158,6 +173,7 @@ namespace Rice::detail
       return this->converted_;
     }
   private:
+    Arg* arg_ = nullptr;
     std::optional<T> converted_;
   };
 }

data/rice/stl/pair.ipp

@@ -62,11 +62,11 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& pair)
-            {
-              return "[Not printable]";
-            });
-        }
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
+      }
       }
 
       private:

data/rice/stl/reference_wrapper.ipp

@@ -23,7 +23,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -33,7 +33,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -42,11 +42,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)
     {
       return this->converter_.is_convertible(value);
     }
@@ -57,6 +57,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     From_Ruby<T&> converter_;
   };
 }

data/rice/stl/set.ipp

@@ -217,10 +217,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& self)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -307,7 +307,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -319,7 +319,7 @@ namespace Rice
             Object object(value);
             if (object.class_name().str() == setName)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           }
           default:
@@ -343,12 +343,12 @@ namespace Rice
             {
               return toSet<T>(value);
             }
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
         }
@@ -371,7 +371,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -383,7 +383,7 @@ namespace Rice
             Object object(value);
             if (object.class_name().str() == setName)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           }
           default:
@@ -412,12 +412,12 @@ namespace Rice
                 return this->converted_;
               }
             }
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
         }
@@ -440,7 +440,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -455,7 +455,7 @@ namespace Rice
             Object object(value);
             if (object.class_name().str() == setName)
             {
-              return Convertible::Cast;
+              return Convertible::Exact;
             }
           }
           default:
@@ -484,12 +484,12 @@ namespace Rice
                 return &this->converted_;
               }
             }
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::set");
           }
         }

data/rice/stl/shared_ptr.hpp

@@ -1,28 +1,28 @@
 #ifndef Rice__stl__shared_ptr__hpp_
 #define Rice__stl__shared_ptr__hpp_
 
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName = "");
+}
+
 namespace Rice::detail
 {
   template<typename T>
   class Wrapper<std::shared_ptr<T>> : public WrapperBase
   {
   public:
-    Wrapper(const std::shared_ptr<T>& data);
+    Wrapper(rb_data_type_t* rb_data_type, const std::shared_ptr<T>& data);
     ~Wrapper();
-    void* get() override;
-    std::shared_ptr<T>& data();
+    void* get(rb_data_type_t* requestedType) override;
 
   private:
     std::shared_ptr<T> data_;
+    rb_data_type_t* inner_rb_data_type_;
   };
 }
 
-namespace Rice
-{
-  template<typename T>
-  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName = "");
-}
-
 #include "shared_ptr.ipp"
 
 #endif // Rice__stl__shared_ptr__hpp_

data/rice/stl/shared_ptr.ipp

@@ -1,6 +1,5 @@
 #include <memory>
 
-// --------- Enable creation of std::shared_ptr from Ruby ---------
 namespace Rice
 {
   template<typename T>
@@ -23,7 +22,24 @@ namespace Rice
 
     Identifier id(klassName);
     Data_Type_T result = define_class_under<detail::intrinsic_type<SharedPtr_T>>(rb_mStd, id).
-      define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      define_method("get", &SharedPtr_T::get).
+      define_method("swap", &SharedPtr_T::swap).
+      define_method("use_count", &SharedPtr_T::use_count).
+      define_method("empty?", [](SharedPtr_T& self)->bool
+      {
+        return !self;
+      });
+
+    if constexpr (!std::is_void_v<T>)
+    {
+      result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+    }
+
+    // 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>)
+    {
+      detail::define_forwarding(result.klass(), Data_Type<T>::klass());
+    }
 
     return result;
   }
@@ -33,31 +49,47 @@ namespace Rice
 namespace Rice::detail
 {
   template<typename T>
-  inline Wrapper<std::shared_ptr<T>>::Wrapper(const std::shared_ptr<T>& data)
-    : data_(data)
+  Wrapper<std::shared_ptr<T>>::Wrapper(rb_data_type_t* rb_data_type, const std::shared_ptr<T>& data)
+    : WrapperBase(rb_data_type), data_(data)
   {
-  }
+    using Intrinsic_T = intrinsic_type<T>;
 
-  template<typename T>
-  inline Wrapper<std::shared_ptr<T>>::~Wrapper()
-  {
-    Registries::instance.instances.remove(this->get());
+    if constexpr (std::is_fundamental_v<Intrinsic_T>)
+    {
+      inner_rb_data_type_ = Data_Type<Pointer<Intrinsic_T>>::ruby_data_type();
+    }
+    else
+    {
+      inner_rb_data_type_ = Data_Type<Intrinsic_T>::ruby_data_type();
+    }
   }
 
   template<typename T>
-  inline void* Wrapper<std::shared_ptr<T>>::get()
+  Wrapper<std::shared_ptr<T>>::~Wrapper()
   {
-    return (void*)this->data_.get();
+    Registries::instance.instances.remove(this->get(this->rb_data_type_));
   }
 
   template<typename T>
-  inline std::shared_ptr<T>& Wrapper<std::shared_ptr<T>>::data()
+  void* Wrapper<std::shared_ptr<T>>::get(rb_data_type_t* requestedType)
   {
-    return data_;
+    if (rb_typeddata_inherited_p(this->rb_data_type_, requestedType))
+    {
+      return &this->data_;
+    }
+    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);
+    }
   }
 }
 
-// --------- Type/To_Ruby/From_Ruby ---------
+// --------- Type ---------
 namespace Rice::detail
 {
   template<typename T>
@@ -65,187 +97,22 @@ namespace Rice::detail
   {
     static bool verify()
     {
+      bool result = true;
       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();
-      }
-    }
-  };
-
-  template <typename T>
-  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<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<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);
-      }
-    }
-
-    VALUE convert(std::shared_ptr<T>&& data)
-    {
-      if constexpr (std::is_fundamental_v<T>)
-      {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<Pointer<T>>::klass(), Data_Type<Pointer<T>>::ruby_data_type(), data, true);
+        result = result && Type<Pointer<T>>::verify();
       }
       else
       {
-        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+        result = result && Type<T>::verify();
       }
-    }
-  };
-
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg * arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
-      {
-        case RUBY_T_DATA:
-          return Convertible::Exact;
-          break;
-        default:
-          return Convertible::None;
-      }
-    }
 
-    std::shared_ptr<T> convert(VALUE value)
-    {
-      // Get the wrapper
-      WrapperBase* wrapperBase = detail::getWrapper(value);
-
-      // Was this shared_ptr created by the user from Ruby? If so it will
-      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
-      // return the shared pointer
-      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
-      {
-        // Use unwrap to validate the underlying wrapper is the correct type
-        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 (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<Pointer<T>>::ruby_data_type());
-        return wrapper->data();
-      }
-      else
+      if (result)
       {
-        // 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());
-        return wrapper->data();
+        define_shared_ptr<T>();
       }
-    }
-  private:
-    Arg* arg_ = nullptr;
-  };
-
-  template <typename T>
-  class To_Ruby<std::shared_ptr<T>&>
-  {
-  public:
-    To_Ruby() = default;
 
-    explicit To_Ruby(Arg* arg)
-    {
+      return result;
     }
-
-    VALUE convert(std::shared_ptr<T>& data)
-    {
-      return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
-    }
-  };
-
-  template <typename T>
-  class From_Ruby<std::shared_ptr<T>&>
-  {
-  public:
-    From_Ruby() = default;
-
-    explicit From_Ruby(Arg * arg) : arg_(arg)
-    {
-    }
-
-    Convertible is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
-      {
-        case RUBY_T_DATA:
-          return Convertible::Exact;
-          break;
-        default:
-          return Convertible::None;
-      }
-    }
-
-    std::shared_ptr<T>& convert(VALUE value)
-    {
-      // Get the wrapper
-      WrapperBase* wrapperBase = detail::getWrapper(value);
-
-      // Was this shared_ptr created by the user from Ruby? If so it will
-      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
-      // return the shared pointer
-      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
-      {
-        // Use unwrap to validate the underlying wrapper is the correct type
-        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 (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<Pointer<T>>::ruby_data_type());
-        return wrapper->data();
-      }
-      else
-      {
-        // 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());
-        return wrapper->data();
-      }
-    }
-
-  private:
-    Arg* arg_ = nullptr;
   };
 }