nio4r 2.0.0.pre-java → 2.1.0-java

data/ext/libev/ev.h

@@ -56,11 +56,6 @@ EV_CPP(extern "C" {)
 
 /*****************************************************************************/
 
-/* pre-4.0 compatibility */
-#ifndef EV_COMPAT3
-# define EV_COMPAT3 1
-#endif
-
 #ifndef EV_FEATURES
 # if defined __OPTIMIZE_SIZE__
 #  define EV_FEATURES 0x7c
@@ -211,7 +206,7 @@ struct ev_loop;
 /*****************************************************************************/
 
 #define EV_VERSION_MAJOR 4
-#define EV_VERSION_MINOR 22
+#define EV_VERSION_MINOR 24
 
 /* eventmask, revents, events... */
 enum {
@@ -515,10 +510,10 @@ enum {
 
 /* method bits to be ored together */
 enum {
-  EVBACKEND_SELECT  = 0x00000001U, /* about anywhere */
-  EVBACKEND_POLL    = 0x00000002U, /* !win */
+  EVBACKEND_SELECT  = 0x00000001U, /* available just about anywhere */
+  EVBACKEND_POLL    = 0x00000002U, /* !win, !aix, broken on osx */
   EVBACKEND_EPOLL   = 0x00000004U, /* linux */
-  EVBACKEND_KQUEUE  = 0x00000008U, /* bsd */
+  EVBACKEND_KQUEUE  = 0x00000008U, /* bsd, broken on osx */
   EVBACKEND_DEVPOLL = 0x00000010U, /* solaris 8 */ /* NYI */
   EVBACKEND_PORT    = 0x00000020U, /* solaris 10 */
   EVBACKEND_ALL     = 0x0000003FU, /* all known backends */

data/ext/libev/ev_epoll.c

@@ -235,7 +235,8 @@ epoll_poll (EV_P_ ev_tstamp timeout)
     }
 }
 
-int inline_size
+inline_size
+int
 epoll_init (EV_P_ int flags)
 {
 #ifdef EPOLL_CLOEXEC
@@ -260,14 +261,16 @@ epoll_init (EV_P_ int flags)
   return EVBACKEND_EPOLL;
 }
 
-void inline_size
+inline_size
+void
 epoll_destroy (EV_P)
 {
   ev_free (epoll_events);
   array_free (epoll_eperm, EMPTY);
 }
 
-void inline_size
+inline_size
+void
 epoll_fork (EV_P)
 {
   close (backend_fd);

data/ext/libev/ev_kqueue.c

@@ -43,7 +43,8 @@
 #include <string.h>
 #include <errno.h>
 
-void inline_speed
+inline_speed
+void
 kqueue_change (EV_P_ int fd, int filter, int flags, int fflags)
 {
   ++kqueue_changecnt;
@@ -152,7 +153,8 @@ kqueue_poll (EV_P_ ev_tstamp timeout)
     }
 }
 
-int inline_size
+inline_size
+int
 kqueue_init (EV_P_ int flags)
 {
   /* initialize the kernel queue */
@@ -176,14 +178,16 @@ kqueue_init (EV_P_ int flags)
   return EVBACKEND_KQUEUE;
 }
 
-void inline_size
+inline_size
+void
 kqueue_destroy (EV_P)
 {
   ev_free (kqueue_events);
   ev_free (kqueue_changes);
 }
 
-void inline_size
+inline_size
+void
 kqueue_fork (EV_P)
 {
   /* some BSD kernels don't just destroy the kqueue itself,

data/ext/libev/ev_poll.c

@@ -39,7 +39,8 @@
 
 #include <poll.h>
 
-void inline_size
+inline_size
+void
 pollidx_init (int *base, int count)
 {
   /* consider using memset (.., -1, ...), which is practically guaranteed
@@ -126,7 +127,8 @@ poll_poll (EV_P_ ev_tstamp timeout)
       }
 }
 
-int inline_size
+inline_size
+int
 poll_init (EV_P_ int flags)
 {
   backend_mintime = 1e-3;
@@ -139,7 +141,8 @@ poll_init (EV_P_ int flags)
   return EVBACKEND_POLL;
 }
 
-void inline_size
+inline_size
+void
 poll_destroy (EV_P)
 {
   ev_free (pollidxs);

data/ext/libev/ev_port.c

@@ -55,7 +55,8 @@
 #include <string.h>
 #include <errno.h>
 
-void inline_speed
+inline_speed
+void
 port_associate_and_check (EV_P_ int fd, int ev)
 {
   if (0 >
@@ -136,7 +137,8 @@ port_poll (EV_P_ ev_tstamp timeout)
     }
 }
 
-int inline_size
+inline_size
+int
 port_init (EV_P_ int flags)
 {
   /* Initialize the kernel queue */
@@ -163,13 +165,15 @@ port_init (EV_P_ int flags)
   return EVBACKEND_PORT;
 }
 
-void inline_size
+inline_size
+void
 port_destroy (EV_P)
 {
   ev_free (port_events);
 }
 
-void inline_size
+inline_size
+void
 port_fork (EV_P)
 {
   close (backend_fd);

data/ext/libev/ev_select.c

@@ -271,7 +271,8 @@ select_poll (EV_P_ ev_tstamp timeout)
 #endif
 }
 
-int inline_size
+inline_size
+int
 select_init (EV_P_ int flags)
 {
   backend_mintime = 1e-6;
@@ -300,7 +301,8 @@ select_init (EV_P_ int flags)
   return EVBACKEND_SELECT;
 }
 
-void inline_size
+inline_size
+void
 select_destroy (EV_P)
 {
   ev_free (vec_ri);

data/ext/nio4r/bytebuffer.c

@@ -2,34 +2,39 @@
 
 static VALUE mNIO = Qnil;
 static VALUE cNIO_ByteBuffer = Qnil;
+static VALUE cNIO_ByteBuffer_OverflowError = Qnil;
+static VALUE cNIO_ByteBuffer_UnderflowError = Qnil;
+static VALUE cNIO_ByteBuffer_MarkUnsetError = Qnil;
 
 /* Allocator/deallocator */
 static VALUE NIO_ByteBuffer_allocate(VALUE klass);
-static void NIO_ByteBuffer_mark(struct NIO_ByteBuffer *byteBuffer);
+static void NIO_ByteBuffer_gc_mark(struct NIO_ByteBuffer *byteBuffer);
 static void NIO_ByteBuffer_free(struct NIO_ByteBuffer *byteBuffer);
 
 /* Methods */
-static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE value, VALUE offset, VALUE length);
-static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string);
-static VALUE NIO_ByteBuffer_get(VALUE self);
-static VALUE NIO_ByteBuffer_readnext(VALUE self, VALUE amount);
-static VALUE NIO_ByteBuffer_writeTo(VALUE self, VALUE file);
-static VALUE NIO_ByteBuffer_readFrom(VALUE self, VALUE file);
+static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE capacity);
+static VALUE NIO_ByteBuffer_clear(VALUE self);
+static VALUE NIO_ByteBuffer_get_position(VALUE self);
+static VALUE NIO_ByteBuffer_set_position(VALUE self, VALUE new_position);
+static VALUE NIO_ByteBuffer_get_limit(VALUE self);
+static VALUE NIO_ByteBuffer_set_limit(VALUE self, VALUE new_limit);
+static VALUE NIO_ByteBuffer_capacity(VALUE self);
 static VALUE NIO_ByteBuffer_remaining(VALUE self);
-static VALUE NIO_ByteBuffer_hasRemaining(VALUE self);
-static VALUE NIO_ByteBuffer_getOffset(VALUE self);
-static VALUE NIO_ByteBuffer_equals(VALUE self, VALUE other);
+static VALUE NIO_ByteBuffer_full(VALUE self);
+static VALUE NIO_ByteBuffer_get(int argc, VALUE *argv, VALUE self);
+static VALUE NIO_ByteBuffer_fetch(VALUE self, VALUE index);
+static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string);
+static VALUE NIO_ByteBuffer_write_to(VALUE self, VALUE file);
+static VALUE NIO_ByteBuffer_read_from(VALUE self, VALUE file);
 static VALUE NIO_ByteBuffer_flip(VALUE self);
 static VALUE NIO_ByteBuffer_rewind(VALUE self);
+static VALUE NIO_ByteBuffer_mark(VALUE self);
 static VALUE NIO_ByteBuffer_reset(VALUE self);
-static VALUE NIO_ByteBuffer_markBuffer(VALUE self);
-static VALUE NIO_ByteBuffer_clear(VALUE self);
 static VALUE NIO_ByteBuffer_compact(VALUE self);
-static VALUE NIO_ByteBuffer_capacity(VALUE self);
-static VALUE NIO_ByteBuffer_position(VALUE self, VALUE newPosition);
-static VALUE NIO_ByteBuffer_setLimit(VALUE self, VALUE newLimit);
-static VALUE NIO_ByteBuffer_getLimit(VALUE self);
-static VALUE NIO_ByteBuffer_toString(VALUE self);
+static VALUE NIO_ByteBuffer_each(VALUE self);
+static VALUE NIO_ByteBuffer_inspect(VALUE self);
+
+#define MARK_UNSET -1
 
 void Init_NIO_ByteBuffer()
 {
@@ -37,36 +42,43 @@ void Init_NIO_ByteBuffer()
     cNIO_ByteBuffer = rb_define_class_under(mNIO, "ByteBuffer", rb_cObject);
     rb_define_alloc_func(cNIO_ByteBuffer, NIO_ByteBuffer_allocate);
 
-    rb_define_method(cNIO_ByteBuffer, "initialize", NIO_ByteBuffer_initialize, 3);
-    rb_define_method(cNIO_ByteBuffer, "<<", NIO_ByteBuffer_put, 1);
-    rb_define_method(cNIO_ByteBuffer, "get", NIO_ByteBuffer_get, 0);
-    rb_define_method(cNIO_ByteBuffer, "read_next", NIO_ByteBuffer_readnext, 1);
-    rb_define_method(cNIO_ByteBuffer, "write_to", NIO_ByteBuffer_writeTo, 1);
-    rb_define_method(cNIO_ByteBuffer, "read_from", NIO_ByteBuffer_readFrom, 1);
+    cNIO_ByteBuffer_OverflowError  = rb_define_class_under(cNIO_ByteBuffer, "OverflowError", rb_eIOError);
+    cNIO_ByteBuffer_UnderflowError = rb_define_class_under(cNIO_ByteBuffer, "UnderflowError", rb_eIOError);
+    cNIO_ByteBuffer_MarkUnsetError = rb_define_class_under(cNIO_ByteBuffer, "MarkUnsetError", rb_eIOError);
+
+    rb_include_module(cNIO_ByteBuffer, rb_mEnumerable);
+
+    rb_define_method(cNIO_ByteBuffer, "initialize", NIO_ByteBuffer_initialize, 1);
+    rb_define_method(cNIO_ByteBuffer, "clear", NIO_ByteBuffer_clear, 0);
+    rb_define_method(cNIO_ByteBuffer, "position", NIO_ByteBuffer_get_position, 0);
+    rb_define_method(cNIO_ByteBuffer, "position=", NIO_ByteBuffer_set_position, 1);
+    rb_define_method(cNIO_ByteBuffer, "limit", NIO_ByteBuffer_get_limit, 0);
+    rb_define_method(cNIO_ByteBuffer, "limit=", NIO_ByteBuffer_set_limit, 1);
+    rb_define_method(cNIO_ByteBuffer, "capacity", NIO_ByteBuffer_capacity, 0);
+    rb_define_method(cNIO_ByteBuffer, "size", NIO_ByteBuffer_capacity, 0);
     rb_define_method(cNIO_ByteBuffer, "remaining", NIO_ByteBuffer_remaining, 0);
-    rb_define_method(cNIO_ByteBuffer, "remaining?", NIO_ByteBuffer_hasRemaining, 0);
-    rb_define_method(cNIO_ByteBuffer, "offset?", NIO_ByteBuffer_getOffset, 0);
-    rb_define_method(cNIO_ByteBuffer, "equals", NIO_ByteBuffer_equals, 1);
+    rb_define_method(cNIO_ByteBuffer, "full?", NIO_ByteBuffer_full, 0);
+    rb_define_method(cNIO_ByteBuffer, "get", NIO_ByteBuffer_get, -1);
+    rb_define_method(cNIO_ByteBuffer, "[]", NIO_ByteBuffer_fetch, 1);
+    rb_define_method(cNIO_ByteBuffer, "<<", NIO_ByteBuffer_put, 1);
+    rb_define_method(cNIO_ByteBuffer, "read_from", NIO_ByteBuffer_read_from, 1);
+    rb_define_method(cNIO_ByteBuffer, "write_to", NIO_ByteBuffer_write_to, 1);
     rb_define_method(cNIO_ByteBuffer, "flip", NIO_ByteBuffer_flip, 0);
     rb_define_method(cNIO_ByteBuffer, "rewind", NIO_ByteBuffer_rewind, 0);
+    rb_define_method(cNIO_ByteBuffer, "mark", NIO_ByteBuffer_mark, 0);
     rb_define_method(cNIO_ByteBuffer, "reset", NIO_ByteBuffer_reset, 0);
-    rb_define_method(cNIO_ByteBuffer, "mark", NIO_ByteBuffer_markBuffer, 0);
-    rb_define_method(cNIO_ByteBuffer, "clear", NIO_ByteBuffer_clear, 0);
     rb_define_method(cNIO_ByteBuffer, "compact", NIO_ByteBuffer_compact, 0);
-    rb_define_method(cNIO_ByteBuffer, "capacity", NIO_ByteBuffer_capacity, 0);
-    rb_define_method(cNIO_ByteBuffer, "position", NIO_ByteBuffer_position, 1);
-    rb_define_method(cNIO_ByteBuffer, "limit", NIO_ByteBuffer_setLimit, 1);
-    rb_define_method(cNIO_ByteBuffer, "limit?", NIO_ByteBuffer_getLimit, 0);
-    rb_define_method(cNIO_ByteBuffer, "to_s", NIO_ByteBuffer_toString, 0);
+    rb_define_method(cNIO_ByteBuffer, "each", NIO_ByteBuffer_each, 0);
+    rb_define_method(cNIO_ByteBuffer, "inspect", NIO_ByteBuffer_inspect, 0);
 }
 
 static VALUE NIO_ByteBuffer_allocate(VALUE klass)
 {
     struct NIO_ByteBuffer *bytebuffer = (struct NIO_ByteBuffer *)xmalloc(sizeof(struct NIO_ByteBuffer));
-    return Data_Wrap_Struct(klass, NIO_ByteBuffer_mark, NIO_ByteBuffer_free, bytebuffer);
+    return Data_Wrap_Struct(klass, NIO_ByteBuffer_gc_mark, NIO_ByteBuffer_free, bytebuffer);
 }
 
-static void NIO_ByteBuffer_mark(struct NIO_ByteBuffer *buffer)
+static void NIO_ByteBuffer_gc_mark(struct NIO_ByteBuffer *buffer)
 {
 }
 
@@ -75,339 +87,335 @@ static void NIO_ByteBuffer_free(struct NIO_ByteBuffer *buffer)
     xfree(buffer);
 }
 
-static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE value, VALUE i_offset, VALUE i_length)
+static VALUE NIO_ByteBuffer_initialize(VALUE self, VALUE capacity)
 {
-    //Value can be either.
-    //NUM -> Size of the buffer
-    //STRING -> Data to be stored on the buffer
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
-
-    switch (TYPE(value)) {
-      case T_FIXNUM:
-        byteBuffer->size = NUM2INT(value);
-        byteBuffer->buffer = malloc(sizeof(char) * byteBuffer->size);
-        break;
-      case T_STRING:
-        byteBuffer->size = RSTRING_LEN(value);
-        byteBuffer->buffer = StringValuePtr(value);
-        //buffer = RSTRING_PTR(str);
-        break;
-      default:
-        /* raise exception */
-        rb_raise(rb_eTypeError, "not a valid input");
-        break;
-    }
-
-    byteBuffer->position = 0;
-    byteBuffer->offset = 0;
-    byteBuffer->limit = byteBuffer->size - 1;
-    byteBuffer->self = self;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    if(i_offset != Qnil && TYPE(i_offset) == T_FIXNUM) {
-        byteBuffer->offset = NUM2INT(i_offset);
-        byteBuffer->position = byteBuffer->offset;
+    buffer->capacity = NUM2INT(capacity);
+    buffer->buffer = xmalloc(buffer->capacity);
 
-        if(i_length != Qnil && TYPE(i_length) == T_FIXNUM) {
-            int length = NUM2INT(i_length);
-
-            if(byteBuffer->offset + length < byteBuffer->size) {
-                byteBuffer->limit = byteBuffer->offset + length;
-            } else {
-                rb_raise(rb_eRuntimeError, "Invalid Arguiments Exception");
-            }
-        }
-    }
-
-    if(byteBuffer->size == 0) {
-        rb_raise(rb_eRuntimeError, "Invalid Arguiments Exception");
-    }
+    NIO_ByteBuffer_clear(self);
 
     return self;
 }
 
-static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string)
+static VALUE NIO_ByteBuffer_clear(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    if(TYPE(string) == T_STRING) {
-        char *temp =  StringValuePtr(string);
-        int i = 0;
-        int limit = RSTRING_LEN(string);
+    memset(buffer->buffer, 0, buffer->capacity);
 
-        for(byteBuffer->position; i < limit; byteBuffer->position++) {
-            byteBuffer->buffer[byteBuffer->position] = temp[i++];
-        }
-    }
+    buffer->position = 0;
+    buffer->limit = buffer->capacity;
+    buffer->mark = MARK_UNSET;
 
     return self;
 }
 
-static VALUE NIO_ByteBuffer_get(VALUE self)
+static VALUE NIO_ByteBuffer_get_position(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return INT2NUM(buffer->position);
+}
+
+static VALUE NIO_ByteBuffer_set_position(VALUE self, VALUE new_position)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    int pos = NUM2INT(new_position);
 
-    int remaining = NUM2INT(NIO_ByteBuffer_remaining(self));
+    if(pos < 0) {
+        rb_raise(rb_eArgError, "negative position given");
+    }
 
-    if(remaining == 0) {
-        return rb_str_new2("");
+    if(pos > buffer->limit) {
+        rb_raise(rb_eArgError, "specified position exceeds limit");
     }
 
-    char tempArray[remaining+1];
-    int i = 0;
+    buffer->position = pos;
 
-    for(byteBuffer->position; byteBuffer->position <= byteBuffer->limit; byteBuffer->position++) {
-        tempArray[i++] = byteBuffer->buffer[byteBuffer->position];
+    if(buffer->mark > buffer->position) {
+        buffer->mark = MARK_UNSET;
     }
 
-    tempArray[remaining] = '\0';
-    return rb_str_new2(tempArray);
+    return new_position;
+}
+
+static VALUE NIO_ByteBuffer_get_limit(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return INT2NUM(buffer->limit);
 }
 
-static VALUE NIO_ByteBuffer_readnext(VALUE self, VALUE amount)
+static VALUE NIO_ByteBuffer_set_limit(VALUE self, VALUE new_limit)
 {
-    int amnt = NUM2INT(amount);
-    if(amnt < 1) {
-        rb_raise(rb_eTypeError, "not a valid input");
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    int lim = NUM2INT(new_limit);
+
+    if(lim < 0) {
+        rb_raise(rb_eArgError, "negative limit given");
     }
 
-    if(amnt > NUM2INT(NIO_ByteBuffer_remaining(self))) {
-        rb_raise(rb_eTypeError, "Less number of elements remaining");
+    if(lim > buffer->capacity) {
+        rb_raise(rb_eArgError, "specified limit exceeds capacity");
     }
 
-    char tempArray[amnt+1];
-    int c = 0;
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    buffer->limit = lim;
+
+    if(buffer->position > lim) {
+        buffer->position = lim;
+    }
 
-    while(c < amnt) {
-        tempArray[c++] = byteBuffer->buffer[byteBuffer->position];
-        byteBuffer->position++;
+    if(buffer->mark > lim) {
+        buffer->mark = MARK_UNSET;
     }
 
-    tempArray[amnt] = '\0';
-    return rb_str_new2(tempArray);
+    return new_limit;
 }
 
-static VALUE NIO_ByteBuffer_writeTo(VALUE self, VALUE io)
+static VALUE NIO_ByteBuffer_capacity(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
-    int size = byteBuffer->limit + 1 - byteBuffer->position;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    #if HAVE_RB_IO_T
-        rb_io_t        *fptr;
-    #else
-        OpenFile       *fptr;
-    #endif
+    return INT2NUM(buffer->capacity);
+}
 
-    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-    rb_io_set_nonblock(fptr);
+static VALUE NIO_ByteBuffer_remaining(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    VALUE content = NIO_ByteBuffer_get(self);
-    char* contentAsPointer = StringValuePtr(content);
+    return INT2NUM(buffer->limit - buffer->position);
+}
 
-    write(FPTR_TO_FD(fptr), contentAsPointer , size);
+static VALUE NIO_ByteBuffer_full(VALUE self)
+{
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    return self;
+    return buffer->position == buffer->limit ? Qtrue : Qfalse;
 }
 
-static VALUE NIO_ByteBuffer_readFrom(VALUE self, VALUE io)
+static VALUE NIO_ByteBuffer_get(int argc, VALUE *argv, VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
-    int size = byteBuffer->limit + 1 - byteBuffer->position;
+    int len;
+    VALUE length, result;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    #if HAVE_RB_IO_T
-        rb_io_t        *fptr;
-    #else
-        OpenFile       *fptr;
-    #endif
+    rb_scan_args(argc, argv, "01", &length);
 
-    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-    rb_io_set_nonblock(fptr);
+    if(length == Qnil) {
+        len = buffer->limit - buffer->position;
+    } else {
+        len = NUM2INT(length);
+    }
 
-    while(NIO_ByteBuffer_hasRemaining(self) == Qtrue) {
-        char* nextByte;
-        read(FPTR_TO_FD(fptr), &nextByte, 1);
-        VALUE byte = rb_str_new2(nextByte);
-        NIO_ByteBuffer_put(self, byte);
+    if(len < 0) {
+        rb_raise(rb_eArgError, "negative length given");
     }
 
-    return self;
-}
+    if(len > buffer->limit - buffer->position) {
+        rb_raise(cNIO_ByteBuffer_UnderflowError, "not enough data in buffer");
+    }
 
-static VALUE NIO_ByteBuffer_remaining(VALUE self)
-{
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    result = rb_str_new(buffer->buffer + buffer->position, len);
+    buffer->position += len;
 
-    return INT2NUM(byteBuffer->limit + 1 - byteBuffer->position);
+    return result;
 }
 
-static VALUE NIO_ByteBuffer_hasRemaining(VALUE self)
+static VALUE NIO_ByteBuffer_fetch(VALUE self, VALUE index)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    return ((byteBuffer->limit + 1 - byteBuffer->position) > 0) ? Qtrue : Qfalse;
-}
+    int i = NUM2INT(index);
 
-static VALUE NIO_ByteBuffer_getOffset(VALUE self)
-{
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
-    return INT2NUM(byteBuffer->offset);
-}
+    if(i < 0) {
+        rb_raise(rb_eArgError, "negative index given");
+    }
 
-static VALUE NIO_ByteBuffer_equals(VALUE self, VALUE other)
-{
-    return self == other ? Qtrue : Qfalse;
+    if(i >= buffer->limit) {
+        rb_raise(rb_eArgError, "specified index exceeds limit");
+    }
+
+    return INT2NUM(buffer->buffer[i]);
 }
 
-static VALUE NIO_ByteBuffer_flip(VALUE self)
+static VALUE NIO_ByteBuffer_put(VALUE self, VALUE string)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    long length = RSTRING_LEN(string);
+
+    if(length > buffer->limit - buffer->position) {
+        rb_raise(cNIO_ByteBuffer_OverflowError, "buffer is full");
+    }
 
-    byteBuffer->limit = (byteBuffer->position > 0) ? byteBuffer->position - 1 : 0;
-    byteBuffer->position = 0;
-    byteBuffer->mark = -1;
+    memcpy(buffer->buffer + buffer->position, StringValuePtr(string), length);
+    buffer->position += length;
 
     return self;
 }
 
-static VALUE NIO_ByteBuffer_rewind(VALUE self)
+static VALUE NIO_ByteBuffer_read_from(VALUE self, VALUE io)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    rb_io_t *fptr;
+    ssize_t nbytes, bytes_read;
 
-    byteBuffer->position = 0;
-    byteBuffer->mark = -1;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
 
-    return self;
-}
+    nbytes = buffer->limit - buffer->position;
+    if(nbytes == 0) {
+        rb_raise(cNIO_ByteBuffer_OverflowError, "buffer is full");
+    }
 
-static VALUE NIO_ByteBuffer_reset(VALUE self)
-{
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    bytes_read = read(FPTR_TO_FD(fptr), buffer->buffer + buffer->position, nbytes);
 
-    if(byteBuffer->mark < 0){
-        rb_raise(rb_eRuntimeError, "Invalid Mark Exception");
-    } else {
-        byteBuffer->position = byteBuffer->mark;
+    if(bytes_read < 0) {
+        if(errno == EAGAIN) {
+            return INT2NUM(0);
+        } else {
+            rb_sys_fail("write");
+        }
     }
 
-    return self;
+    buffer->position += bytes_read;
+
+    return INT2NUM(bytes_read);
 }
 
-static VALUE NIO_ByteBuffer_markBuffer(VALUE self)
+static VALUE NIO_ByteBuffer_write_to(VALUE self, VALUE io)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    rb_io_t *fptr;
+    ssize_t nbytes, bytes_written;
 
-    byteBuffer->mark = byteBuffer->position;
-    return self;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
+
+    nbytes = buffer->limit - buffer->position;
+    if(nbytes == 0) {
+        rb_raise(cNIO_ByteBuffer_UnderflowError, "no data remaining in buffer");
+    }
+
+    bytes_written = write(FPTR_TO_FD(fptr), buffer->buffer + buffer->position, nbytes);
+
+    if(bytes_written < 0) {
+        if(errno == EAGAIN) {
+            return INT2NUM(0);
+        } else {
+            rb_sys_fail("write");
+        }
+    }
+
+    buffer->position += bytes_written;
+
+    return INT2NUM(bytes_written);
 }
 
-static VALUE NIO_ByteBuffer_clear(VALUE self)
+static VALUE NIO_ByteBuffer_flip(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    byteBuffer->position = 0;
-    byteBuffer->limit = byteBuffer->size - 1;
-    byteBuffer->mark = -1;
+    buffer->limit = buffer->position;
+    buffer->position = 0;
+    buffer->mark = MARK_UNSET;
 
     return self;
 }
 
-static VALUE NIO_ByteBuffer_compact(VALUE self)
+static VALUE NIO_ByteBuffer_rewind(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
-
-    if(NIO_ByteBuffer_hasRemaining(self) == Qtrue) {
-        //move content
-        int i = 0, j = byteBuffer->position;
-        for(j = byteBuffer->position; j <= byteBuffer->limit; j++) {
-            byteBuffer->buffer[i++] = byteBuffer->buffer[j];
-        }
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-        byteBuffer->position = i;
-        byteBuffer->limit = byteBuffer->size - 1;
-    }
+    buffer->position = 0;
+    buffer->mark = MARK_UNSET;
 
     return self;
 }
 
-static VALUE NIO_ByteBuffer_capacity(VALUE self)
+static VALUE NIO_ByteBuffer_mark(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    return INT2NUM(byteBuffer->size);
+    buffer->mark = buffer->position;
+    return self;
 }
 
-static VALUE NIO_ByteBuffer_position(VALUE self, VALUE newposition)
+static VALUE NIO_ByteBuffer_reset(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    int newPosition = NUM2INT(newposition);
-
-    if(newPosition < 0 || newPosition > byteBuffer->limit) {
-      rb_raise(rb_eRuntimeError, "Illegal Argument Exception");
+    if(buffer->mark < 0) {
+        rb_raise(cNIO_ByteBuffer_MarkUnsetError, "mark has not been set");
     } else {
-        byteBuffer->position = newPosition;
-
-        if(byteBuffer->mark > newPosition) {
-            byteBuffer->mark = -1;
-        }
+        buffer->position = buffer->mark;
     }
+
     return self;
 }
 
-static VALUE NIO_ByteBuffer_setLimit(VALUE self, VALUE newlimit)
+static VALUE NIO_ByteBuffer_compact(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-    int newLimit = NUM2INT(newlimit);
+    memmove(buffer->buffer, buffer->buffer + buffer->position, buffer->limit - buffer->position);
+    buffer->position = buffer->limit - buffer->position;
+    buffer->limit = buffer->capacity;
 
-    if(newLimit < byteBuffer->size && newLimit >= 0)
-    {
-        byteBuffer->limit = newLimit;
+    return self;
+}
 
-        if(byteBuffer->position > byteBuffer->limit) {
-            byteBuffer->position = newLimit;
-        }
+static VALUE NIO_ByteBuffer_each(VALUE self)
+{
+    int i;
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
 
-        if(byteBuffer->mark > byteBuffer->limit) {
-            byteBuffer->mark  = -1;
+    if(rb_block_given_p()) {
+        for(i = 0; i < buffer->limit; i++) {
+            rb_yield(INT2NUM(buffer->buffer[i]));
         }
     } else {
-        rb_raise(rb_eRuntimeError, "Illegal Argument Exception");
+        rb_raise(rb_eArgError, "no block given");
     }
 
     return self;
 }
 
-static VALUE NIO_ByteBuffer_getLimit(VALUE self)
+static VALUE NIO_ByteBuffer_inspect(VALUE self)
 {
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
-
-    return INT2NUM(byteBuffer->limit);
-}
-
-static VALUE NIO_ByteBuffer_toString(VALUE self)
-{
-    struct NIO_ByteBuffer *byteBuffer;
-    Data_Get_Struct(self, struct NIO_ByteBuffer, byteBuffer);
-
-    return rb_sprintf ("ByteBuffer [pos=%d lim=%d cap=%d]\n", byteBuffer->position, byteBuffer->limit, byteBuffer->size);
+    struct NIO_ByteBuffer *buffer;
+    Data_Get_Struct(self, struct NIO_ByteBuffer, buffer);
+
+    return rb_sprintf(
+        "#<%s:%p @position=%d @limit=%d @capacity=%d>",
+        rb_class2name(CLASS_OF(self)),
+        (void*)self,
+        buffer->position,
+        buffer->limit,
+        buffer->capacity
+    );
 }