rice 4.6.1 → 4.7.0

data/rice/detail/Types.ipp

@@ -0,0 +1,430 @@
+namespace Rice::detail
+{
+  template<>
+  struct Type<bool>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cTrueClass;
+    }
+  };
+
+  template<>
+  struct Type<char>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<int N>
+  struct Type<char[N]>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<char*>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<signed char>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+  
+  template<int N>
+  struct Type<signed char[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<signed char>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<unsigned char>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<int N>
+  struct Type<unsigned char[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<unsigned char>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+  
+  template<>
+  struct Type<short>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<short[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<short>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+  
+  template<>
+  struct Type<unsigned short>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<unsigned short[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<unsigned short>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<int>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<int[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<int>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<unsigned int>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<unsigned int[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<unsigned int>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<long>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<long[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<long>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<unsigned long>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<unsigned long[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<unsigned long>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+  
+  template<>
+  struct Type<long long>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<long long[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<long long>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<unsigned long long>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cInteger;
+    }
+  };
+
+  template<int N>
+  struct Type<unsigned long long[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<unsigned long long>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<float>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cFloat;
+    }
+  };
+
+  template<int N>
+  struct Type<float[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<float>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<double>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cFloat;
+    }
+  };
+
+  template<int N>
+  struct Type<double[N]>
+  {
+    static bool verify()
+    {
+      define_buffer<double>();
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cString;
+    }
+  };
+
+  template<>
+  struct Type<void>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cNilClass;
+    }
+  };
+
+  template<>
+  struct Type<void*>
+  {
+    static bool verify()
+    {
+      Type<Pointer<void>>::verify();
+      return true;
+    }
+  };
+}

data/rice/detail/Wrapper.hpp

@@ -63,6 +63,18 @@ namespace Rice::detail
     T* data_ = nullptr;
   };
 
+  template <typename T>
+  class Wrapper<T**> : public WrapperBase
+  {
+  public:
+    Wrapper(T** data, bool isOwner);
+    ~Wrapper();
+    void* get() override;
+
+  private:
+    T** data_ = nullptr;
+  };
+
   // ---- Helper Functions ---------
   template <typename T>
   void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data, bool isOwner);

data/rice/detail/Wrapper.ipp

@@ -94,6 +94,33 @@ namespace Rice::detail
     return (void*)this->data_;
   }
 
+  // ----  Wrapper** -----
+  template <typename T>
+  inline Wrapper<T**>::Wrapper(T** data, bool isOwner) : data_(data)
+  {
+    this->isOwner_ = isOwner;
+    this->isConst_ = std::is_const_v<std::remove_pointer_t<std::remove_pointer_t<T>>>;
+  }
+
+  template <typename T>
+  inline Wrapper<T**>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get());
+    if constexpr (std::is_destructible_v<T>)
+    {
+      if (this->isOwner_)
+      {
+        delete this->data_;
+      }
+    }
+  }
+
+  template <typename T>
+  inline void* Wrapper<T**>::get()
+  {
+    return (void*)this->data_;
+  }
+
   // ---- Helper Functions -------
   template <typename T>
   inline VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T& data, bool isOwner)
@@ -112,6 +139,21 @@ namespace Rice::detail
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
+    // std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> return true. Sigh.
+    else if constexpr (detail::is_std_vector_v<T>)
+    {
+      if constexpr (std::is_copy_constructible_v<typename T::value_type>)
+      {
+        wrapper = new Wrapper<T>(data);
+        result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
+      }
+      else
+      {
+        wrapper = new Wrapper<T>(std::move(data));
+        result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
+      }
+    }
+
     // Ruby is the owner so copy data
     else if constexpr (std::is_copy_constructible_v<T>)
     {
@@ -122,14 +164,15 @@ namespace Rice::detail
     // Ruby is the owner so move data
     else if constexpr (std::is_move_constructible_v<T>)
     {
-      wrapper = new Wrapper<T>(std::forward<T>(data));
+      wrapper = new Wrapper<T>(std::move(data));
       result = TypedData_Wrap_Struct(klass, rb_data_type, wrapper);
     }
 
     else
     {
+      detail::TypeMapper<T> typeMapper;
       std::string message = "Rice was directed to take ownership of a C++ object but it does not have an accessible copy or move constructor. Type: " +
-        typeName(typeid(T));
+        typeMapper.name();
       throw std::runtime_error(message);
     }