rice 4.5.0 → 4.6.0

data/rice/Data_Object.ipp

@@ -18,6 +18,13 @@ namespace Rice
     this->set_value(value);
   }
 
+  template<typename T>
+  inline Data_Object<T>::Data_Object(T&& data, Class klass)
+  {
+    VALUE value = detail::wrap(klass, Data_Type<T>::ruby_data_type(), data, true);
+    this->set_value(value);
+  }
+  
   template<typename T>
   inline Data_Object<T>::Data_Object(const T& data, bool isOwner, Class klass)
   {
@@ -38,6 +45,12 @@ namespace Rice
     check_ruby_type(value);
   }
 
+  template<typename T>
+  inline Data_Object<T>::Data_Object(VALUE value) : Object(value)
+  {
+    check_ruby_type(value);
+  }
+
   template<typename T>
   inline void Data_Object<T>::check_ruby_type(VALUE value)
   {
@@ -71,19 +84,6 @@ namespace Rice
       return detail::unwrap<T>(this->value(), Data_Type<T>::ruby_data_type(), false);
     }
   }
-
-  template<typename T>
-  inline T* Data_Object<T>::from_ruby(VALUE value, bool takeOwnership)
-  {
-    if (Data_Type<T>::is_descendant(value))
-    {
-      return detail::unwrap<T>(value, Data_Type<T>::ruby_data_type(), takeOwnership);
-    }
-    else
-    {
-      throw create_type_exception<T>(value);
-    }
-  }
 }
 
 namespace Rice::detail
@@ -91,8 +91,19 @@ namespace Rice::detail
   template<typename T>
   class To_Ruby
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
-    VALUE convert(T& data)
+    template<typename U>
+    VALUE convert(U& data)
     {
       // Get the ruby typeinfo
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
@@ -102,7 +113,8 @@ namespace Rice::detail
       return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
     }
 
-    VALUE convert(const T& data)
+    template<typename U>
+    VALUE convert(U&& data)
     {
       // Get the ruby typeinfo
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
@@ -116,6 +128,16 @@ namespace Rice::detail
   template <typename T>
   class To_Ruby<T&>
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     To_Ruby() = default;
 
@@ -123,26 +145,16 @@ namespace Rice::detail
     {
     }
 
-    VALUE convert(T& data)
-    {
-      // Note that T could be a pointer or reference to a base class while data is in fact a
-      // child class. Lookup the correct type so we return an instance of the correct Ruby class
-      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
-
-      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-      return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
-    }
-
-    VALUE convert(const T& data)
+    template<typename U>
+    VALUE convert(U& data)
     {
       // Note that T could be a pointer or reference to a base class while data is in fact a
       // child class. Lookup the correct type so we return an instance of the correct Ruby class
       std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(data);
 
-      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+      bool isOwner = (this->returnInfo_ && this->returnInfo_->isOwner());
       return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
     }
-
   private:
     Return* returnInfo_ = nullptr;
   };
@@ -150,6 +162,16 @@ namespace Rice::detail
   template <typename T>
   class To_Ruby<T*>
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     To_Ruby() = default;
 
@@ -157,38 +179,31 @@ namespace Rice::detail
     {
     }
 
-    VALUE convert(T* data)
+    template<typename U>
+    VALUE convert(U* data)
     {
-      if (data)
+      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+
+      if (data == nullptr)
       {
-        // Note that T could be a pointer or reference to a base class while data is in fact a
-        // child class. Lookup the correct type so we return an instance of the correct Ruby class
-        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
-        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+        return Qnil;
       }
-      else
+      else if (this->returnInfo_ && this->returnInfo_->isArray())
       {
-        return Qnil;
+        using Buffer_T = Buffer<T>;
+        Buffer_T buffer((T*)data);
+        buffer.setOwner(isOwner);
+        return detail::wrap(Data_Type<Buffer_T>::klass(), Data_Type<Buffer_T>::ruby_data_type(), buffer, true);
       }
-    }
-
-    VALUE convert(const T* data)
-    {
-      if (data)
+      else
       {
         // Note that T could be a pointer or reference to a base class while data is in fact a
         // child class. Lookup the correct type so we return an instance of the correct Ruby class
         std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
-        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
         return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
       }
-      else
-      {
-        return Qnil;
-      }
     }
-
+    
   private:
     Return* returnInfo_ = nullptr;
   };
@@ -196,6 +211,16 @@ namespace Rice::detail
   template <typename T>
   class To_Ruby<T*&>
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     To_Ruby() = default;
 
@@ -203,36 +228,29 @@ namespace Rice::detail
     {
     }
 
-    VALUE convert(T* data)
+    template<typename U>
+    VALUE convert(U* data)
     {
-      if (data)
+      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+
+      if (data == nullptr)
       {
-        // Note that T could be a pointer or reference to a base class while data is in fact a
-        // child class. Lookup the correct type so we return an instance of the correct Ruby class
-        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
-        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+        return Qnil;
       }
-      else
+      else if (this->returnInfo_ && this->returnInfo_->isArray())
       {
-        return Qnil;
+        using Buffer_T = Buffer<intrinsic_type<T>>;
+        Buffer_T buffer((T*)data);
+        buffer.setOwner(isOwner);
+        return detail::wrap(Data_Type<Buffer_T>::klass(), Data_Type<Buffer_T>::ruby_data_type(), buffer, true);
       }
-    }
-
-    VALUE convert(const T* data)
-    {
-      if (data)
+      else
       {
         // Note that T could be a pointer or reference to a base class while data is in fact a
         // child class. Lookup the correct type so we return an instance of the correct Ruby class
         std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
-        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
         return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
       }
-      else
-      {
-        return Qnil;
-      }
     }
 
   private:
@@ -242,6 +260,16 @@ namespace Rice::detail
   template <typename T>
   class To_Ruby<T**>
   {
+    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
+                  "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     To_Ruby() = default;
 
@@ -249,31 +277,16 @@ namespace Rice::detail
     {
     }
 
-    VALUE convert(T** data)
+    template<typename U>
+    VALUE convert(U** data)
     {
       if (data)
       {
-        // Note that T could be a pointer or reference to a base class while data is in fact a
-        // child class. Lookup the correct type so we return an instance of the correct Ruby class
-        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(**data);
         bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
-      }
-      else
-      {
-        return Qnil;
-      }
-    }
-
-    VALUE convert(const T** data)
-    {
-      if (data)
-      {
-        // Note that T could be a pointer or reference to a base class while data is in fact a
-        // child class. Lookup the correct type so we return an instance of the correct Ruby class
-        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType(*data);
-        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
-        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+        Buffer<T*> buffer((T**)data);
+        buffer.setOwner(isOwner);
+        using Buffer_T = Buffer<intrinsic_type<T>*>;
+        return detail::wrap(Data_Type<Buffer_T>::klass(), Data_Type<Buffer_T>::ruby_data_type(), buffer, true);
       }
       else
       {
@@ -300,6 +313,14 @@ namespace Rice::detail
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> || !std::is_same_v<T, std::unordered_map<T, T>> ||
+                  !std::is_same_v<T, std::monostate> || !std::is_same_v<T, std::multimap<T, T>> ||
+                  !std::is_same_v<T, std::optional<T>> || !std::is_same_v<T, std::pair<T, T>> ||
+                  !std::is_same_v<T, std::set<T>> || !std::is_same_v<T, std::string> ||
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     From_Ruby() = default;
 
@@ -321,34 +342,16 @@ namespace Rice::detail
 
     T convert(VALUE value)
     {
-      // This expression checks to see if T has an explicit copy constructor
-      // If it does then we have to call it directly. Not sure if this end ups
-      // with an extra copy or not?
-      // 
-      // std::is_constructible_v<T, T> && !std::is_convertible_v<T, T>
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      using Intrinsic_T = intrinsic_type<T>;
+      Intrinsic_T* instance = detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
+
+      if constexpr (std::is_constructible_v<T, T> && !std::is_convertible_v<T, T>)
       {
-        if constexpr (std::is_constructible_v<T, T> && !std::is_convertible_v<T, T>)
-        {
-          return T(this->arg_->template defaultValue<T>());
-        }
-        else
-        {
-          return this->arg_->template defaultValue<T>();
-        }
+        return T(*instance);
       }
       else
       {
-        if constexpr (std::is_constructible_v<T, T> && !std::is_convertible_v<T, T>)
-        {
-          using Intrinsic_T = intrinsic_type<T>;
-          return T(*Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner()));
-        }
-        else
-        {
-          using Intrinsic_T = intrinsic_type<T>;
-          return *Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
-        }
+        return *instance;
       }
     }
 
@@ -361,6 +364,14 @@ namespace Rice::detail
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>>   && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate>   && !std::is_same_v<T, std::multimap<T, T>>      &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>>          &&
+                  !std::is_same_v<T, std::set<T>>      && !std::is_same_v<T, std::string>              &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     From_Ruby() = default;
 
@@ -384,14 +395,7 @@ namespace Rice::detail
     {
       using Intrinsic_T = intrinsic_type<T>;
 
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return this->arg_->template defaultValue<Intrinsic_T>();
-      }
-      else
-      {
-        return *Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
-      }
+      return *detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner()); 
     }
 
   private:
@@ -403,6 +407,14 @@ namespace Rice::detail
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     From_Ruby() = default;
 
@@ -426,55 +438,30 @@ namespace Rice::detail
     {
       using Intrinsic_T = intrinsic_type<T>;
 
-      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
-      {
-        return std::move(this->arg_->template defaultValue<Intrinsic_T>());
-      }
-      else
-      {
-        return std::move(*Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner()));
-      }
+      Intrinsic_T* object = detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
+      return std::move(*object);
     }
 
   private:
     Arg* arg_ = nullptr;
   };
 
-  // Helper class to convert a Ruby array of T to a C++ array of T (this happens when an API take T* as parameter
-  // along with a second size parameter)
-  template<typename T>
-  class ArrayHelper
-  {
-  public:
-    using Intrinsic_T = intrinsic_type<T>;
-
-    T* convert(VALUE value)
-    {
-      this->vector_ = Array(value).to_vector<T>();
-      return this->vector_.data();
-    }
-
-  private:
-    std::vector<Intrinsic_T> vector_;
-  };
-
   // 99% of the time a T* represents a wrapped C++ object that we want to call methods on. However, T* 
   // could also be a pointer to an array of T objects, so T[]. OpenCV for example has API calls like this.
-  //
-  // Therefore this From_Ruby implementation supports both uses cases which complicates the code. The problem
-  // is for T[] to compile, a class needs to be constructible, destructible and not abstract. A further wrinkle
-  // is if T has an explicit copy-constructor then that requires additional special handling in the code
-  // (see From_Ruby<T>). Whether this extra complication is worth it is debatable, but it does mean that 
-  // a Ruby array can be passed to any C++ API that takes a * including fundamental types (unsigned char)
-  // and class types (T).
-  //
-  // Note that the From_Ruby<T[]> specialization never matches a parameter defined in function as T[] - the C++ 
-  // compiler always picks T* instead. Not sure why...
+  // In that case, the Ruby VALUE will be a Buffer<T> instance
   template<typename T>
   class From_Ruby<T*>
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
     using Intrinsic_T = intrinsic_type<T>;
 
   public:
@@ -484,20 +471,19 @@ namespace Rice::detail
     {
     }
 
-    ~From_Ruby()
-    {
-      if constexpr (std::is_destructible_v<Intrinsic_T>)
-      {
-        delete this->arrayHelper_;
-      }
-    }
-
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
-          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          if (this->arg_ && this->arg_->isArray())
+          {
+            return Data_Type<Buffer<T>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          }
+          else
+          {
+            return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          }
           break;
         case RUBY_T_NIL:
           return Convertible::Exact;
@@ -514,28 +500,23 @@ namespace Rice::detail
     {
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
-        {
-          return Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
-          break;
-        }
         case RUBY_T_NIL:
         {
           return nullptr;
           break;
         }
-        case RUBY_T_ARRAY:
+        case RUBY_T_DATA:
         {
-          if constexpr (std::is_copy_constructible_v<Intrinsic_T> && std::is_destructible_v<Intrinsic_T> && !std::is_abstract_v<Intrinsic_T>)
+          if (this->arg_ && this->arg_->isArray())
+          {
+            using Buffer_T = Buffer<Intrinsic_T>;
+            Buffer_T* buffer = detail::unwrap<Buffer_T>(value, Data_Type<Buffer_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
+            return buffer->ptr();
+          }
+          else
           {
-            if (this->arrayHelper_ == nullptr)
-            {
-              this->arrayHelper_ = new ArrayHelper<T>();
-            }
-            return this->arrayHelper_->convert(value);
-            break;
+            return detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
           }
-          // Will fall through to the type exception if we get here
         }
         default:
         {
@@ -546,7 +527,6 @@ namespace Rice::detail
 
   private:
     Arg* arg_ = nullptr;
-    ArrayHelper<T>* arrayHelper_ = nullptr;
   };
 
   template<typename T>
@@ -554,6 +534,14 @@ namespace Rice::detail
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     From_Ruby() = default;
 
@@ -583,7 +571,7 @@ namespace Rice::detail
       }
       else
       {
-        return Data_Object<Intrinsic_T>::from_ruby(value, this->arg_ && this->arg_->isOwner());
+        return detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), this->arg_ && this->arg_->isOwner());
       }
     }
 
@@ -596,6 +584,14 @@ namespace Rice::detail
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
     using Intrinsic_T = intrinsic_type<T>;
   public:
     From_Ruby() = default;
@@ -609,7 +605,7 @@ namespace Rice::detail
       switch (rb_type(value))
       {
         case RUBY_T_DATA:
-          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+          return Data_Type<Buffer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
           break;
         case RUBY_T_NIL:
           return Convertible::Exact;
@@ -628,7 +624,8 @@ namespace Rice::detail
       {
         case RUBY_T_DATA:
         {
-          return detail::unwrap<Intrinsic_T*>(value, Data_Type<T>::ruby_data_type(), false);
+          Buffer<Intrinsic_T*>* buffer = detail::unwrap<Buffer<Intrinsic_T*>>(value, Data_Type<Buffer<Intrinsic_T*>>::ruby_data_type(), false);
+          return buffer->ptr();
           break;
         }
         case RUBY_T_NIL:
@@ -636,11 +633,6 @@ namespace Rice::detail
           return nullptr;
           break;
         }
-        case RUBY_T_ARRAY:
-        {
-          this->vector_ = Array(value).to_vector<Intrinsic_T*>();
-          return this->vector_.data();
-        }
         default:
         {
           throw create_type_exception<Intrinsic_T>(value);
@@ -658,6 +650,14 @@ namespace Rice::detail
   {
     static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
                   "Data_Object cannot be used with fundamental types");
+
+    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
+                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
+                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
+                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
+                  !std::is_same_v<T, std::vector<T>>,
+                  "Please include rice/stl.hpp header for STL support");
+
   public:
     Convertible is_convertible(VALUE value)
     {

data/rice/Data_Type.hpp

@@ -43,7 +43,7 @@ namespace Rice
      *  bound.
      *  \return *this
      */
-    virtual Data_Type & operator=(Module const & klass);
+    Data_Type& operator=(Module const & klass);
 
     /*! Creates a singleton method allocate and an instance method called
      *  initialize which together create a new instance of the class.  The
@@ -114,7 +114,8 @@ namespace Rice
      */
     static bool is_bound();
     static void check_is_bound();
-    static bool is_defined(Object parent, const std::string& name);
+    static bool is_defined();
+    static bool check_defined(const std::string& name, Object parent = rb_cObject);
 
     // This is only for testing - DO NOT USE!!!
     static void unbind();
@@ -174,9 +175,7 @@ namespace Rice
     // Typed Data support
     static inline rb_data_type_t* rb_data_type_ = nullptr;
 
-    // Track unbound instances (ie, declared variables of type Data_Type<T>
-    // before define_class is called)
-    static inline std::set<Data_Type<T>*>unbound_instances_;
+    static inline std::set<Data_Type<T>*>& unbound_instances();
   };
 
   //! Define a new data class in the namespace given by module.