Support Buffer of const elements.

Author: cfis

rice/Buffer.hpp

@@ -50,8 +50,9 @@ namespace Rice
 
     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>

rice/Buffer.ipp

@@ -52,7 +52,7 @@ namespace Rice
         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()));
+        memcpy((void*)this->m_buffer, RSTRING_PTR(packed.value()), RSTRING_LEN(packed.value()));
 
         this->m_owner = true;
         break;
@@ -69,18 +69,18 @@ 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<std::remove_cv_t<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);
+          (std::remove_cv_t<T>)this->m_buffer[0] = *detail::unwrap<T>(value, Data_Type<std::remove_cv_t<T>>::ruby_data_type(), false);
           this->m_owner = false;
           break;
         }
@@ -94,7 +94,7 @@ 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;
         }

test/test_Buffer.cpp

@@ -64,6 +64,31 @@ TESTCASE(CharArray)
   ASSERT_EQUAL(data[7], 1);
 }
 
+TESTCASE(ConstChar)
+{
+  define_buffer<const char>();
+
+  Module m = define_module("BufferTesting");
+
+  std::string code = R"(Rice::Buffer≺char const≻.new("my string"))";
+  Object object = m.instance_eval(code);
+  ASSERT_EQUAL("Rice::Buffer≺char const≻", object.class_name().c_str());
+
+  String bytes = object.call("bytes");
+  ASSERT_EQUAL(std::string("my string"), bytes.str());
+
+  Array array = object.call("to_ary");
+  ASSERT_EQUAL("109, 121, 32, 115, 116, 114, 105, 110, 103", array.join(", ").c_str());
+
+  Object size = object.call("size");
+  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(size));
+
+  Data_Object<Buffer<const char>> dataObject(object);
+  Buffer<const char> buffer = std::move(*dataObject);
+  ASSERT_EQUAL(std::string("my string"), std::string(buffer.ptr(), buffer.size()));
+  ASSERT_EQUAL(9, (int)buffer.size());
+}
+
 TESTCASE(signed_char_pointer)
 {
   define_buffer<signed char>();
@@ -330,6 +355,31 @@ TESTCASE(array_of_objects)
   Object result = m.module_eval(code);
   ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
 
+  code = R"(array = [MyClass.new(0), MyClass.new(1)]
+            buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass∗≻.new(array)
+            buffer[1] = MyClass.new(2)
+            buffer[1].id)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(array_of_const_objects)
+{
+  define_buffer<const MyClass*>();
+
+  define_class<MyClass>("MyClass").
+    define_constructor(Constructor<MyClass, int>()).
+    define_attr("id", &MyClass::id);
+
+  std::string code = R"(array = [MyClass.new(0), MyClass.new(1)]
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass∗≻.new(array)
+                        buffer[1].id)";
+
+  Module m = define_module("Testing");
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
+
   code = R"(array = [MyClass.new(0), MyClass.new(1)]
             buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass∗≻.new(array)
             buffer[1] = MyClass.new(2)