nio4r 2.0.0.pre-java → 2.1.0-java

data/ext/nio4r/extconf.rb

@@ -1,15 +1,9 @@
+# frozen_string_literal: true
+
 require "mkmf"
 
 have_header("unistd.h")
 
-if have_func("rb_thread_blocking_region")
-  $defs << "-DHAVE_RB_THREAD_BLOCKING_REGION"
-end
-
-if have_func("rb_thread_call_without_gvl")
-  $defs << "-DHAVE_RB_THEREAD_CALL_WITHOUT_GVL"
-end
-
 $defs << "-DEV_USE_SELECT" if have_header("sys/select.h")
 
 $defs << "-DEV_USE_POLL" if have_header("poll.h")
@@ -24,7 +18,7 @@ $defs << "-DEV_USE_PORT" if have_header("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"
 
 dir_config "nio4r_ext"
 create_makefile "nio4r_ext"

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);
@@ -77,12 +78,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);
 
@@ -120,38 +116,6 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE
     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)));
-    }
-
-    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;
-}
-
 static VALUE NIO_Monitor_close(int argc, VALUE *argv, VALUE self)
 {
     VALUE deregister, selector;
@@ -197,6 +161,33 @@ 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)
+{
+    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);
+
+    monitor->interests |= NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, monitor->interests);
+
+    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);
+
+    monitor->interests &= ~NIO_Monitor_symbol2interest(interest);
+    NIO_Monitor_update_interests(self, monitor->interests);
+
+    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 +242,59 @@ 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, 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);
+    }
+
+    monitor->interests = interests;
+
+    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);
+}

data/ext/nio4r/nio4r.h

@@ -7,22 +7,19 @@
 #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
 {
-    struct ev_loop *ev_loop;
+    ev_loop *ev_loop;
     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;
 };
@@ -43,22 +40,15 @@ struct NIO_Monitor
 
 struct NIO_ByteBuffer
 {
-    int size, offset, limit, position, mark;
     char *buffer;
-    VALUE self;
+    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

@@ -1,311 +1,295 @@
 package org.nio4r;
 
-import org.jruby.*;
+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.javasupport.JavaUtil;
+import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.nio.channels.FileChannel;
-import java.util.ArrayList;
+import org.jruby.runtime.Block;
 
 /*
 created by Upekshej
  */
 public class ByteBuffer extends RubyObject {
-
     private java.nio.ByteBuffer byteBuffer;
-    private String currentWritePath = "";
-    private String currentReadPath = "";
 
-    private FileChannel currentWriteFileChannel;
-    private FileOutputStream fileOutputStream;
+    public static RaiseException newOverflowError(ThreadContext context, String message) {
+        RubyClass klass = context.runtime.getModule("NIO").getClass("ByteBuffer").getClass("OverflowError");
+        return context.runtime.newRaiseException(klass, message);
+    }
 
-    private FileInputStream currentReadChannel;
-    private FileChannel inChannel;
+    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 value, IRubyObject offset, IRubyObject length) {
-        Ruby ruby = context.getRuntime();
+    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;
+    }
 
-        if (value == ruby.getNil()) {
-            throw ruby.newTypeError("expected String or Integer for value, got NilClass");
+    @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 (value instanceof RubyString) {
-            if (offset != ruby.getNil() && length != ruby.getNil()) {
-                int arrayOffset = RubyNumeric.num2int(offset);
-                int arrayLimit = RubyNumeric.num2int(length);
-                byteBuffer = java.nio.ByteBuffer.wrap(value.asJavaString().getBytes(), arrayOffset, arrayLimit);
-            } else {
-                byteBuffer = java.nio.ByteBuffer.wrap(value.asJavaString().getBytes());
-            }
-        } else if (value instanceof RubyInteger) {
-            int allocationSize = RubyNumeric.num2int(value);
-            byteBuffer = java.nio.ByteBuffer.allocate(allocationSize);
-        } else {
-            throw ruby.newTypeError("expected String or Integer for value");
+        if(pos > this.byteBuffer.limit()) {
+            throw context.runtime.newArgumentError("specified position exceeds limit");
         }
 
-        return this;
+        try {
+            this.byteBuffer.position(pos);
+            return newPosition;
+        } catch(IllegalArgumentException e) {
+            throw context.runtime.newArgumentError(e.getLocalizedMessage());
+        }
     }
 
-    /**
-     * Currently assuming only strings will come..
-     *
-     * @param context
-     * @return
-     */
-    @JRubyMethod(name = "<<")
-    public IRubyObject put(ThreadContext context, IRubyObject str) {
-        String string = str.asJavaString();
+    @JRubyMethod(name = "limit")
+    public IRubyObject getLimit(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.limit());
+    }
 
-        if (byteBuffer == null) {
-            byteBuffer = java.nio.ByteBuffer.wrap(string.getBytes());
-        }
+    @JRubyMethod(name = "limit=")
+    public IRubyObject setLimit(ThreadContext context, IRubyObject newLimit) {
+        int lim = RubyNumeric.num2int(newLimit);
 
-        byteBuffer.put(string.getBytes());
-        return this;
-    }
+        if(lim < 0) {
+            throw context.runtime.newArgumentError("negative limit given");
+        }
 
-    //https://www.ruby-forum.com/topic/3731325
-    @JRubyMethod(name = "get")
-    public IRubyObject get(ThreadContext context) {
-        ArrayList<Byte> temp = new ArrayList<Byte>();
+        if(lim > this.byteBuffer.capacity()) {
+            throw context.runtime.newArgumentError("specified limit exceeds capacity");
+        }
 
-        while (byteBuffer.hasRemaining()) {
-            temp.add(byteBuffer.get());
+        try {
+            this.byteBuffer.limit(lim);
+            return newLimit;
+        } catch(IllegalArgumentException e) {
+            throw context.runtime.newArgumentError(e.getLocalizedMessage());
         }
+    }
 
-        return JavaUtil.convertJavaToRuby(context.getRuntime(), new String(toPrimitives(temp)));
+    @JRubyMethod(name = {"capacity", "size"})
+    public IRubyObject capacity(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.capacity());
     }
 
-    @JRubyMethod(name = "read_next")
-    public IRubyObject readNext(ThreadContext context, IRubyObject count) {
-        int c = RubyNumeric.num2int(count);
+    @JRubyMethod
+    public IRubyObject remaining(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.remaining());
+    }
 
-        if (c < 1) {
-            throw new IllegalArgumentException();
+    @JRubyMethod(name = "full?")
+    public IRubyObject isFull(ThreadContext context) {
+        if (this.byteBuffer.hasRemaining()) {
+            return context.getRuntime().getFalse();
+        } else {
+            return context.getRuntime().getTrue();
         }
+    }
 
-        if (c <= byteBuffer.remaining()) {
-            org.jruby.util.ByteList temp = new org.jruby.util.ByteList(c);
+    @JRubyMethod
+    public IRubyObject get(ThreadContext context) {
+        return this.get(context, context.getRuntime().newFixnum(this.byteBuffer.remaining()));
+    }
 
-            while (c > 0) {
-                temp.append(byteBuffer.get());
-                c = c - 1;
-            }
+    @JRubyMethod
+    public IRubyObject get(ThreadContext context, IRubyObject length) {
+        int len = RubyNumeric.num2int(length);
+        byte[] bytes = new byte[len];
 
-            return context.runtime.newString(temp);
+        try {
+            this.byteBuffer.get(bytes);
+        } catch(BufferUnderflowException e) {
+            throw ByteBuffer.newUnderflowError(context, "not enough data in buffer");
         }
 
-        return RubyString.newEmptyString(context.runtime);
+        return RubyString.newString(context.getRuntime(), bytes);
     }
 
-    private byte[] toPrimitives(ArrayList<Byte> oBytes) {
-        byte[] bytes = new byte[oBytes.size()];
+    @JRubyMethod(name = "[]")
+    public IRubyObject fetch(ThreadContext context, IRubyObject index) {
+        int i = RubyNumeric.num2int(index);
 
-        for (int i = 0; i < oBytes.size(); i++) {
-            bytes[i] = (oBytes.get(i) == null) ? " ".getBytes()[0] : oBytes.get(i);
+        if(i < 0) {
+            throw context.runtime.newArgumentError("negative index given");
         }
 
-        return bytes;
-    }
-
-    @JRubyMethod(name = "write_to")
-    public IRubyObject writeTo(ThreadContext context, IRubyObject f) {
-        try {
-            File file = (File) JavaUtil.unwrapJavaObject(f);
+        if(i >= this.byteBuffer.limit()) {
+            throw context.runtime.newArgumentError("index exceeds limit");
+        }
 
-            if (!isTheSameFile(file, false)) {
-                currentWritePath = file.getAbsolutePath();
-                if (currentWriteFileChannel != null) currentWriteFileChannel.close();
-                if (fileOutputStream != null) fileOutputStream.close();
+        return context.getRuntime().newFixnum(this.byteBuffer.get(i));
+    }
 
-                fileOutputStream = new FileOutputStream(file, true);
-                currentWriteFileChannel = fileOutputStream.getChannel();
-            }
+    @JRubyMethod(name = "<<")
+    public IRubyObject put(ThreadContext context, IRubyObject str) {
+        String string = str.asJavaString();
 
-            currentWriteFileChannel.write(byteBuffer);
-        } catch (Exception e) {
-            throw new IllegalArgumentException("write error: " + e.getLocalizedMessage());
+        try {
+            this.byteBuffer.put(string.getBytes());
+        } catch(BufferOverflowException e) {
+            throw ByteBuffer.newOverflowError(context, "buffer is full");
         }
 
         return this;
     }
 
     @JRubyMethod(name = "read_from")
-    public IRubyObject readFrom(ThreadContext context, IRubyObject f) {
-        try {
-            File file = (File) JavaUtil.unwrapJavaObject(f);
-
-            if (!isTheSameFile(file, true)) {
-                inChannel.close();
-                currentReadChannel.close();
-                currentReadPath = file.getAbsolutePath();
-                currentReadChannel = new FileInputStream(file);
-                inChannel = currentReadChannel.getChannel();
-            }
+    public IRubyObject readFrom(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.runtime;
+        Channel channel = RubyIO.convertToIO(context, io).getChannel();
 
-            inChannel.read(byteBuffer);
-        } catch (Exception e) {
-            throw new IllegalArgumentException("read error: " + e.getLocalizedMessage());
+        if(!this.byteBuffer.hasRemaining()) {
+            throw ByteBuffer.newOverflowError(context, "buffer is full");
         }
 
-        return this;
-    }
+        if(!(channel instanceof ReadableByteChannel) || !(channel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("unsupported IO object: " + io.getType().toString());
+        }
 
-    private boolean isTheSameFile(File f, boolean read) {
-        if (read) {
-            return (currentReadPath == f.getAbsolutePath());
+        try {
+            ((SelectableChannel)channel).configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
         }
 
-        return currentWritePath == f.getAbsolutePath();
-    }
+        try {
+            int bytesRead = ((ReadableByteChannel)channel).read(this.byteBuffer);
 
-    @JRubyMethod(name = "remaining")
-    public IRubyObject remainingPositions(ThreadContext context) {
-        int count = byteBuffer.remaining();
-        return context.getRuntime().newFixnum(count);
+            if(bytesRead >= 0) {
+                return runtime.newFixnum(bytesRead);
+            } else {
+                throw runtime.newEOFError();
+            }
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
     }
 
-    @JRubyMethod(name = "remaining?")
-    public IRubyObject hasRemaining(ThreadContext context) {
-        if (byteBuffer.hasRemaining()) {
-            return context.getRuntime().getTrue();
-        }
+    @JRubyMethod(name = "write_to")
+    public IRubyObject writeTo(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.runtime;
+        Channel channel = RubyIO.convertToIO(context, io).getChannel();
 
-        return context.getRuntime().getFalse();
-    }
+        if(!this.byteBuffer.hasRemaining()) {
+            throw ByteBuffer.newUnderflowError(context, "not enough data in buffer");
+        }
 
-    @JRubyMethod(name = "offset?")
-    public IRubyObject getOffset(ThreadContext context) {
-        int offset = byteBuffer.arrayOffset();
-        return context.getRuntime().newFixnum(offset);
-    }
+        if(!(channel instanceof WritableByteChannel) || !(channel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("unsupported IO object: " + io.getType().toString());
+        }
 
-    /**
-     * Check whether the two ByteBuffers are the same.
-     *
-     * @param context
-     * @param ob      : The RubyObject which needs to be check
-     * @return
-     */
-    @JRubyMethod(name = "equals?")
-    public IRubyObject equals(ThreadContext context, IRubyObject obj) {
-        Object o = JavaUtil.convertRubyToJava(obj);
-
-        if(!(o instanceof ByteBuffer)) {
-            return context.getRuntime().getFalse();
+        try {
+            ((SelectableChannel)channel).configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
         }
 
-        if(this.byteBuffer.equals(((ByteBuffer)o).getBuffer())) {
-            return context.getRuntime().getTrue();
-        } else {
-            return context.getRuntime().getFalse();
+        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());
         }
     }
 
-    /**
-     * Flip capability provided by the java nio.ByteBuffer
-     * buf.put(magic);    // Prepend header
-     * in.read(buf);      // Read data into rest of buffer
-     * buf.flip();        // Flip buffer
-     * out.write(buf);    // Write header + data to channel
-     *
-     * @param context
-     * @return
-     */
     @JRubyMethod
     public IRubyObject flip(ThreadContext context) {
-        byteBuffer.flip();
+        this.byteBuffer.flip();
         return this;
     }
 
-    /**
-     * Rewinds the buffer. Usage in java is like
-     * out.write(buf);    // Write remaining data
-     * buf.rewind();      // Rewind buffer
-     * buf.get(array);    // Copy data into array
-     *
-     * @param context
-     * @return
-     */
     @JRubyMethod
     public IRubyObject rewind(ThreadContext context) {
-        byteBuffer.rewind();
-        return this;
-    }
-
-    @JRubyMethod
-    public IRubyObject reset(ThreadContext context) {
-        byteBuffer.reset();
+        this.byteBuffer.rewind();
         return this;
     }
 
     @JRubyMethod
     public IRubyObject mark(ThreadContext context) {
-        byteBuffer.mark();
+        this.byteBuffer.mark();
         return this;
     }
 
-    /**
-     * Removes all the content in the byteBuffer
-     *
-     * @param context
-     * @return
-     */
     @JRubyMethod
-    public IRubyObject clear(ThreadContext context) {
-        byteBuffer.clear();
-        return this;
+    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) {
-        byteBuffer.compact();
+        this.byteBuffer.compact();
         return this;
     }
 
-    @JRubyMethod(name = "capacity")
-    public IRubyObject capacity(ThreadContext context) {
-        int cap = byteBuffer.capacity();
-        return context.getRuntime().newFixnum(cap);
-    }
-
     @JRubyMethod
-    public IRubyObject position(ThreadContext context, IRubyObject newPosition) {
-        int position = RubyNumeric.num2int(newPosition);
-        byteBuffer.position(position);
-        return this;
-    }
+    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)));
+        }
 
-    @JRubyMethod(name = "limit")
-    public IRubyObject limit(ThreadContext context, IRubyObject newLimit) {
-        int limit = RubyNumeric.num2int(newLimit);
-        byteBuffer.limit(limit);
         return this;
     }
 
-    @JRubyMethod(name = "limit?")
-    public IRubyObject limit(ThreadContext context) {
-        int lmt = byteBuffer.limit();
-        return context.getRuntime().newFixnum(lmt);
-    }
-
-    @JRubyMethod(name = "to_s")
-    public IRubyObject to_String(ThreadContext context) {
-        return JavaUtil.convertJavaToRuby(context.getRuntime(), byteBuffer.toString());
-    }
-
-    public java.nio.ByteBuffer getBuffer() {
-        return byteBuffer;
+    @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()
+        ));
     }
 }