ed-precompiled_nio4r 2.7.4-arm64-darwin

data/ext/nio4r/monitor.c

@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#include "nio4r.h"
+#include <assert.h>
+
+static VALUE mNIO = Qnil;
+static VALUE cNIO_Monitor = Qnil;
+
+/* Allocator/deallocator */
+static VALUE NIO_Monitor_allocate(VALUE klass);
+static void NIO_Monitor_mark(void *data);
+static size_t NIO_Monitor_memsize(const void *data);
+
+/* Methods */
+static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector, VALUE io, 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);
+static VALUE NIO_Monitor_value(VALUE self);
+static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj);
+static VALUE NIO_Monitor_readiness(VALUE self);
+
+/* Internal C functions */
+static int NIO_Monitor_symbol2interest(VALUE interests);
+static void NIO_Monitor_update_interests(VALUE self, int interests);
+
+/* Compatibility for Ruby <= 3.1 */
+#ifndef HAVE_RB_IO_DESCRIPTOR
+static int
+io_descriptor_fallback(VALUE io)
+{
+    rb_io_t *fptr;
+    GetOpenFile(io, fptr);
+    return fptr->fd;
+}
+#define rb_io_descriptor io_descriptor_fallback
+#endif
+
+/* Monitor control how a channel is being waited for by a monitor */
+void Init_NIO_Monitor()
+{
+    mNIO = rb_define_module("NIO");
+    cNIO_Monitor = rb_define_class_under(mNIO, "Monitor", rb_cObject);
+    rb_define_alloc_func(cNIO_Monitor, NIO_Monitor_allocate);
+
+    rb_define_method(cNIO_Monitor, "initialize", NIO_Monitor_initialize, 3);
+    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);
+    rb_define_method(cNIO_Monitor, "readiness", NIO_Monitor_readiness, 0);
+    rb_define_method(cNIO_Monitor, "readable?", NIO_Monitor_is_readable, 0);
+    rb_define_method(cNIO_Monitor, "writable?", NIO_Monitor_is_writable, 0);
+    rb_define_method(cNIO_Monitor, "writeable?", NIO_Monitor_is_writable, 0);
+}
+
+static const rb_data_type_t NIO_Monitor_type = {
+    "NIO::Monitor",
+    {
+        NIO_Monitor_mark,
+        RUBY_TYPED_DEFAULT_FREE,
+        NIO_Monitor_memsize,
+    },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE NIO_Monitor_allocate(VALUE klass)
+{
+    struct NIO_Monitor *monitor = (struct NIO_Monitor *)xmalloc(sizeof(struct NIO_Monitor));
+    assert(monitor);
+    *monitor = (struct NIO_Monitor){.self = Qnil};
+    return TypedData_Wrap_Struct(klass, &NIO_Monitor_type, monitor);
+}
+
+static void NIO_Monitor_mark(void *data)
+{
+    struct NIO_Monitor *monitor = (struct NIO_Monitor *)data;
+    rb_gc_mark(monitor->self);
+}
+
+static size_t NIO_Monitor_memsize(const void *data)
+{
+    const struct NIO_Monitor *monitor = (const struct NIO_Monitor *)data;
+    return sizeof(*monitor);
+}
+
+static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE selector_obj)
+{
+    struct NIO_Monitor *monitor;
+    struct NIO_Selector *selector;
+    ID interests_id;
+
+    interests_id = SYM2ID(interests);
+
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, 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 event type %s (must be :r, :w, or :rw)", RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0)));
+    }
+
+    int descriptor = rb_io_descriptor(rb_convert_type(io, T_FILE, "IO", "to_io"));
+    ev_io_init(&monitor->ev_io, NIO_Selector_monitor_callback, descriptor, monitor->interests);
+
+    rb_ivar_set(self, rb_intern("io"), io);
+    rb_ivar_set(self, rb_intern("interests"), interests);
+    rb_ivar_set(self, rb_intern("selector"), selector_obj);
+
+    selector = NIO_Selector_unwrap(selector_obj);
+
+    RB_OBJ_WRITE(self, &monitor->self, self);
+    monitor->ev_io.data = (void *)monitor;
+
+    /* We can safely hang onto this as we also hang onto a reference to the
+       object where it originally came from */
+    monitor->selector = selector;
+
+    if (monitor->interests) {
+        ev_io_start(selector->ev_loop, &monitor->ev_io);
+    }
+
+    return Qnil;
+}
+
+static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self)
+{
+    VALUE deregister, selector;
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    rb_scan_args(argc, argv, "01", &deregister);
+    selector = rb_ivar_get(self, rb_intern("selector"));
+
+    if (selector != Qnil) {
+        /* if ev_loop is 0, it means that the loop has been stopped already (see NIO_Selector_shutdown) */
+        if (monitor->interests && monitor->selector->ev_loop) {
+            ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
+        }
+
+        monitor->selector = 0;
+        rb_ivar_set(self, rb_intern("selector"), Qnil);
+
+        /* Default value is true */
+        if (deregister == Qtrue || deregister == Qnil) {
+            rb_funcall(selector, rb_intern("deregister"), 1, rb_ivar_get(self, rb_intern("io")));
+        }
+    }
+
+    return Qnil;
+}
+
+static VALUE NIO_Monitor_is_closed(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    return monitor->selector == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE NIO_Monitor_io(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("io"));
+}
+
+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;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    interest = monitor->interests | NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, (int)interest);
+
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
+static VALUE NIO_Monitor_remove_interest(VALUE self, VALUE interest)
+{
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    interest = monitor->interests & ~NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, (int)interest);
+
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
+static VALUE NIO_Monitor_selector(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("selector"));
+}
+
+static VALUE NIO_Monitor_value(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("value"));
+}
+
+static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj)
+{
+    return rb_ivar_set(self, rb_intern("value"), obj);
+}
+
+static VALUE NIO_Monitor_readiness(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    if ((monitor->revents & (EV_READ | EV_WRITE)) == (EV_READ | EV_WRITE)) {
+        return ID2SYM(rb_intern("rw"));
+    } else if (monitor->revents & EV_READ) {
+        return ID2SYM(rb_intern("r"));
+    } else if (monitor->revents & EV_WRITE) {
+        return ID2SYM(rb_intern("w"));
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE NIO_Monitor_is_readable(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    if (monitor->revents & EV_READ) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE NIO_Monitor_is_writable(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, monitor);
+
+    if (monitor->revents & EV_WRITE) {
+        return Qtrue;
+    } else {
+        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;
+    TypedData_Get_Struct(self, struct NIO_Monitor, &NIO_Monitor_type, 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

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#ifndef NIO4R_H
+#define NIO4R_H
+
+#include "libev.h"
+#include "ruby.h"
+#include "ruby/io.h"
+
+struct NIO_Selector {
+    struct ev_loop *ev_loop;
+    struct ev_timer timer; /* for timeouts */
+    struct ev_io wakeup;
+
+    int ready_count;
+    int closed, selecting;
+    int wakeup_reader, wakeup_writer;
+    volatile int wakeup_fired;
+
+    VALUE ready_array;
+};
+
+struct NIO_callback_data {
+    VALUE *monitor;
+    struct NIO_Selector *selector;
+};
+
+struct NIO_Monitor {
+    VALUE self;
+    int interests, revents;
+    struct ev_io ev_io;
+    struct NIO_Selector *selector;
+};
+
+struct NIO_ByteBuffer {
+    char *buffer;
+    int position, limit, capacity, mark;
+};
+
+struct NIO_Selector *NIO_Selector_unwrap(VALUE selector);
+
+/* Thunk between libev callbacks in NIO::Monitors and NIO::Selectors */
+void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
+
+#endif /* NIO4R_H */

data/ext/nio4r/nio4r_ext.c

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2011-2017 Tony Arcieri. Distributed under the MIT License.
+ * See LICENSE.txt for further details.
+ */
+
+#include "../libev/ev.c"
+#include "nio4r.h"
+
+void Init_NIO_Selector();
+void Init_NIO_Monitor();
+void Init_NIO_ByteBuffer();
+
+void Init_nio4r_ext()
+{
+    #ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+    #endif
+
+    ev_set_allocator(xrealloc);
+
+    Init_NIO_Selector();
+    Init_NIO_Monitor();
+    Init_NIO_ByteBuffer();
+}

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

@@ -0,0 +1,295 @@
+package org.nio4r;
+
+import java.io.IOException;
+import java.io.Serializable;
+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 static final long serialVersionUID = -6903439483039149324L;
+    private transient 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()
+        ));
+    }
+}