nio4r 1.2.1 → 2.5.3

data/ext/nio4r/extconf.rb

@@ -1,41 +1,28 @@
-require "mkmf"
-
-have_header("unistd.h")
+# frozen_string_literal: true
 
-if have_func("rb_thread_blocking_region")
-  $defs << "-DHAVE_RB_THREAD_BLOCKING_REGION"
-end
+require "rubygems"
 
-if have_func("rb_thread_call_without_gvl")
-  $defs << "-DHAVE_RB_THEREAD_CALL_WITHOUT_GVL"
+# Write a dummy Makefile on Windows because we use the pure Ruby implementation there
+if Gem.win_platform?
+  require "devkit" if RUBY_PLATFORM.include?("mingw")
+  File.write("Makefile", "all install::\n")
+  File.write("nio4r_ext.so", "")
+  exit
 end
 
-$defs << "-DEV_USE_SELECT" if have_header("sys/select.h")
-
-$defs << "-DEV_USE_POLL" if have_header("poll.h")
-
-$defs << "-DEV_USE_EPOLL" if have_header("sys/epoll.h")
-
-if have_header("sys/event.h") && have_header("sys/queue.h")
-  $defs << "-DEV_USE_KQUEUE"
-end
+require "mkmf"
 
-$defs << "-DEV_USE_PORT" if have_header("port.h")
+have_header("unistd.h")
 
+$defs << "-DEV_USE_LINUXAIO"     if have_header("linux/aio_abi.h")
+$defs << "-DEV_USE_SELECT"       if have_header("sys/select.h")
+$defs << "-DEV_USE_POLL"         if have_type("port_event_t", "poll.h")
+$defs << "-DEV_USE_EPOLL"        if have_header("sys/epoll.h")
+$defs << "-DEV_USE_KQUEUE"       if have_header("sys/event.h") && have_header("sys/queue.h")
+$defs << "-DEV_USE_PORT"         if have_type("port_event_t", "port.h")
 $defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
 
-$defs << "-DHAVE_RUBYSIG_H" if RUBY_VERSION.to_f < 1.9
+CONFIG["optflags"] << " -fno-strict-aliasing" unless RUBY_PLATFORM =~ /mswin/
 
 dir_config "nio4r_ext"
 create_makefile "nio4r_ext"
-
-# win32 needs to link in "just the right order" for some reason or
-# ioctlsocket will be mapped to an [inverted] ruby specific version.
-if RUBY_PLATFORM =~ /mingw|win32/
-  makefile_contents = File.read "Makefile"
-
-  makefile_contents.gsub! "DLDFLAGS = ", "DLDFLAGS = -export-all "
-
-  makefile_contents.gsub! "LIBS = $(LIBRUBYARG_SHARED)", "LIBS = -lws2_32 $(LIBRUBYARG_SHARED)"
-  File.open("Makefile", "w") { |f| f.write makefile_contents }
-end

data/ext/nio4r/monitor.c

@@ -15,12 +15,13 @@ static void NIO_Monitor_free(struct NIO_Monitor *monitor);
 
 /* Methods */
 static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector, VALUE io, VALUE interests);
-static VALUE NIO_Monitor_set_interests(VALUE self, VALUE interests);
-
 static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self);
 static VALUE NIO_Monitor_is_closed(VALUE self);
 static VALUE NIO_Monitor_io(VALUE self);
 static VALUE NIO_Monitor_interests(VALUE self);
+static VALUE NIO_Monitor_set_interests(VALUE self, VALUE interests);
+static VALUE NIO_Monitor_add_interest(VALUE self, VALUE interest);
+static VALUE NIO_Monitor_remove_interest(VALUE self, VALUE interest);
 static VALUE NIO_Monitor_selector(VALUE self);
 static VALUE NIO_Monitor_is_readable(VALUE self);
 static VALUE NIO_Monitor_is_writable(VALUE self);
@@ -28,11 +29,9 @@ static VALUE NIO_Monitor_value(VALUE self);
 static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj);
 static VALUE NIO_Monitor_readiness(VALUE self);
 
-#if HAVE_RB_IO_T
-  rb_io_t *fptr;
-#else
-  OpenFile *fptr;
-#endif
+/* Internal C functions */
+static int NIO_Monitor_symbol2interest(VALUE interests);
+static void NIO_Monitor_update_interests(VALUE self, int interests);
 
 /* Monitor control how a channel is being waited for by a monitor */
 void Init_NIO_Monitor()
@@ -42,11 +41,13 @@ void Init_NIO_Monitor()
     rb_define_alloc_func(cNIO_Monitor, NIO_Monitor_allocate);
 
     rb_define_method(cNIO_Monitor, "initialize", NIO_Monitor_initialize, 3);
-    rb_define_method(cNIO_Monitor, "interests=", NIO_Monitor_set_interests, 1);
     rb_define_method(cNIO_Monitor, "close", NIO_Monitor_close, -1);
     rb_define_method(cNIO_Monitor, "closed?", NIO_Monitor_is_closed, 0);
     rb_define_method(cNIO_Monitor, "io", NIO_Monitor_io, 0);
     rb_define_method(cNIO_Monitor, "interests", NIO_Monitor_interests, 0);
+    rb_define_method(cNIO_Monitor, "interests=", NIO_Monitor_set_interests, 1);
+    rb_define_method(cNIO_Monitor, "add_interest", NIO_Monitor_add_interest, 1);
+    rb_define_method(cNIO_Monitor, "remove_interest", NIO_Monitor_remove_interest, 1);
     rb_define_method(cNIO_Monitor, "selector", NIO_Monitor_selector, 0);
     rb_define_method(cNIO_Monitor, "value", NIO_Monitor_value, 0);
     rb_define_method(cNIO_Monitor, "value=", NIO_Monitor_set_value, 1);
@@ -65,6 +66,7 @@ static VALUE NIO_Monitor_allocate(VALUE klass)
 
 static void NIO_Monitor_mark(struct NIO_Monitor *monitor)
 {
+    return rb_gc_mark(monitor->self);
 }
 
 static void NIO_Monitor_free(struct NIO_Monitor *monitor)
@@ -77,12 +79,7 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE
     struct NIO_Monitor *monitor;
     struct NIO_Selector *selector;
     ID interests_id;
-
-    #if HAVE_RB_IO_T
-        rb_io_t *fptr;
-    #else
-        OpenFile *fptr;
-    #endif
+    rb_io_t *fptr;
 
     interests_id = SYM2ID(interests);
 
@@ -96,7 +93,7 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE
         monitor->interests = EV_READ | EV_WRITE;
     } else {
         rb_raise(rb_eArgError, "invalid event type %s (must be :r, :w, or :rw)",
-            RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0, 0)));
+            RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0)));
     }
 
     GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
@@ -115,41 +112,11 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE
        object where it originally came from */
     monitor->selector = selector;
 
-    ev_io_start(selector->ev_loop, &monitor->ev_io);
-
-    return Qnil;
-}
-
-static VALUE NIO_Monitor_set_interests(VALUE self, VALUE interests)
-{
-    struct NIO_Monitor *monitor;
-    ID interests_id;
-
-    if(NIO_Monitor_is_closed(self) == Qtrue) {
-        rb_raise(rb_eTypeError, "monitor is already closed");
-    }
-
-    interests_id = SYM2ID(interests);
-    Data_Get_Struct(self, struct NIO_Monitor, monitor);
-
-    if(interests_id == rb_intern("r")) {
-        monitor->interests = EV_READ;
-    } else if(interests_id == rb_intern("w")) {
-        monitor->interests = EV_WRITE;
-    } else if(interests_id == rb_intern("rw")) {
-        monitor->interests = EV_READ | EV_WRITE;
-    } else {
-        rb_raise(rb_eArgError, "invalid interest type %s (must be :r, :w, or :rw)",
-            RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0, 0)));
+    if (monitor->interests) {
+      ev_io_start(selector->ev_loop, &monitor->ev_io);
     }
 
-    ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
-    ev_io_set(&monitor->ev_io, monitor->ev_io.fd, monitor->interests);
-    ev_io_start(monitor->selector->ev_loop, &monitor->ev_io);
-
-    rb_ivar_set(self, rb_intern("interests"), interests);
-
-    return interests;
+    return Qnil;
 }
 
 static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self)
@@ -163,7 +130,7 @@ static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self)
 
     if(selector != Qnil) {
         /* if ev_loop is 0, it means that the loop has been stopped already (see NIO_Selector_shutdown) */
-        if(monitor->selector->ev_loop != 0) {
+        if(monitor->interests && monitor->selector->ev_loop) {
           ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
         }
 
@@ -197,6 +164,37 @@ static VALUE NIO_Monitor_interests(VALUE self)
     return rb_ivar_get(self, rb_intern("interests"));
 }
 
+static VALUE NIO_Monitor_set_interests(VALUE self, VALUE interests)
+{
+    if(NIL_P(interests)) {
+        NIO_Monitor_update_interests(self, 0);
+    } else {
+        NIO_Monitor_update_interests(self, NIO_Monitor_symbol2interest(interests));
+    }
+
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
+static VALUE NIO_Monitor_add_interest(VALUE self, VALUE interest) {
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    interest = monitor->interests | NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, interest);
+
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
+static VALUE NIO_Monitor_remove_interest(VALUE self, VALUE interest) {
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    interest = monitor->interests & ~NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, interest);
+
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
 static VALUE NIO_Monitor_selector(VALUE self)
 {
     return rb_ivar_get(self, rb_intern("selector"));
@@ -251,3 +249,69 @@ static VALUE NIO_Monitor_is_writable(VALUE self)
         return Qfalse;
     }
 }
+
+/* Internal C functions */
+
+static int NIO_Monitor_symbol2interest(VALUE interests)
+{
+    ID interests_id;
+    interests_id = SYM2ID(interests);
+
+    if(interests_id == rb_intern("r")) {
+        return EV_READ;
+    } else if(interests_id == rb_intern("w")) {
+        return EV_WRITE;
+    } else if(interests_id == rb_intern("rw")) {
+        return EV_READ | EV_WRITE;
+    } else {
+        rb_raise(rb_eArgError, "invalid interest type %s (must be :r, :w, or :rw)",
+            RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0)));
+    }
+}
+
+static void NIO_Monitor_update_interests(VALUE self, int interests)
+{
+    ID interests_id;
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    if(NIO_Monitor_is_closed(self) == Qtrue) {
+        rb_raise(rb_eEOFError, "monitor is closed");
+    }
+
+    if(interests) {
+        switch(interests) {
+            case EV_READ:
+                interests_id = rb_intern("r");
+                break;
+            case EV_WRITE:
+                interests_id = rb_intern("w");
+                break;
+            case EV_READ | EV_WRITE:
+                interests_id = rb_intern("rw");
+                break;
+            default:
+                rb_raise(rb_eRuntimeError, "bogus NIO_Monitor_update_interests! (%d)", interests);
+        }
+
+        rb_ivar_set(self, rb_intern("interests"), ID2SYM(interests_id));
+    } else {
+        rb_ivar_set(self, rb_intern("interests"), Qnil);
+    }
+
+    if(monitor->interests != interests) {
+        // If the monitor currently has interests, we should stop it.
+        if(monitor->interests) {
+            ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
+        }
+
+        // Assign the interests we are now monitoring for:
+        monitor->interests = interests;
+        ev_io_set(&monitor->ev_io, monitor->ev_io.fd, monitor->interests);
+
+        // If we are interested in events, schedule the monitor back into the event loop:
+        if(monitor->interests) {
+            ev_io_start(monitor->selector->ev_loop, &monitor->ev_io);
+        }
+    }
+}

data/ext/nio4r/nio4r.h

@@ -7,11 +7,7 @@
 #define NIO4R_H
 
 #include "ruby.h"
-#if HAVE_RUBY_IO_H
-# include "ruby/io.h"
-#else
-# include "rubyio.h"
-#endif
+#include "ruby/io.h"
 #include "libev.h"
 
 struct NIO_Selector
@@ -20,9 +16,10 @@ struct NIO_Selector
     struct ev_timer timer; /* for timeouts */
     struct ev_io wakeup;
 
-    int wakeup_reader, wakeup_writer;
-    int closed, selecting;
     int ready_count;
+    int closed, selecting;
+    int wakeup_reader, wakeup_writer;
+    volatile int wakeup_fired;
 
     VALUE ready_array;
 };
@@ -41,16 +38,17 @@ struct NIO_Monitor
     struct NIO_Selector *selector;
 };
 
+struct NIO_ByteBuffer
+{
+    char *buffer;
+    int position, limit, capacity, mark;
+};
+
+
 #ifdef GetReadFile
 # define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
 #else
-
-#if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
-# define FPTR_TO_FD(fptr) fileno(fptr->f)
-#else
 # define FPTR_TO_FD(fptr) fptr->fd
-#endif /* !HAVE_RB_IO_T */
-
 #endif /* GetReadFile */
 
 /* Thunk between libev callbacks in NIO::Monitors and NIO::Selectors */

data/ext/nio4r/org/nio4r/ByteBuffer.java

@@ -0,0 +1,293 @@
+package org.nio4r;
+
+import java.io.IOException;
+import java.nio.channels.Channel;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.nio.BufferOverflowException;
+import java.nio.BufferUnderflowException;
+import java.nio.InvalidMarkException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyIO;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.Block;
+
+/*
+created by Upekshej
+ */
+public class ByteBuffer extends RubyObject {
+    private java.nio.ByteBuffer byteBuffer;
+
+    public static RaiseException newOverflowError(ThreadContext context, String message) {
+        RubyClass klass = context.runtime.getModule("NIO").getClass("ByteBuffer").getClass("OverflowError");
+        return context.runtime.newRaiseException(klass, message);
+    }
+
+    public static RaiseException newUnderflowError(ThreadContext context, String message) {
+        RubyClass klass = context.runtime.getModule("NIO").getClass("ByteBuffer").getClass("UnderflowError");
+        return context.runtime.newRaiseException(klass, message);
+    }
+
+    public static RaiseException newMarkUnsetError(ThreadContext context, String message) {
+        RubyClass klass = context.runtime.getModule("NIO").getClass("ByteBuffer").getClass("MarkUnsetError");
+        return context.runtime.newRaiseException(klass, message);
+    }
+
+    public ByteBuffer(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject capacity) {
+        this.byteBuffer = java.nio.ByteBuffer.allocate(RubyNumeric.num2int(capacity));
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject clear(ThreadContext context) {
+        this.byteBuffer.clear();
+        return this;
+    }
+
+    @JRubyMethod(name = "position")
+    public IRubyObject getPosition(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.position());
+    }
+
+    @JRubyMethod(name = "position=")
+    public IRubyObject setPosition(ThreadContext context, IRubyObject newPosition) {
+        int pos = RubyNumeric.num2int(newPosition);
+
+        if(pos < 0) {
+            throw context.runtime.newArgumentError("negative position given");
+        }
+
+        if(pos > this.byteBuffer.limit()) {
+            throw context.runtime.newArgumentError("specified position exceeds limit");
+        }
+
+        try {
+            this.byteBuffer.position(pos);
+            return newPosition;
+        } catch(IllegalArgumentException e) {
+            throw context.runtime.newArgumentError(e.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod(name = "limit")
+    public IRubyObject getLimit(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.limit());
+    }
+
+    @JRubyMethod(name = "limit=")
+    public IRubyObject setLimit(ThreadContext context, IRubyObject newLimit) {
+        int lim = RubyNumeric.num2int(newLimit);
+
+        if(lim < 0) {
+            throw context.runtime.newArgumentError("negative limit given");
+        }
+
+        if(lim > this.byteBuffer.capacity()) {
+            throw context.runtime.newArgumentError("specified limit exceeds capacity");
+        }
+
+        try {
+            this.byteBuffer.limit(lim);
+            return newLimit;
+        } catch(IllegalArgumentException e) {
+            throw context.runtime.newArgumentError(e.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod(name = {"capacity", "size"})
+    public IRubyObject capacity(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.capacity());
+    }
+
+    @JRubyMethod
+    public IRubyObject remaining(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.remaining());
+    }
+
+    @JRubyMethod(name = "full?")
+    public IRubyObject isFull(ThreadContext context) {
+        if (this.byteBuffer.hasRemaining()) {
+            return context.getRuntime().getFalse();
+        } else {
+            return context.getRuntime().getTrue();
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject get(ThreadContext context) {
+        return this.get(context, context.getRuntime().newFixnum(this.byteBuffer.remaining()));
+    }
+
+    @JRubyMethod
+    public IRubyObject get(ThreadContext context, IRubyObject length) {
+        int len = RubyNumeric.num2int(length);
+        byte[] bytes = new byte[len];
+
+        try {
+            this.byteBuffer.get(bytes);
+        } catch(BufferUnderflowException e) {
+            throw ByteBuffer.newUnderflowError(context, "not enough data in buffer");
+        }
+
+        return RubyString.newString(context.getRuntime(), bytes);
+    }
+
+    @JRubyMethod(name = "[]")
+    public IRubyObject fetch(ThreadContext context, IRubyObject index) {
+        int i = RubyNumeric.num2int(index);
+
+        if(i < 0) {
+            throw context.runtime.newArgumentError("negative index given");
+        }
+
+        if(i >= this.byteBuffer.limit()) {
+            throw context.runtime.newArgumentError("index exceeds limit");
+        }
+
+        return context.getRuntime().newFixnum(this.byteBuffer.get(i));
+    }
+
+    @JRubyMethod(name = "<<")
+    public IRubyObject put(ThreadContext context, IRubyObject str) {
+        try {
+            this.byteBuffer.put(str.convertToString().getByteList().bytes());
+        } catch(BufferOverflowException e) {
+            throw ByteBuffer.newOverflowError(context, "buffer is full");
+        }
+
+        return this;
+    }
+
+    @JRubyMethod(name = "read_from")
+    public IRubyObject readFrom(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.runtime;
+        Channel channel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!this.byteBuffer.hasRemaining()) {
+            throw ByteBuffer.newOverflowError(context, "buffer is full");
+        }
+
+        if(!(channel instanceof ReadableByteChannel) || !(channel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("unsupported IO object: " + io.getType().toString());
+        }
+
+        try {
+            ((SelectableChannel)channel).configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        try {
+            int bytesRead = ((ReadableByteChannel)channel).read(this.byteBuffer);
+
+            if(bytesRead >= 0) {
+                return runtime.newFixnum(bytesRead);
+            } else {
+                throw runtime.newEOFError();
+            }
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod(name = "write_to")
+    public IRubyObject writeTo(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.runtime;
+        Channel channel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!this.byteBuffer.hasRemaining()) {
+            throw ByteBuffer.newUnderflowError(context, "not enough data in buffer");
+        }
+
+        if(!(channel instanceof WritableByteChannel) || !(channel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("unsupported IO object: " + io.getType().toString());
+        }
+
+        try {
+            ((SelectableChannel)channel).configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        try {
+            int bytesWritten = ((WritableByteChannel)channel).write(this.byteBuffer);
+
+            if(bytesWritten >= 0) {
+                return runtime.newFixnum(bytesWritten);
+            } else {
+                throw runtime.newEOFError();
+            }
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject flip(ThreadContext context) {
+        this.byteBuffer.flip();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject rewind(ThreadContext context) {
+        this.byteBuffer.rewind();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject mark(ThreadContext context) {
+        this.byteBuffer.mark();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject reset(ThreadContext context) {
+        try {
+            this.byteBuffer.reset();
+            return this;
+        } catch(InvalidMarkException ie) {
+            throw ByteBuffer.newMarkUnsetError(context, "mark has not been set");
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject compact(ThreadContext context) {
+        this.byteBuffer.compact();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject each(ThreadContext context, Block block) {
+        for(int i = 0; i < this.byteBuffer.limit(); i++) {
+            block.call(context, context.getRuntime().newFixnum(this.byteBuffer.get(i)));
+        }
+
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject inspect(ThreadContext context) {
+        return context.runtime.newString(String.format(
+            "#<%s:0x%x @position=%d @limit=%d @capacity=%d>",
+            this.getType().toString(),
+            System.identityHashCode(this),
+            this.byteBuffer.position(),
+            this.byteBuffer.limit(),
+            this.byteBuffer.capacity()
+        ));
+    }
+}