rice 4.6.0 → 4.7.0

data/rice/Arg.ipp

@@ -70,14 +70,14 @@ namespace Rice
     return this->isOwner_;
   }
 
-  inline Arg& Arg::setArray()
+  inline Arg& Arg::setBuffer()
   {
-    this->isArray_ = true;
+    this->isBuffer_ = true;
     return *this;
   }
 
-  inline bool Arg::isArray()
+  inline bool Arg::isBuffer()
   {
-    return this->isArray_;
+    return this->isBuffer_;
   }
 } // Rice

data/rice/Buffer.hpp

@@ -3,15 +3,17 @@
 
 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> && !std::is_void_v<T>>>
   {
   public:
-    using type = T;
-
     Buffer(T* pointer);
     Buffer(T* pointer, size_t size);
     Buffer(VALUE value);
+    Buffer(VALUE value, size_t size);
 
     ~Buffer();
 
@@ -20,16 +22,16 @@ namespace Rice
 
     Buffer& operator=(const Buffer& other) = delete;
     Buffer& operator=(Buffer&& other);
+    T& operator[](size_t index);
 
     T* ptr();
     T& reference();
-    void release();
+    T* release();
 
     size_t size() const;
-    void setSize(size_t value);
 
     // Ruby API
-  //  VALUE toString() const;
+    VALUE toString() const;
 
     VALUE bytes() const;
     VALUE bytes(size_t count) const;
@@ -37,31 +39,70 @@ 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, size_t size);
+    void fromWrappedType(VALUE value, size_t size);
 
     bool m_owner = false;
     size_t m_size = 0;
-    // std::unique_ptr would be greate but std::unique_ptr<void> isn't allowed
-    T* m_buffer = nullptr;
+    // std::unique_ptr would be great but std::unique_ptr<void> isn't allowed. Mutable is needed to
+    // support const T* buffers
+    mutable T* m_buffer = nullptr;
   };
 
   template<typename T>
-  class Buffer<T*>
+  class Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>
   {
   public:
-    using type = T*;
+    Buffer(T** pointer);
+    Buffer(T** pointer, size_t size);
+    Buffer(VALUE value);
+    Buffer(VALUE value, size_t size);
+
+    ~Buffer();
+
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    T* operator[](size_t index);
+
+    T** ptr();
+    T** release();
+
+    size_t size() const;
+
+    // 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<typename T>
+  class Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>
+  {
+  public:
     Buffer(T** pointer);
     Buffer(T** pointer, size_t size);
     Buffer(VALUE value);
+    Buffer(VALUE value, size_t size);
 
     ~Buffer();
 
@@ -71,16 +112,15 @@ namespace Rice
     Buffer& operator=(const Buffer& other) = delete;
     Buffer& operator=(Buffer&& other);
 
-    const Buffer<T>& operator[](size_t index);
+    T* operator[](size_t index);
 
     T** ptr();
-    void release();
+    T** release();
 
     size_t size() const;
-    void setSize(size_t value);
 
     // Ruby API
-   // VALUE toString() const;
+    VALUE toString() const;
 
     VALUE bytes() const;
     VALUE bytes(size_t count) const;
@@ -94,30 +134,39 @@ namespace Rice
   private:
     bool m_owner = false;
     size_t m_size = 0;
-    T** m_outer = nullptr;
-    std::vector<Buffer<T>> m_inner;
+    T** m_buffer = nullptr;
   };
 
-  template<>
-  class Buffer<void>
+  template<typename T>
+  class Buffer<T, std::enable_if_t<std::is_void_v<T>>>
   {
   public:
-    Buffer(void* pointer);
+    Buffer(T* pointer);
+    Buffer(VALUE value);
+    Buffer(VALUE value, size_t size);
+
     Buffer(const Buffer& other) = delete;
     Buffer(Buffer&& other);
 
     Buffer& operator=(const Buffer& other) = delete;
     Buffer& operator=(Buffer&& other);
 
-    void* ptr();
+    size_t size() const;
+      
+    VALUE bytes(size_t count) const;
+    VALUE bytes() const;
+
+    T* ptr();
+    T* release();
 
   private:
-    void* m_buffer = nullptr;
+    bool m_owner = false;
+    size_t m_size = 0;
+    T* m_buffer = nullptr;
   };
 
   template<typename T>
   Data_Type<Buffer<T>> define_buffer(std::string klassName = "");
-
-  void define_fundamental_buffer_types();
 }
+
 #endif // Rice__Buffer__hpp_