arraybuffer 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54a97a398cfc2dba3f1e7be91ad4270c5cda76d80d3a537e928f55c69a5a884d
-  data.tar.gz: 89a6d372984df0af25cc325f9df08819eb28f1b04a49998226f4efccb425ff4c
+  metadata.gz: 82dc4ee3054dbbe61e080e0ea27591f92cf50e20b1cfd4259915a97b796e6b3e
+  data.tar.gz: 17200f6002a0b1ace4e94de035fc1b3eebbce01559e0cea0e96c1125ef4a1e9d
 SHA512:
-  metadata.gz: 4cc867ac7554a8da0df51f40609f53e3fef3ab4b41d3b53252910330cc12f80959d41cfeaab2b1ac64476eaa48da7df1664f9d01f54928d67a7f6d2b0d172bb2
-  data.tar.gz: 9db2cf2cde11394abd9cb850d02a156658e0a770ae230f2104fce0697382459199b040829b54f9dff37e31409e2c2944883201c9a014b47b41f24e3f74836c24
+  metadata.gz: aba9d04396abf1eeb40561d0801399cdc49b917e3c7a3c44f23fa580c17fde9dfdc8f77258ccba2adeaf24cb3d6cd2c6bb2206edf60f301b714d5750a6748c0a
+  data.tar.gz: 9be6cb003e01b9f3a14e04c0e69e68f52390fc5efe8c8c35144d51b85e8946dfa24fb0b9cda8693c49ad935b797aeffee6830e5954cf1c85df4a7101c8855302

data/ext/arraybuffer/arraybuffer.c

@@ -2,6 +2,10 @@
 #include "extconf.h"
 #include <string.h>
 
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+#include <ruby/memory_view.h>
+#endif
+
 extern VALUE cArrayBuffer;
 
 #define DECLAREBB(self) \
@@ -12,15 +16,43 @@ extern VALUE cArrayBuffer;
     rb_raise(rb_eArgError, "Index out of bounds: %d", (idx)); \
   }
 
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+static bool
+r_bb_mv_get(VALUE self, rb_memory_view_t *view, int flags) {
+  DECLAREBB(self);
+  if (!bb->size)
+    return 0;
+  rb_memory_view_init_as_byte_array(view, self, bb->ptr, (const ssize_t)bb->size, 0);
+  return 1;
+}
+
+// static bool
+// r_bb_mv_release(VALUE self, rb_memory_view_t *view) {
+//   return 1;
+// }
+
+static bool
+r_bb_mv_available_p(VALUE self) {
+  DECLAREBB(self);
+  return bb->size > 0 ? 1 : 0;
+}
+
+static rb_memory_view_entry_t cArrayBufferMemoryView = {
+  r_bb_mv_get,
+  NULL, // r_bb_mv_release,
+  r_bb_mv_available_p
+};
+#endif
+
 static void
 t_bb_gc_mark(struct LLC_ArrayBuffer *bb) {
+  if (bb->backing_str) {
+    rb_gc_mark(bb->backing_str);
+  }
 }
 
 static void
 t_bb_free(struct LLC_ArrayBuffer *bb) {
-  if (bb->ptr)
-    xfree(bb->ptr);
-
   xfree(bb);
 }
 
@@ -29,18 +61,37 @@ t_bb_allocator(VALUE klass) {
   struct LLC_ArrayBuffer *bb = (struct LLC_ArrayBuffer*)xmalloc(sizeof(struct LLC_ArrayBuffer));
   bb->ptr = NULL;
   bb->size = 0;
+  bb->backing_str = NULL;
 
   return Data_Wrap_Struct(klass, t_bb_gc_mark, t_bb_free, bb);
 }
 
+#define BB_BACKING_PTR(bb) \
+  (FL_TEST((bb)->backing_str, RSTRING_NOEMBED) ? RSTRING((bb)->backing_str)->as.heap.ptr : &RSTRING(bb->backing_str)->as.ary)
+
+static void
+t_bb_reassign_ptr(struct LLC_ArrayBuffer *bb) {
+  if (!bb->backing_str) {
+    bb->ptr = NULL;
+    return;
+  }
+
+  rb_str_set_len(bb->backing_str, bb->size);
+  bb->ptr = BB_BACKING_PTR(bb);
+  bb->ptr[bb->size] = 0;
+}
+
 static VALUE
 t_bb_initialize(VALUE self, VALUE size) {
   DECLAREBB(self);
   unsigned int s = NUM2UINT(size);
   bb->size = s;
-  if (bb->ptr)
-    xfree(bb->ptr);
-  bb->ptr = xmalloc(s);
+  if (bb->backing_str)
+    rb_gc_mark(bb->backing_str);
+
+  bb->backing_str = rb_str_buf_new(s);
+
+  t_bb_reassign_ptr(bb);
   memset(bb->ptr, 0, (size_t)s);
   return self;
 }
@@ -96,31 +147,9 @@ t_bb_realloc(VALUE self, VALUE _new_size) {
   if (new_size == bb->size)
     return self;
 
-  void *old_ptr = (void*)bb->ptr;
-  if (new_size > 0) {
-    char *new_ptr = (void*)xmalloc(new_size);
-    if (old_ptr) {
-      if (new_size > bb->size) {
-        size_t diff = (size_t)(new_size - bb->size);
-        memcpy(new_ptr, old_ptr, (size_t)bb->size);
-        xfree(old_ptr);
-        old_ptr = NULL;
-        memset((char*)new_ptr + (size_t)bb->size, 0, diff);
-      } else {
-        memcpy(new_ptr, old_ptr, (size_t)new_size);
-      }
-    } else {
-      memset(new_ptr, 0, new_size);
-    }
-    bb->size = new_size;
-    bb->ptr = (unsigned char*)new_ptr;
-  } else {
-    bb->size = 0;
-    bb->ptr = NULL;
-  }
-
-  if (old_ptr)
-    xfree(old_ptr);
+  rb_str_resize(bb->backing_str, new_size);
+  bb->size = new_size;
+  t_bb_reassign_ptr(bb);
 
   return self;
 }
@@ -128,8 +157,8 @@ t_bb_realloc(VALUE self, VALUE _new_size) {
 /*
  * Returns a ASCII-8BIT string with the contents of the buffer
  *
- * The returned string is a copy of the buffer. It's encoding is always
- * ASCII-8BIT.
+ * The returned string is the backing string of the buffer.
+ * It's encoding is always ASCII-8BIT.
  * If the buffer has size zero, an empty string is returned.
  *
  * @return [String]
@@ -137,9 +166,7 @@ t_bb_realloc(VALUE self, VALUE _new_size) {
 static VALUE
 t_bb_bytes(VALUE self) {
   DECLAREBB(self);
-  return rb_tainted_str_new(
-    (const char*)bb->ptr,
-    bb->size);
+  return bb->backing_str;
 }
 
 void
@@ -156,4 +183,9 @@ Init_arraybuffer() {
   rb_define_method(cArrayBuffer, "each", t_bb_each, 0);
   rb_define_method(cArrayBuffer, "realloc", t_bb_realloc, 1);
   rb_define_method(cArrayBuffer, "bytes", t_bb_bytes, 0);
+  rb_define_method(cArrayBuffer, "to_s", t_bb_bytes, 0);
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+  rb_memory_view_register(cArrayBuffer, &cArrayBufferMemoryView);
+#endif
 }

data/ext/arraybuffer/arraybuffer.h

@@ -6,6 +6,7 @@
 struct LLC_ArrayBuffer {
   unsigned char *ptr;
   unsigned int size;
+  VALUE backing_str;
 };
 
 #endif

data/ext/arraybuffer/dataview.c

@@ -6,6 +6,10 @@
 #include <string.h>
 #endif
 
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+#include <ruby/memory_view.h>
+#endif
+
 extern VALUE cArrayBuffer;
 extern VALUE cDataView;
 
@@ -42,6 +46,39 @@ t_dv_allocator(VALUE klass) {
   return Data_Wrap_Struct(klass, t_dv_gc_mark, t_dv_free, dv);
 }
 
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+static bool
+r_dv_mv_get(VALUE self, rb_memory_view_t *view, int flags) {
+  DECLAREDV(self);
+  if (!dv->size)
+    return 0;
+
+  DECLAREBB(dv->bb_obj);
+
+  char *ptr = (char*)bb->ptr + (size_t)dv->offset;
+
+  rb_memory_view_init_as_byte_array(view, self, ptr, (const ssize_t)dv->size, 0);
+  return 1;
+}
+
+// static bool
+// r_dv_mv_release(VALUE self, rb_memory_view_t *view) {
+//   return 1;
+// }
+
+static bool
+r_dv_mv_available_p(VALUE self) {
+  DECLAREDV(self);
+  return dv->size > 0 ? 1 : 0;
+}
+
+static rb_memory_view_entry_t cDataViewMemoryView = {
+  r_dv_mv_get,
+  NULL, // r_dv_mv_release,
+  r_dv_mv_available_p
+};
+#endif
+
 /*
  * call-seq:
  *  initialize(buffer, offset, size, endianess:)
@@ -488,6 +525,17 @@ t_dv_setbytes(VALUE self, VALUE index, VALUE bytes) {
   return self;
 }
 
+VALUE
+t_dv_to_s(VALUE self) {
+  DECLAREDV(self);
+  DECLAREBB(dv->bb_obj);
+
+  const char *ptr = (const char*)bb->ptr + (size_t)dv->offset;
+  size_t len = (size_t)dv->size;
+
+  return rb_str_new(ptr, len);
+}
+
 void
 Init_dataview() {
   idEndianess = rb_intern("endianess");
@@ -520,4 +568,10 @@ Init_dataview() {
   rb_define_method(cDataView, "size", t_dv_size, 0);
   rb_define_alias(cDataView, "length", "size");
   rb_define_method(cDataView, "each", t_dv_each, 0);
+
+  rb_define_method(cDataView, "to_s", t_dv_to_s, 0);
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+  rb_memory_view_register(cDataView, &cDataViewMemoryView);
+#endif
 }

data/ext/arraybuffer/extconf.rb

@@ -3,5 +3,9 @@ require 'mkmf'
 
 # preparation for compilation goes here
 
+if have_header("ruby/memory_view.h")
+  have_type("rb_memory_view_t", ["ruby/memory_view.h"])
+end
+
 create_header
 create_makefile 'arraybuffer_ext'

data/extconf.h

@@ -1,3 +1,5 @@
 #ifndef EXTCONF_H
 #define EXTCONF_H
+#define HAVE_RUBY_MEMORY_VIEW_H 1
+#define HAVE_TYPE_RB_MEMORY_VIEW_T 1
 #endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arraybuffer
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - André Diego Piske
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-24 00:00:00.000000000 Z
+date: 2021-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.9'
-description: 
+description:
 email:
 - andrepiske@gmail.com
 executables: []
@@ -45,7 +45,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/andrepiske/rb-arraybuffer
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -60,8 +60,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.21
+signing_key:
 specification_version: 4
 summary: An array buffer (a.k.a. byte array) implementation forRuby, implemented natively.
 test_files: []