rice 4.6.0 → 4.7.0

data/rice/Buffer.ipp

@@ -2,35 +2,52 @@ namespace Rice
 {
   // ----  Buffer<T> ------- 
   template<typename T>
-  inline Buffer<T>::Buffer(T* pointer) : m_buffer(pointer)
+  inline Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::Buffer(T* pointer) : m_buffer(pointer)
   {
   }
 
   template<typename T>
-  inline Buffer<T>::Buffer(T* pointer, size_t size) : m_size(size), m_buffer(pointer)
+  inline Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::Buffer(T* pointer, size_t size) : m_size(size), m_buffer(pointer)
   {
   }
 
   template <typename T>
-  inline Buffer<T>::Buffer(VALUE value)
+  inline Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::Buffer(VALUE value) : Buffer(value, 0)
+  {
+  }
+
+  template <typename T>
+  inline Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::Buffer(VALUE value, size_t size)
   {
     if constexpr (std::is_fundamental_v<T>)
     {
-      this->fromRubyType(value);
+      this->fromBuiltinType(value, size);
     }
     else
     {
-      this->fromDataType(value);
+      this->fromWrappedType(value, size);
+    }
+  }
+
+  template <typename T>
+  inline Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::~Buffer()
+  {
+    if constexpr (std::is_destructible_v<T>)
+    {
+      if (this->m_owner)
+      {
+        delete[] this->m_buffer;
+      }
     }
   }
 
   template <typename T>
-  inline void Buffer<T>::fromRubyType(VALUE value)
+  inline void Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::fromBuiltinType(VALUE value, size_t size)
   {
     using Intrinsic_T = typename detail::intrinsic_type<T>;
     using RubyType_T = typename detail::RubyType<Intrinsic_T>;
-    ruby_value_type valueType = rb_type(value);
 
+    ruby_value_type valueType = rb_type(value);
     switch (valueType)
     {
       case RUBY_T_ARRAY:
@@ -39,9 +56,19 @@ namespace Rice
         this->m_size = array.size();
         this->m_buffer = new T[this->m_size]();
 
-        String packed = array.pack<Intrinsic_T>();
-        memcpy(this->m_buffer, RSTRING_PTR(packed.value()), RSTRING_LEN(packed.value()));
-
+        if constexpr (std::is_fundamental_v<T>)
+        {
+          String packed = array.pack<Intrinsic_T>();
+          memcpy((void*)this->m_buffer, RSTRING_PTR(packed.value()), RSTRING_LEN(packed.value()));
+        }
+        else
+        {
+          detail::From_Ruby<Intrinsic_T> fromRuby;
+          for (int i = 0; i < array.size(); i++)
+          {
+            this->m_buffer[0] = fromRuby.convert(array[i]);
+          }
+        }
         this->m_owner = true;
         break;
       }
@@ -57,21 +84,21 @@ namespace Rice
         {
           this->m_buffer = new T[this->m_size]();
         }
-        memcpy(this->m_buffer, RSTRING_PTR(value), this->m_size);
+        memcpy((void*)this->m_buffer, RSTRING_PTR(value), this->m_size);
 
         this->m_owner = true;
         break;
       }
       case RUBY_T_DATA:
       {
-        if (Data_Type<T>::is_descendant(value))
+        if (Data_Type<Pointer<T>>::is_descendant(value))
         {
-          this->m_size = 1;
-          this->m_buffer = new T[this->m_size]();
-          this->m_buffer[0] = *detail::unwrap<T>(value, Data_Type<T>::ruby_data_type(), false);
+          this->m_buffer = detail::unwrap<T>(value, Data_Type<Pointer<T>>::ruby_data_type(), false);
           this->m_owner = false;
+          this->m_size = size;
           break;
         }
+        [[fallthrough]];
       }
       default:
       {
@@ -82,13 +109,14 @@ namespace Rice
           T data = detail::protect(RubyType_T::fromRuby, value);
           this->m_size = 1;
           this->m_buffer = new T[this->m_size]();
-          memcpy(this->m_buffer, &data, sizeof(T));
+          memcpy((void*)this->m_buffer, &data, sizeof(T));
           this->m_owner = true;
           break;
         }
         else
         {
-          std::string typeName = detail::typeName(typeid(T));
+          detail::TypeMapper<T> typeMapper;
+          std::string typeName = typeMapper.name();
           throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
             detail::protect(rb_obj_classname, value), typeName.c_str());
         }
@@ -97,7 +125,7 @@ namespace Rice
   }
 
   template <typename T>
-  inline void Buffer<T>::fromDataType(VALUE value)
+  inline void Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::fromWrappedType(VALUE value, size_t size)
   {
     using Intrinsic_T = typename detail::intrinsic_type<T>;
 
@@ -108,20 +136,68 @@ namespace Rice
         Array array(value);
         this->m_size = array.size();
 
-        // Use operator new[] to allocate memory but not call constructors
-        this->m_buffer = static_cast<T*>(operator new[](sizeof(T)* this->m_size));
+        // Use operator new[] to allocate memory but not call constructors.
+        size_t size = sizeof(T) * this->m_size;
+        this->m_buffer = static_cast<T*>(operator new[](size));
 
         detail::From_Ruby<Intrinsic_T> fromRuby;
 
         for (size_t i = 0; i < this->m_size; i++)
         {
-          this->m_buffer[i] = fromRuby.convert(array[i].value());
+          // Construct objects in allocated memory using move or copy construction
+          if constexpr (std::is_move_constructible_v<T>)
+          {
+            new (&this->m_buffer[i]) T(std::move(fromRuby.convert(array[i].value())));
+          }
+          else if constexpr (std::is_copy_constructible_v<T>)
+          {
+            new (&this->m_buffer[i]) T(fromRuby.convert(array[i].value()));
+          }
+          else
+          {
+            throw Exception(rb_eTypeError, "Cannot construct object of type %s - type is not move or copy constructible",
+              detail::TypeMapper<Intrinsic_T>().name().c_str());
+          }
         }
         break;
       }
+      case RUBY_T_DATA:
+      {
+        if (Data_Type<Pointer<Intrinsic_T>>::is_descendant(value))
+        {
+          this->m_buffer = detail::unwrap<T>(value, Data_Type<Pointer<Intrinsic_T>>::ruby_data_type(), false);
+          this->m_owner = false;
+          this->m_size = size;
+          break;
+        }
+        else if (Data_Type<Intrinsic_T>::is_descendant(value))
+        {
+          this->m_buffer = detail::unwrap<T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), false);
+          this->m_owner = false;
+          this->m_size = size;
+          break;
+        }
+      }
+      case RUBY_T_STRING:
+      {
+        // This special case is a bit ugly...
+        if constexpr (std::is_same_v<detail::intrinsic_type<T>, std::string>)
+        {
+          // FromRuby owns the converted string so we need to keep it alive until we get to the copy constructor
+          // two lines down
+          detail::From_Ruby<T*> fromRuby;
+          T* converted = fromRuby.convert(value);
+          this->m_buffer = new T[1]{ *converted };
+          this->m_owner = true;
+          this->m_size = 1;
+          break;
+        }
+        [[fallthrough]];
+      }
       default:
       {
-        std::string typeName = detail::typeName(typeid(T));
+        detail::TypeMapper<T> typeMapper;
+        std::string typeName = typeMapper.name();
         throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
@@ -129,19 +205,7 @@ namespace Rice
   }
 
   template <typename T>
-  inline Buffer<T>::~Buffer()
-  {
-    if constexpr (std::is_destructible_v<T>)
-    {
-      if (this->m_owner)
-      {
-        delete[] this->m_buffer;
-      }
-    }
-  }
-
-  template <typename T>
-  inline Buffer<T>::Buffer(Buffer<T>&& other) : m_owner(other.m_owner), m_size(other.m_size), m_buffer(other.m_buffer)
+  inline Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::Buffer(Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>&& other) : m_owner(other.m_owner), m_size(other.m_size), m_buffer(other.m_buffer)
   {
     other.m_buffer = nullptr;
     other.m_size = 0;
@@ -149,7 +213,7 @@ namespace Rice
   }
 
   template <typename T>
-  inline Buffer<T>& Buffer<T>::operator=(Buffer<T>&& other)
+  inline Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>& Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::operator=(Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>&& other)
   {
     this->m_buffer = other.m_buffer;
     other.m_buffer = nullptr;
@@ -164,57 +228,54 @@ namespace Rice
   }
 
   template <typename T>
-  inline size_t Buffer<T>::size() const
+  inline size_t Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::size() const
   {
     return this->m_size;
   }
 
   template <typename T>
-  void  Buffer<T>::setSize(size_t value)
+  inline T* Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::ptr()
   {
-    this->m_size = value;
+    return this->m_buffer;
   }
 
   template <typename T>
-  inline T* Buffer<T>::ptr()
+  inline T& Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::reference()
   {
-    return this->m_buffer;
+    return *this->m_buffer;
   }
 
   template <typename T>
-  inline T& Buffer<T>::reference()
+  inline T* Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::release()
   {
-    return *this->m_buffer;
+    this->m_owner = false;
+    return this->m_buffer;
   }
 
   template <typename T>
-  inline bool Buffer<T>::isOwner() const
+  inline bool Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::isOwner() const
   {
     return this->m_owner;
   }
 
   template <typename T>
-  inline void Buffer<T>::setOwner(bool value)
+  inline void Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::setOwner(bool value)
   {
     this->m_owner = value;
   }
 
-  template <typename T>
-  inline void Buffer<T>::release()
+  template<typename T>
+  inline VALUE Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::toString() const
   {
-    this->m_owner = false;
-  }
+    detail::TypeMapper<T*> typeMapper;
+    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
 
- /* template<typename T>
-  inline VALUE Buffer<T>::toString() const
-  {
-    std::string name = detail::typeName(typeid(T));
-    std::string result = "Buffer<type: " + detail::cppClassName(name) + ", size: " + std::to_string(this->m_size) + ">";
-    return detail::To_Ruby<std::string>().convert(result);
-  }*/
+    // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
+    return detail::protect(rb_utf8_str_new_cstr, description.c_str());
+  }
 
   template<typename T>
-  inline VALUE Buffer<T>::bytes(size_t count) const
+  inline VALUE Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::bytes(size_t count) const
   {
     if (!this->m_buffer)
     {
@@ -228,13 +289,13 @@ namespace Rice
   }
 
   template<typename T>
-  inline VALUE Buffer<T>::bytes() const
+  inline VALUE Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::bytes() const
   {
     return this->bytes(this->m_size);
   }
 
   template<typename T>
-  inline Array Buffer<T>::toArray(size_t count) const
+  inline Array Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::toArray(size_t count) const
   {
     if (!this->m_buffer)
     {
@@ -254,20 +315,20 @@ namespace Rice
 
       for (; ptr < end; ptr++)
       {
-        result.push(*ptr);
+        result.push(*ptr, false);
       }
       return result;
     }
   }
 
   template<typename T>
-  inline Array Buffer<T>::toArray() const
+  inline Array Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::toArray() const
   {
     return this->toArray(this->m_size);
   }
 
   template<typename T>
-  inline T Buffer<T>::get(size_t index) const
+  inline T& Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::operator[](size_t index)
   {
     if (index >= this->m_size)
     {
@@ -277,62 +338,79 @@ namespace Rice
     return this->m_buffer[index];
   }
 
+  // ----  Buffer<T*> - Builtin ------- 
   template<typename T>
-  inline void Buffer<T>::set(size_t index, T element)
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(T** pointer) : m_buffer(pointer)
   {
-    if (index >= this->m_size)
-    {
-      throw Exception(rb_eIndexError, "index %ld outside of bounds: 0..%ld", index, this->m_size);
-    }
-
-    this->m_buffer[index] = element;
   }
 
-  // ----  Buffer<T*> ------- 
   template<typename T>
-  inline Buffer<T*>::Buffer(T** pointer) : m_outer(pointer)
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_buffer(pointer), m_size(size)
   {
   }
 
-  template<typename T>
-  inline Buffer<T*>::Buffer(T** pointer, size_t size) : m_outer(pointer), m_size(size)
+  template <typename T>
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(VALUE value) : Buffer(value, 0)
   {
   }
-
+ 
   template <typename T>
-  inline Buffer<T*>::Buffer(VALUE value)
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(VALUE value, size_t size)
   {
-    ruby_value_type valueType = rb_type(value);
+    using Intrinsic_T = typename detail::intrinsic_type<T>;
 
+    ruby_value_type valueType = rb_type(value);
     switch (valueType)
     {
       case RUBY_T_ARRAY:
       {
         Array outer(value);
+
+        // Allocate outer buffer
         this->m_size = outer.size();
-        this->m_outer = new T * [this->m_size]();
+        this->m_buffer = new T*[this->m_size]();
 
         for (size_t i = 0; i < this->m_size; i++)
         {
           // Check the inner value is also an array
           Array inner(outer[i].value());
 
-          // Wrap it with a buffer and add it our list of inner buffers
-          Buffer<T> buffer(inner.value());
-
-          // And update the outer array
-          this->m_outer[i] = buffer.ptr();
+          // Allocate inner buffer
+          this->m_buffer[i] = new T[inner.size()]();
 
-          // Now move the buffer into the affer, not the buffer pointer is still valid (it just got moved)
-          this->m_inner.push_back(std::move(buffer));
+          if constexpr (std::is_fundamental_v<Intrinsic_T>)
+          {
+            String packed = inner.pack<Intrinsic_T>();
+            memcpy((void*)this->m_buffer[i], RSTRING_PTR(packed.value()), RSTRING_LEN(packed.value()));
+          }
+          else
+          {
+            detail::From_Ruby<Intrinsic_T*> fromRuby;
+            for (int i = 0; i < inner.size(); i++)
+            {
+              this->m_buffer[0] = fromRuby.convert(inner[i].value());
+            }
+          }
         }
 
         this->m_owner = true;
         break;
       }
+      case RUBY_T_DATA:
+      {
+        if (Data_Type<Pointer<T*>>::is_descendant(value))
+        {
+          this->m_buffer = detail::unwrap<T*>(value, Data_Type<Pointer<T*>>::ruby_data_type(), false);
+          this->m_owner = false;
+          this->m_size = size;
+          break;
+        }
+        [[fallthrough]];
+      }
       default:
       {
-        std::string typeName = detail::typeName(typeid(T));
+        detail::TypeMapper<T> typeMapper;
+        std::string typeName = typeMapper.name();
         throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
@@ -340,32 +418,33 @@ namespace Rice
   }
 
   template <typename T>
-  inline Buffer<T*>::~Buffer()
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::~Buffer()
   {
     if (this->m_owner)
     {
-      delete[] this->m_outer;
+      for (size_t i = 0; i < this->m_size; i++)
+      {
+        delete this->m_buffer[i];
+      }
+
+      delete[] this->m_buffer;
     }
   }
 
   template <typename T>
-  inline Buffer<T*>::Buffer(Buffer<T*>&& other) : m_owner(other.m_owner), m_size(other.m_size),
-                                                  m_outer(other.m_outer), m_inner(std::move(other.m_inner))
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>&& other) : m_owner(other.m_owner), m_size(other.m_size),
+                                                  m_buffer(other.m_buffer)
   {
-    other.m_outer = nullptr;
-    other.m_inner.clear();
+    other.m_buffer = nullptr;
     other.m_size = 0;
     other.m_owner = false;
   }
 
   template <typename T>
-  inline Buffer<T*>& Buffer<T*>::operator=(Buffer<T*>&& other)
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>& Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::operator=(Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>&& other)
   {
-    this->m_outer = other.m_outer;
-    other.m_outer = nullptr;
-
-    this->m_inner = std::move(other.m_inner);
-    other.m_inner.clear();
+    this->m_buffer = other.m_buffer;
+    other.m_buffer = nullptr;
 
     this->m_size = other.m_size;
     other.m_size = 0;
@@ -377,80 +456,269 @@ namespace Rice
   }
 
   template <typename T>
-  inline const Buffer<T>& Buffer<T*>::operator[](size_t index)
+  inline T* Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::operator[](size_t index)
   {
-    return this->m_inner[index];
+    return this->m_buffer[index];
   }
 
   template <typename T>
-  inline size_t Buffer<T*>::size() const
+  inline size_t Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::size() const
   {
     return this->m_size;
   }
 
   template <typename T>
-  void  Buffer<T*>::setSize(size_t value)
+  inline T** Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::ptr()
   {
-    this->m_size = value;
+    return this->m_buffer;
   }
 
   template <typename T>
-  inline T** Buffer<T*>::ptr()
+  inline T** Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::release()
   {
-    return this->m_outer;
+    this->m_owner = false;
+    return this->m_buffer;
   }
 
   template <typename T>
-  inline bool Buffer<T*>::isOwner() const
+  inline bool Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::isOwner() const
   {
     return this->m_owner;
   }
 
   template <typename T>
-  inline void Buffer<T*>::setOwner(bool value)
+  inline void Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::setOwner(bool value)
   {
     this->m_owner = value;
   }
 
+  template<typename T>
+  inline VALUE Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::toString() const
+  {
+    detail::TypeMapper<T*> typeMapper;
+    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+
+    // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
+    return detail::protect(rb_utf8_str_new_cstr, description.c_str());
+  }
+
+  template<typename T>
+  inline VALUE Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::bytes(size_t count) const
+  {
+    if (!this->m_buffer)
+    {
+      return Qnil;
+    }
+    else
+    {
+      T** begin = this->m_buffer;
+      long length = (long)(count * sizeof(T*));
+      return detail::protect(rb_str_new_static, (const char*)*begin, length);
+    }
+  }
+
+  template<typename T>
+  inline VALUE Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::bytes() const
+  {
+    return this->bytes(this->m_size);
+  }
+
+  template<typename T>
+  inline Array Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::toArray(size_t count) const
+  {
+    if (!this->m_buffer)
+    {
+      return Qnil;
+    }
+    else
+    {
+      Array result;
+
+      T** ptr = this->m_buffer;
+      T** end = this->m_buffer + count;
+
+      for (; ptr < end; ptr++)
+      {
+        Buffer<T> buffer(*ptr);
+        result.push(std::move(buffer), true);
+      }
+      return result;
+    }
+  }
+
+  template<typename T>
+  inline Array Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::toArray() const
+  {
+    return this->toArray(this->m_size);
+  }
+
+  // ----  Buffer<T*> - Wrapped ------- 
+  template<typename T>
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(T** pointer) : m_buffer(pointer)
+  {
+  }
+
+  template<typename T>
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_buffer(pointer), m_size(size)
+  {
+  }
+
   template <typename T>
-  inline void Buffer<T*>::release()
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(VALUE value) : Buffer(value, 0)
+  {
+  }
+  
+  template <typename T>
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(VALUE value, size_t size)
+  {
+    ruby_value_type valueType = rb_type(value);
+    switch (valueType)
+    {
+      case RUBY_T_ARRAY:
+      {
+        Array array(value);
+        this->m_size = array.size();
+        this->m_buffer = new T * [this->m_size]();
+
+        detail::From_Ruby<T*> fromRuby;
+
+        for (size_t i = 0; i < this->m_size; i++)
+        {
+          this->m_buffer[i] = fromRuby.convert(array[i].value());
+        }
+
+        this->m_owner = true;
+        break;
+      }
+      case RUBY_T_DATA:
+      {
+        if (Data_Type<Pointer<T*>>::is_descendant(value))
+        {
+          this->m_buffer = detail::unwrap<T*>(value, Data_Type<Pointer<T*>>::ruby_data_type(), false);
+          this->m_owner = false;
+          this->m_size = size;
+          break;
+        }
+      }
+      default:
+      {
+        detail::TypeMapper<T> typeMapper;
+        std::string typeName = typeMapper.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+          detail::protect(rb_obj_classname, value), typeName.c_str());
+      }
+    }
+  }
+
+  template <typename T>
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::~Buffer()
+  {
+    if (this->m_owner)
+    {
+      delete[] this->m_buffer;
+    }
+  }
+
+  template <typename T>
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>&& other) : m_owner(other.m_owner), m_size(other.m_size),
+    m_buffer(other.m_buffer)
+  {
+    other.m_buffer = nullptr;
+    other.m_size = 0;
+    other.m_owner = false;
+  }
+
+  template <typename T>
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>& Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::operator=(Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>&& other)
+  {
+    this->m_buffer = other.m_buffer;
+    other.m_buffer = nullptr;
+
+    this->m_size = other.m_size;
+    other.m_size = 0;
+
+    this->m_owner = other.m_owner;
+    other.m_owner = false;
+
+    return *this;
+  }
+
+  template <typename T>
+  inline T* Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::operator[](size_t index)
+  {
+    if (index >= this->m_size)
+    {
+      throw Exception(rb_eIndexError, "index %ld outside of bounds: 0..%ld", index, this->m_size);
+    }
+    return this->m_buffer[index];
+  }
+
+  template <typename T>
+  inline size_t Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::size() const
+  {
+    return this->m_size;
+  }
+
+  template <typename T>
+  inline T** Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::ptr()
+  {
+    return this->m_buffer;
+  }
+
+  template <typename T>
+  inline T** Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::release()
   {
     this->m_owner = false;
+    return this->m_buffer;
+  }
+
+  template <typename T>
+  inline bool Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::isOwner() const
+  {
+    return this->m_owner;
+  }
+
+  template <typename T>
+  inline void Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::setOwner(bool value)
+  {
+    this->m_owner = value;
   }
 
-  /*template<typename T>
-  inline VALUE Buffer<T*>::toString() const
+  template<typename T>
+  inline VALUE Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::toString() const
   {
-    std::string name = detail::typeName(typeid(T*));
-    std::string result = "Buffer<type: " + detail::cppClassName(name) + ", size: " + std::to_string(this->m_size) + ">";
-    return detail::To_Ruby<std::string>().convert(result);
-  }*/
+    detail::TypeMapper<T*> typeMapper;
+    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+
+    // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
+    return detail::protect(rb_utf8_str_new_cstr, description.c_str());
+  }
 
   template<typename T>
-  inline VALUE Buffer<T*>::bytes(size_t count) const
+  inline VALUE Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::bytes(size_t count) const
   {
-    if (!this->m_outer)
+    if (!this->m_buffer)
     {
       return Qnil;
     }
     else
     {
-      T** begin = this->m_outer;
+      T** begin = this->m_buffer;
       long length = (long)(count * sizeof(T*));
       return detail::protect(rb_str_new_static, (const char*)*begin, length);
     }
   }
 
   template<typename T>
-  inline VALUE Buffer<T*>::bytes() const
+  inline VALUE Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::bytes() const
   {
     return this->bytes(this->m_size);
   }
 
   template<typename T>
-  inline Array Buffer<T*>::toArray(size_t count) const
+  inline Array Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::toArray(size_t count) const
   {
-    if (!this->m_outer)
+    if (!this->m_buffer)
     {
       return Qnil;
     }
@@ -458,35 +726,70 @@ namespace Rice
     {
       Array result;
 
-      T** ptr = this->m_outer;
-      T** end = this->m_outer + count;
+      T** ptr = this->m_buffer;
+      T** end = this->m_buffer + count;
 
       for (; ptr < end; ptr++)
       {
-        Buffer<T> buffer(*ptr);
-        result.push(std::move(buffer));
+        result.push(*ptr, false);
       }
       return result;
     }
   }
 
   template<typename T>
-  inline Array Buffer<T*>::toArray() const
+  inline Array Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::toArray() const
   {
     return this->toArray(this->m_size);
   }
 
   // ----  Buffer<void> ------- 
-  inline Buffer<void>::Buffer(void* pointer) : m_buffer(pointer)
+  template<typename T>
+  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(VALUE value) : Buffer(value, 0)
+  {
+  }
+  
+  template<typename T>
+  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(VALUE value, size_t size)
+  {
+    ruby_value_type valueType = rb_type(value);
+
+    switch (valueType)
+    {
+      case RUBY_T_STRING:
+      {
+        this->m_size = RSTRING_LEN(value);
+        this->m_buffer = ::operator new(this->m_size);
+        memcpy((void*)this->m_buffer, RSTRING_PTR(value), this->m_size);
+
+        this->m_owner = true;
+        break;
+      }
+      default:
+      {
+        detail::TypeMapper<void> typeMapper;
+        std::string typeName = typeMapper.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+          detail::protect(rb_obj_classname, value), typeName.c_str());
+      }
+    }
+  }
+
+  template<typename T>
+  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(T* pointer) : m_buffer(pointer)
   {
   }
 
-  inline Buffer<void>::Buffer(Buffer<void>&& other) : m_buffer(other.m_buffer)
+  template<typename T>
+  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(Buffer<T, std::enable_if_t<std::is_void_v<T>>>&& other) : m_owner(other.m_owner), m_size(other.m_size), m_buffer(other.m_buffer)
   {
     other.m_buffer = nullptr;
+    other.m_size = 0;
+    other.m_owner = false;
   }
 
-  inline Buffer<void>& Buffer<void>::operator=(Buffer<void>&& other)
+  template<typename T>
+  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>& Buffer<T, std::enable_if_t<std::is_void_v<T>>>::operator=(Buffer<T, std::enable_if_t<std::is_void_v<T>>>&& other)
   {
     this->m_buffer = other.m_buffer;
     other.m_buffer = nullptr;
@@ -494,89 +797,108 @@ namespace Rice
     return *this;
   }
 
-  inline void* Buffer<void>::ptr()
+  template<typename T>
+  inline size_t Buffer<T, std::enable_if_t<std::is_void_v<T>>>::size() const
+  {
+    return this->m_size;
+  }
+
+  template<typename T>
+  inline T* Buffer<T, std::enable_if_t<std::is_void_v<T>>>::ptr()
   {
     return this->m_buffer;
   }
 
+  template <typename T>
+  inline T* Buffer<T, std::enable_if_t<std::is_void_v<T>>>::release()
+  {
+    this->m_owner = false;
+    return this->m_buffer;
+  }
+
+  template<typename T>
+  inline VALUE Buffer<T, std::enable_if_t<std::is_void_v<T>>>::bytes(size_t count) const
+  {
+    if (!this->m_buffer)
+    {
+      return Qnil;
+    }
+    else
+    {
+      return detail::protect(rb_usascii_str_new, (const char*)this->m_buffer, (long)count);
+    }
+  }
+
+  template<typename T>
+  inline VALUE Buffer<T, std::enable_if_t<std::is_void_v<T>>>::bytes() const
+  {
+    return this->bytes(this->m_size);
+  }
+
   // ------  define_buffer ----------
   template<typename T>
   inline Data_Type<Buffer<T>> define_buffer(std::string klassName)
   {
     using Buffer_T = Buffer<T>;
+    using Data_Type_T = Data_Type<Buffer_T>;
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Buffer_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Buffer_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mRice = define_module("Rice");
 
+    if (Data_Type_T::check_defined(klassName, rb_mRice))
+    {
+      return Data_Type_T();
+    }
+
     if constexpr (std::is_void_v<T>)
     {
-      return define_class_under<Buffer_T>(rb_mRice, klassName);
+      return define_class_under<Buffer_T>(rb_mRice, klassName).
+        define_constructor(Constructor<Buffer_T, VALUE>(), Arg("value").setValue()).
+        define_constructor(Constructor<Buffer_T, VALUE, size_t>(), Arg("value").setValue(), Arg("size")).
+        define_method("size", &Buffer_T::size).
+        template define_method<VALUE(Buffer_T::*)(size_t) const>("bytes", &Buffer_T::bytes, Return().setValue()).
+        template define_method<VALUE(Buffer_T::*)() const>("bytes", &Buffer_T::bytes, Return().setValue()).
+        define_method("data", &Buffer_T::ptr, Return().setBuffer()).
+        define_method("release", &Buffer_T::release, Return().setBuffer());
     }
     else
     {
       Data_Type<Buffer_T> klass = define_class_under<Buffer_T>(rb_mRice, klassName).
         define_constructor(Constructor<Buffer_T, VALUE>(), Arg("value").setValue()).
+        define_constructor(Constructor<Buffer_T, VALUE, size_t>(), Arg("value").setValue(), Arg("size")).
         define_method("size", &Buffer_T::size).
-        define_method("size=", &Buffer_T::setSize).
-       // template define_method<VALUE(Buffer_T::*)() const>("to_s", &Buffer_T::toString, Return().setValue()).
+        template define_method<VALUE(Buffer_T::*)() const>("to_s", &Buffer_T::toString, Return().setValue()).
         template define_method<VALUE(Buffer_T::*)(size_t) const>("bytes", &Buffer_T::bytes, Return().setValue()).
         template define_method<VALUE(Buffer_T::*)() const>("bytes", &Buffer_T::bytes, Return().setValue()).
         template define_method<Array(Buffer_T::*)(size_t) const>("to_ary", &Buffer_T::toArray, Return().setValue()).
-        template define_method<Array(Buffer_T::*)() const>("to_ary", &Buffer_T::toArray, Return().setValue());
+        template define_method<Array(Buffer_T::*)() const>("to_ary", &Buffer_T::toArray, Return().setValue()).
+        define_method("[]", &Buffer_T::operator[], Arg("index")).
+        define_method("data", &Buffer_T::ptr, Return().setBuffer()).
+        define_method("release", &Buffer_T::release, Return().setBuffer());
 
-      if constexpr (!std::is_pointer_v<T>)
+      if constexpr (!std::is_pointer_v<T> && !std::is_void_v<T> && !std::is_const_v<T> && std::is_copy_assignable_v<T>)
       {
-        klass.
-          define_method("[]", [](const Buffer_T& self, size_t index) -> T
-          {
-            return self.get(index);
-          }).
-          define_method("[]=", [](Buffer_T& self, size_t index, T element) -> void
-          {
-            self.set(index, element);
-          });
+        klass.define_method("[]=", [](Buffer_T& self, size_t index, T& value) -> void
+        {
+          self[index] = value;
+        });
+      }
+      else if constexpr (std::is_pointer_v<T> && !std::is_const_v<std::remove_pointer_t<T>> && std::is_copy_assignable_v<std::remove_pointer_t<T>>)
+      {
+        klass.define_method("[]=", [](Buffer_T& self, size_t index, T value) -> void
+        {
+          *self[index] = *value;
+        });
       }
 
       return klass;
     }
   }
-
-  inline void define_fundamental_buffer_types()
-  {
-    define_buffer<bool>();
-    define_buffer<int>();
-    define_buffer<int*>();
-    define_buffer<unsigned int>();
-    define_buffer<unsigned int*>();
-    define_buffer<char>();
-    define_buffer<char*>();
-    define_buffer<unsigned char>();
-    define_buffer<unsigned char*>();
-    define_buffer<signed char>();
-    define_buffer<signed char*>();
-    define_buffer<double>();
-    define_buffer<double*>();
-    define_buffer<float>();
-    define_buffer<float*>();
-    define_buffer<long>();
-    define_buffer<long*>();
-    define_buffer<unsigned long>();
-    define_buffer<unsigned long*>();
-    define_buffer<long long>();
-    define_buffer<long long*>();
-    define_buffer<unsigned long long>();
-    define_buffer<unsigned long long*>();
-    define_buffer<short>();
-    define_buffer<short*>();
-    define_buffer<unsigned short>();
-    define_buffer<unsigned short*>();
-    define_buffer<void>();
-  }
 }
 
 namespace Rice::detail
@@ -586,13 +908,8 @@ namespace Rice::detail
   {
     static bool verify()
     {
-      Type<intrinsic_type<T>>::verify();
-
-      if (!Data_Type<Buffer<T>>::is_defined())
-      {
-        define_buffer<T>();
-      }
-
+      detail::verifyType<T>();
+      define_buffer<T>();
       return true;
     }
   };