rice 4.6.0 → 4.6.1

data/include/rice/stl.hpp

@@ -3771,68 +3771,67 @@ namespace Rice
           }
         })
         .define_method("last", [](const T& vector) -> std::optional<Value_T>
+        {
+          if (vector.size() > 0)
           {
-            if (vector.size() > 0)
-            {
-              return vector.back();
-            }
-            else
-            {
-              return std::nullopt;
-            }
-          })
+            return vector.back();
+          }
+          else
+          {
+            return std::nullopt;
+          }
+        })
         .define_method("[]", [this](const T& vector, Difference_T index) -> std::optional<Value_T>
+        {
+          index = normalizeIndex(vector.size(), index);
+          if (index < 0 || index >= (Difference_T)vector.size())
           {
-            index = normalizeIndex(vector.size(), index);
-            if (index < 0 || index >= (Difference_T)vector.size())
-            {
-              return std::nullopt;
-            }
-            else
-            {
-              return vector[index];
-            }
-          })
+            return std::nullopt;
+          }
+          else
+          {
+            return vector[index];
+          }
+        })
         .define_method("[]", [this](const T& vector, Difference_T start, Difference_T length) -> VALUE
+        {
+          start = normalizeIndex(vector.size(), start);
+          if (start < 0 || start >= (Difference_T)vector.size())
+          {
+            return rb_ary_new();
+          }
+          else
           {
-            start = normalizeIndex(vector.size(), start);
-            if (start < 0 || start >= (Difference_T)vector.size())
+            auto begin = vector.begin() + start;
+
+            // Ruby does not throw an exception when the length is too long
+            Difference_T size = (Difference_T)vector.size();
+            if (start + length > size)
             {
-              return rb_ary_new();
+              length = size - start;
             }
-            else
-            {
-              auto begin = vector.begin() + start;
-
-              // Ruby does not throw an exception when the length is too long
-              Difference_T size = (Difference_T)vector.size();
-              if (start + length > size)
-              {
-                length = size - start;
-              }
 
-              auto finish = vector.begin() + start + length;
-              T slice(begin, finish);
+            auto finish = vector.begin() + start + length;
+            T slice(begin, finish);
 
-              VALUE result = rb_ary_new();
-              std::for_each(slice.begin(), slice.end(), [&result](const Reference_T element)
-              {
-                VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
-                rb_ary_push(result, value);
-              });
-
-              return result;
-            }
-          }, Return().setValue());
+            VALUE result = rb_ary_new();
+            std::for_each(slice.begin(), slice.end(), [&result](const Reference_T element)
+            {
+              VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
+              rb_ary_push(result, value);
+            });
 
-          if constexpr (!std::is_same_v<Value_T, bool>)
-          {
-            define_buffer<Value_T>();
-            define_buffer<Value_T*>();
-            klass_.template define_method<Value_T*(T::*)()>("data", &T::data);
+            return result;
           }
+        }, Return().setValue());
+
+        if constexpr (!std::is_same_v<Value_T, bool>)
+        {
+          define_buffer<Value_T>();
+          klass_.template define_method<Value_T*(T::*)()>("data", &T::data);
+        }
 
-          rb_define_alias(klass_, "at", "[]");
+        rb_define_alias(klass_, "at", "[]");
       }
 
       // Methods that require Value_T to support operator==

data/lib/rice/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.6.0"
+  VERSION = "4.6.1"
 end

data/rice/Buffer.hpp

@@ -3,11 +3,14 @@
 
 namespace Rice
 {
+  template<typename T, typename = void>
+  class Buffer;
+    
   template<typename T>
-  class Buffer
+  class Buffer<T, std::enable_if_t<!std::is_pointer_v<T>>>
   {
   public:
-    using type = T;
+    using Element_T = T;
 
     Buffer(T* pointer);
     Buffer(T* pointer, size_t size);
@@ -20,6 +23,7 @@ namespace Rice
 
     Buffer& operator=(const Buffer& other) = delete;
     Buffer& operator=(Buffer&& other);
+    T& operator[](size_t index);
 
     T* ptr();
     T& reference();
@@ -29,7 +33,7 @@ namespace Rice
     void setSize(size_t value);
 
     // Ruby API
-  //  VALUE toString() const;
+    VALUE toString() const;
 
     VALUE bytes() const;
     VALUE bytes(size_t count) const;
@@ -37,15 +41,12 @@ namespace Rice
     Array toArray() const;
     Array toArray(size_t count) const;
 
-    T get(size_t index) const;
-    void set(size_t index, T value);
-
     bool isOwner() const;
     void setOwner(bool value);
 
   private:
-    void fromRubyType(VALUE value);
-    void fromDataType(VALUE value);
+    void fromBuiltinType(VALUE value);
+    void fromWrappedType(VALUE value);
 
     bool m_owner = false;
     size_t m_size = 0;
@@ -54,10 +55,10 @@ namespace Rice
   };
 
   template<typename T>
-  class Buffer<T*>
+  class Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>
   {
   public:
-    using type = T*;
+    using Element_T = Buffer<T>;
 
     Buffer(T** pointer);
     Buffer(T** pointer, size_t size);
@@ -71,7 +72,7 @@ namespace Rice
     Buffer& operator=(const Buffer& other) = delete;
     Buffer& operator=(Buffer&& other);
 
-    const Buffer<T>& operator[](size_t index);
+    Element_T& operator[](size_t index);
 
     T** ptr();
     void release();
@@ -80,7 +81,7 @@ namespace Rice
     void setSize(size_t value);
 
     // Ruby API
-   // VALUE toString() const;
+    VALUE toString() const;
 
     VALUE bytes() const;
     VALUE bytes(size_t count) const;
@@ -98,6 +99,50 @@ namespace Rice
     std::vector<Buffer<T>> m_inner;
   };
 
+  template<typename T>
+  class Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>
+  {
+  public:
+    using Element_T = T*;
+
+    Buffer(T** pointer);
+    Buffer(T** pointer, size_t size);
+    Buffer(VALUE value);
+
+    ~Buffer();
+
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    Element_T& operator[](size_t index);
+
+    T** ptr();
+    void release();
+
+    size_t size() const;
+    void setSize(size_t value);
+
+    // Ruby API
+    VALUE toString() const;
+
+    VALUE bytes() const;
+    VALUE bytes(size_t count) const;
+
+    Array toArray() const;
+    Array toArray(size_t count) const;
+
+    void setOwner(bool value);
+    bool isOwner() const;
+
+  private:
+    bool m_owner = false;
+    size_t m_size = 0;
+    T** m_buffer = nullptr;
+  };
+
   template<>
   class Buffer<void>
   {