thrift 0.6.0 → 0.7.0

data/ext/constants.h

@@ -74,6 +74,7 @@ extern ID write_field_stop_method_id;
 extern ID skip_method_id;
 extern ID write_method_id;
 extern ID read_all_method_id;
+extern ID read_into_buffer_method_id;
 extern ID native_qmark_method_id;
 
 extern ID fields_const_id;

data/ext/memory_buffer.c

@@ -30,6 +30,11 @@ int GARBAGE_BUFFER_SIZE;
 
 #define GET_BUF(self) rb_ivar_get(self, buf_ivar_id)
 
+VALUE rb_thrift_memory_buffer_write(VALUE self, VALUE str);
+VALUE rb_thrift_memory_buffer_read(VALUE self, VALUE length_value);
+VALUE rb_thrift_memory_buffer_read_byte(VALUE self);
+VALUE rb_thrift_memory_buffer_read_into_buffer(VALUE self, VALUE buffer_value, VALUE size_value);
+
 VALUE rb_thrift_memory_buffer_write(VALUE self, VALUE str) {
   VALUE buf = GET_BUF(self);
   rb_str_buf_cat(buf, RSTRING_PTR(str), RSTRING_LEN(str));
@@ -53,19 +58,69 @@ VALUE rb_thrift_memory_buffer_read(VALUE self, VALUE length_value) {
     rb_ivar_set(self, buf_ivar_id, rb_funcall(buf, slice_method_id, 2, INT2FIX(index), INT2FIX(RSTRING_LEN(buf) - 1)));
     index = 0;
   }
+  rb_ivar_set(self, index_ivar_id, INT2FIX(index));
 
   if (RSTRING_LEN(data) < length) {
     rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
   }
 
-  rb_ivar_set(self, index_ivar_id, INT2FIX(index));
   return data;
 }
 
+VALUE rb_thrift_memory_buffer_read_byte(VALUE self) {
+  VALUE index_value = rb_ivar_get(self, index_ivar_id);
+  int index = FIX2INT(index_value);
+
+  VALUE buf = GET_BUF(self);
+  if (index >= RSTRING_LEN(buf)) {
+    rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
+  }
+  char byte = RSTRING_PTR(buf)[index++];
+
+  if (index >= GARBAGE_BUFFER_SIZE) {
+    rb_ivar_set(self, buf_ivar_id, rb_funcall(buf, slice_method_id, 2, INT2FIX(index), INT2FIX(RSTRING_LEN(buf) - 1)));
+    index = 0;
+  }
+  rb_ivar_set(self, index_ivar_id, INT2FIX(index));
+
+  int result = (int) byte;
+  return INT2FIX(result);
+}
+
+VALUE rb_thrift_memory_buffer_read_into_buffer(VALUE self, VALUE buffer_value, VALUE size_value) {
+  int i = 0;
+  int size = FIX2INT(size_value);
+  int index;
+  VALUE buf = GET_BUF(self);
+
+  while (i < size) {
+    index = FIX2INT(rb_ivar_get(self, index_ivar_id));
+    if (index >= RSTRING_LEN(buf)) {
+      rb_raise(rb_eEOFError, "Not enough bytes remain in memory buffer");
+    }
+    char byte = RSTRING_PTR(buf)[index++];
+
+    if (index >= GARBAGE_BUFFER_SIZE) {
+      rb_ivar_set(self, buf_ivar_id, rb_funcall(buf, slice_method_id, 2, INT2FIX(index), INT2FIX(RSTRING_LEN(buf) - 1)));
+      index = 0;
+    }
+    rb_ivar_set(self, index_ivar_id, INT2FIX(index));
+
+    if (i >= RSTRING_LEN(buffer_value)) {
+      rb_raise(rb_eIndexError, "index %d out of string", i);
+    }
+    ((char*)RSTRING_PTR(buffer_value))[i] = byte;
+    i++;
+  }
+  return INT2FIX(i);
+}
+
 void Init_memory_buffer() {
   VALUE thrift_memory_buffer_class = rb_const_get(thrift_module, rb_intern("MemoryBufferTransport"));
   rb_define_method(thrift_memory_buffer_class, "write", rb_thrift_memory_buffer_write, 1);
   rb_define_method(thrift_memory_buffer_class, "read", rb_thrift_memory_buffer_read, 1);
+  rb_define_method(thrift_memory_buffer_class, "read_byte", rb_thrift_memory_buffer_read_byte, 0);
+  rb_define_method(thrift_memory_buffer_class, "read_into_buffer", rb_thrift_memory_buffer_read_into_buffer, 2);
   
   buf_ivar_id = rb_intern("@buf");
   index_ivar_id = rb_intern("@index");

data/ext/struct.c

@@ -55,6 +55,7 @@ ID setvalue_id;
 
 ID to_s_method_id;
 ID name_to_id_method_id;
+static ID sorted_field_ids_method_id;
 
 #define IS_CONTAINER(ttype) ((ttype) == TTYPE_MAP || (ttype) == TTYPE_LIST || (ttype) == TTYPE_SET)
 #define STRUCT_FIELDS(obj) rb_const_get(CLASS_OF(obj), fields_const_id)
@@ -375,13 +376,11 @@ static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol) {
 
   // iterate through all the fields here
   VALUE struct_fields = STRUCT_FIELDS(self);
-
-  VALUE struct_field_ids_unordered = rb_funcall(struct_fields, keys_method_id, 0);
-  VALUE struct_field_ids_ordered = rb_funcall(struct_field_ids_unordered, sort_method_id, 0);
+  VALUE sorted_field_ids = rb_funcall(self, sorted_field_ids_method_id, 0);
 
   int i = 0;
-  for (i=0; i < RARRAY_LEN(struct_field_ids_ordered); i++) {
-    VALUE field_id = rb_ary_entry(struct_field_ids_ordered, i);
+  for (i=0; i < RARRAY_LEN(sorted_field_ids); i++) {
+    VALUE field_id = rb_ary_entry(sorted_field_ids, i);
 
     VALUE field_info = rb_hash_aref(struct_fields, field_id);
 
@@ -414,6 +413,8 @@ static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol) {
 
 static VALUE rb_thrift_union_read(VALUE self, VALUE protocol);
 static VALUE rb_thrift_struct_read(VALUE self, VALUE protocol);
+static void skip_map_contents(VALUE protocol, VALUE key_type_value, VALUE value_type_value, int size);
+static void skip_list_or_set_contents(VALUE protocol, VALUE element_type_value, int size);
 
 static void set_field_value(VALUE obj, VALUE field_name, VALUE value) {
   char name_buf[RSTRING_LEN(field_name) + 1];
@@ -424,6 +425,23 @@ static void set_field_value(VALUE obj, VALUE field_name, VALUE value) {
   rb_ivar_set(obj, rb_intern(name_buf), value);
 }
 
+// Helper method to skip the contents of a map (assumes the map header has been read).
+static void skip_map_contents(VALUE protocol, VALUE key_type_value, VALUE value_type_value, int size) {
+  int i;
+  for (i = 0; i < size; i++) {
+    rb_funcall(protocol, skip_method_id, 1, key_type_value);
+    rb_funcall(protocol, skip_method_id, 1, value_type_value);
+  }
+}
+
+// Helper method to skip the contents of a list or set (assumes the list/set header has been read).
+static void skip_list_or_set_contents(VALUE protocol, VALUE element_type_value, int size) {
+  int i;
+  for (i = 0; i < size; i++) {
+    rb_funcall(protocol, skip_method_id, 1, element_type_value);
+  }
+}
+
 static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
   VALUE result = Qnil;
 
@@ -458,18 +476,30 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
     int value_ttype = FIX2INT(rb_ary_entry(map_header, 1));
     int num_entries = FIX2INT(rb_ary_entry(map_header, 2));
 
+    // Check the declared key and value types against the expected ones and skip the map contents
+    // if the types don't match.
     VALUE key_info = rb_hash_aref(field_info, key_sym);
     VALUE value_info = rb_hash_aref(field_info, value_sym);
 
-    result = rb_hash_new();
+    if (!NIL_P(key_info) && !NIL_P(value_info)) {
+      int specified_key_type = FIX2INT(rb_hash_aref(key_info, type_sym));
+      int specified_value_type = FIX2INT(rb_hash_aref(value_info, type_sym));
+      if (specified_key_type == key_ttype && specified_value_type == value_ttype) {
+        result = rb_hash_new();
 
-    for (i = 0; i < num_entries; ++i) {
-      VALUE key, val;
+        for (i = 0; i < num_entries; ++i) {
+          VALUE key, val;
 
-      key = read_anything(protocol, key_ttype, key_info);
-      val = read_anything(protocol, value_ttype, value_info);
+          key = read_anything(protocol, key_ttype, key_info);
+          val = read_anything(protocol, value_ttype, value_info);
 
-      rb_hash_aset(result, key, val);
+          rb_hash_aset(result, key, val);
+        }
+      } else {
+        skip_map_contents(protocol, INT2FIX(key_ttype), INT2FIX(value_ttype), num_entries);
+      }
+    } else {
+      skip_map_contents(protocol, INT2FIX(key_ttype), INT2FIX(value_ttype), num_entries);
     }
 
     default_read_map_end(protocol);
@@ -479,10 +509,23 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
     VALUE list_header = default_read_list_begin(protocol);
     int element_ttype = FIX2INT(rb_ary_entry(list_header, 0));
     int num_elements = FIX2INT(rb_ary_entry(list_header, 1));
-    result = rb_ary_new2(num_elements);
 
-    for (i = 0; i < num_elements; ++i) {
-      rb_ary_push(result, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym)));
+    // Check the declared element type against the expected one and skip the list contents
+    // if the types don't match.
+    VALUE element_info = rb_hash_aref(field_info, element_sym);
+    if (!NIL_P(element_info)) {
+      int specified_element_type = FIX2INT(rb_hash_aref(element_info, type_sym));
+      if (specified_element_type == element_ttype) {
+        result = rb_ary_new2(num_elements);
+
+        for (i = 0; i < num_elements; ++i) {
+          rb_ary_push(result, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym)));
+        }
+      } else {
+        skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements);
+      }
+    } else {
+      skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements);
     }
 
     default_read_list_end(protocol);
@@ -493,15 +536,28 @@ static VALUE read_anything(VALUE protocol, int ttype, VALUE field_info) {
     VALUE set_header = default_read_set_begin(protocol);
     int element_ttype = FIX2INT(rb_ary_entry(set_header, 0));
     int num_elements = FIX2INT(rb_ary_entry(set_header, 1));
-    items = rb_ary_new2(num_elements);
 
-    for (i = 0; i < num_elements; ++i) {
-      rb_ary_push(items, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym)));
+    // Check the declared element type against the expected one and skip the set contents
+    // if the types don't match.
+    VALUE element_info = rb_hash_aref(field_info, element_sym);
+    if (!NIL_P(element_info)) {
+      int specified_element_type = FIX2INT(rb_hash_aref(element_info, type_sym));
+      if (specified_element_type == element_ttype) {
+        items = rb_ary_new2(num_elements);
+
+        for (i = 0; i < num_elements; ++i) {
+          rb_ary_push(items, read_anything(protocol, element_ttype, rb_hash_aref(field_info, element_sym)));
+        }
+
+        result = rb_class_new_instance(1, &items, rb_cSet);
+      } else {
+        skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements);
+      }
+    } else {
+      skip_list_or_set_contents(protocol, INT2FIX(element_ttype), num_elements);
     }
 
     default_read_set_end(protocol);
-
-    result = rb_class_new_instance(1, &items, rb_cSet);
   } else {
     rb_raise(rb_eNotImpError, "read_anything not implemented for type %d!", ttype);
   }
@@ -657,4 +713,5 @@ void Init_struct() {
 
   to_s_method_id = rb_intern("to_s");
   name_to_id_method_id = rb_intern("name_to_id");
+  sorted_field_ids_method_id = rb_intern("sorted_field_ids");
 }

data/ext/thrift_native.c

@@ -88,6 +88,7 @@ ID write_field_stop_method_id;
 ID skip_method_id;
 ID write_method_id;
 ID read_all_method_id;
+ID read_into_buffer_method_id;
 ID native_qmark_method_id;
 
 // constant ids
@@ -170,6 +171,7 @@ void Init_thrift_native() {
   skip_method_id = rb_intern("skip");
   write_method_id = rb_intern("write");
   read_all_method_id = rb_intern("read_all");
+  read_into_buffer_method_id = rb_intern("read_into_buffer");
   native_qmark_method_id = rb_intern("native?");
 
   // constant ids

data/lib/thrift/exceptions.rb

@@ -35,6 +35,8 @@ module Thrift
     WRONG_METHOD_NAME = 3
     BAD_SEQUENCE_ID = 4
     MISSING_RESULT = 5
+    INTERNAL_ERROR = 6
+    PROTOCOL_ERROR = 7
 
     attr_reader :type
 
@@ -79,4 +81,4 @@ module Thrift
     end
 
   end
-end
+end

data/lib/thrift/protocol/binary_protocol.rb

@@ -29,6 +29,11 @@ module Thrift
       super(trans)
       @strict_read = strict_read
       @strict_write = strict_write
+
+      # Pre-allocated read buffer for fixed-size read methods. Needs to be at least 8 bytes long for
+      # read_i64() and read_double().
+      @rbuf = "\0" * 8
+      @rbuf.force_encoding("BINARY") if @rbuf.respond_to?(:force_encoding)
     end
 
     def write_message_begin(name, type, seqid)
@@ -165,8 +170,7 @@ module Thrift
     end
 
     def read_byte
-      dat = trans.read_all(1)
-      val = dat[0].ord
+      val = trans.read_byte
       if (val > 0x7f)
         val = 0 - ((val - 1) ^ 0xff)
       end
@@ -174,8 +178,8 @@ module Thrift
     end
 
     def read_i16
-      dat = trans.read_all(2)
-      val, = dat.unpack('n')
+      trans.read_into_buffer(@rbuf, 2)
+      val, = @rbuf.unpack('n')
       if (val > 0x7fff)
         val = 0 - ((val - 1) ^ 0xffff)
       end
@@ -183,8 +187,8 @@ module Thrift
     end
 
     def read_i32
-      dat = trans.read_all(4)
-      val, = dat.unpack('N')
+      trans.read_into_buffer(@rbuf, 4)
+      val, = @rbuf.unpack('N')
       if (val > 0x7fffffff)
         val = 0 - ((val - 1) ^ 0xffffffff)
       end
@@ -192,8 +196,8 @@ module Thrift
     end
 
     def read_i64
-      dat = trans.read_all(8)
-      hi, lo = dat.unpack('N2')
+      trans.read_into_buffer(@rbuf, 8)
+      hi, lo = @rbuf.unpack('N2')
       if (hi > 0x7fffffff)
         hi ^= 0xffffffff
         lo ^= 0xffffffff
@@ -204,8 +208,8 @@ module Thrift
     end
 
     def read_double
-      dat = trans.read_all(8)
-      val = dat.unpack('G').first
+      trans.read_into_buffer(@rbuf, 8)
+      val = @rbuf.unpack('G').first
       val
     end
 

data/lib/thrift/protocol/compact_protocol.rb

@@ -98,6 +98,10 @@ module Thrift
 
       @last_field = [0]
       @boolean_value = nil
+
+      # Pre-allocated read buffer for read_double().
+      @rbuf = "\0" * 8
+      @rbuf.force_encoding("BINARY") if @rbuf.respond_to?(:force_encoding)
     end
 
     def write_message_begin(name, type, seqid)
@@ -302,8 +306,7 @@ module Thrift
     end
 
     def read_byte
-      dat = trans.read_all(1)
-      val = dat[0]
+      val = trans.read_byte
       if (val > 0x7f)
         val = 0 - ((val - 1) ^ 0xff)
       end
@@ -323,8 +326,8 @@ module Thrift
     end
 
     def read_double
-      dat = trans.read_all(8)
-      val = dat.reverse.unpack('G').first
+      trans.read_into_buffer(@rbuf, 8)
+      val = @rbuf.reverse.unpack('G').first
       val
     end
 

data/lib/thrift/server/nonblocking_server.rb

@@ -44,7 +44,13 @@ module Thrift
       begin
         loop do
           break if @server_transport.closed?
-          rd, = select([@server_transport], nil, nil, 0.1)
+          begin
+            rd, = select([@server_transport], nil, nil, 0.1)
+          rescue Errno::EBADF => e
+            # In Ruby 1.9, calling @server_transport.close in shutdown paths causes the select() to raise an
+            # Errno::EBADF. If this happens, ignore it and retry the loop.
+            break
+          end
           next if rd.nil?
           socket = @server_transport.accept
           @logger.debug "Accepted socket: #{socket.inspect}"
@@ -146,10 +152,14 @@ module Thrift
             break if read_signals == :shutdown
           end
           rd.each do |fd|
-            if fd.handle.eof?
+            begin
+              if fd.handle.eof?
+                remove_connection fd
+              else
+                read_connection fd
+              end
+            rescue Errno::ECONNRESET
               remove_connection fd
-            else
-              read_connection fd
             end
           end
         end
@@ -292,4 +302,4 @@ module Thrift
       end
     end
   end
-end
+end

data/lib/thrift/struct.rb

@@ -55,7 +55,7 @@ module Thrift
     end
 
     def fields_with_default_values
-      fields_with_default_values = self.class.instance_variable_get("@fields_with_default_values")
+      fields_with_default_values = self.class.instance_variable_get(:@fields_with_default_values)
       unless fields_with_default_values
         fields_with_default_values = {}
         struct_fields.each do |fid, field_def|
@@ -63,7 +63,7 @@ module Thrift
             fields_with_default_values[field_def[:name]] = field_def[:default]
           end
         end
-        self.class.instance_variable_set("@fields_with_default_values", fields_with_default_values)
+        self.class.instance_variable_set(:@fields_with_default_values, fields_with_default_values)
       end
       fields_with_default_values
     end
@@ -114,9 +114,10 @@ module Thrift
     end
 
     def ==(other)
+      return false if other.nil?
       each_field do |fid, field_info|
         name = field_info[:name]
-        return false unless self.instance_variable_get("@#{name}") == other.instance_variable_get("@#{name}")
+        return false unless other.respond_to?(name) && self.send(name) == other.send(name)
       end
       true
     end
@@ -125,13 +126,15 @@ module Thrift
       self.class == other.class && self == other
     end
 
+    # This implementation of hash() is inspired by Apache's Java HashCodeBuilder class.
     def hash
-      field_values = []
+      total = 17
       each_field do |fid, field_info|
         name = field_info[:name]
-        field_values << self.instance_variable_get("@#{name}")
+        value = self.send(name)
+        total = (total * 37 + value.hash) & 0xffffffff
       end
-      field_values.hash
+      total
     end
 
     def differences(other)

data/lib/thrift/struct_union.rb

@@ -21,19 +21,28 @@ require 'set'
 module Thrift
   module Struct_Union
     def name_to_id(name)
-      names_to_ids = self.class.instance_variable_get("@names_to_ids")
+      names_to_ids = self.class.instance_variable_get(:@names_to_ids)
       unless names_to_ids
         names_to_ids = {}
         struct_fields.each do |fid, field_def|
           names_to_ids[field_def[:name]] = fid
         end
-        self.class.instance_variable_set("@names_to_ids", names_to_ids)
+        self.class.instance_variable_set(:@names_to_ids, names_to_ids)
       end
       names_to_ids[name]
     end
 
+    def sorted_field_ids
+      sorted_field_ids = self.class.instance_variable_get(:@sorted_field_ids)
+      unless sorted_field_ids
+        sorted_field_ids = struct_fields.keys.sort
+        self.class.instance_variable_set(:@sorted_field_ids, sorted_field_ids)
+      end
+      sorted_field_ids
+    end
+
     def each_field
-      struct_fields.keys.sort.each do |fid|
+      sorted_field_ids.each do |fid|
         data = struct_fields[fid]
         yield fid, data
       end
@@ -46,25 +55,49 @@ module Thrift
         value.read(iprot)
       when Types::MAP
         key_type, val_type, size = iprot.read_map_begin
-        value = {}
-        size.times do
-          k = read_field(iprot, field_info(field[:key]))
-          v = read_field(iprot, field_info(field[:value]))
-          value[k] = v
+        # Skip the map contents if the declared key or value types don't match the expected ones.
+        if (key_type != field[:key][:type] || val_type != field[:value][:type])
+          size.times do
+            iprot.skip(key_type)
+            iprot.skip(val_type)
+          end
+          value = nil
+        else
+          value = {}
+          size.times do
+            k = read_field(iprot, field_info(field[:key]))
+            v = read_field(iprot, field_info(field[:value]))
+            value[k] = v
+          end
         end
         iprot.read_map_end
       when Types::LIST
         e_type, size = iprot.read_list_begin
-        value = Array.new(size) do |n|
-          read_field(iprot, field_info(field[:element]))
+        # Skip the list contents if the declared element type doesn't match the expected one.
+        if (e_type != field[:element][:type])
+          size.times do
+            iprot.skip(e_type)
+          end
+          value = nil
+        else
+          value = Array.new(size) do |n|
+            read_field(iprot, field_info(field[:element]))
+          end
         end
         iprot.read_list_end
       when Types::SET
         e_type, size = iprot.read_set_begin
-        value = Set.new
-        size.times do
-          element = read_field(iprot, field_info(field[:element]))
-          value << element
+        # Skip the set contents if the declared element type doesn't match the expected one.
+        if (e_type != field[:element][:type])
+          size.times do
+            iprot.skip(e_type)
+          end
+        else
+          value = Set.new
+          size.times do
+            element = read_field(iprot, field_info(field[:element]))
+            value << element
+          end
         end
         iprot.read_set_end
       else

data/lib/thrift/transport/base_transport.rb

@@ -34,6 +34,26 @@ module Thrift
     end
   end
 
+  module TransportUtils
+    if RUBY_VERSION >= '1.9'
+      def self.get_string_byte(string, index)
+        string.getbyte(index)
+      end
+
+      def self.set_string_byte(string, index, byte)
+        string.setbyte(index, byte)
+      end
+    else
+      def self.get_string_byte(string, index)
+        string[index]
+      end
+
+      def self.set_string_byte(string, index, byte)
+        string[index] = byte
+      end
+    end
+  end
+
   class BaseTransport
     def open?; end
     
@@ -45,9 +65,26 @@ module Thrift
       raise NotImplementedError
     end
 
+    # Returns an unsigned byte as a Fixnum in the range (0..255).
+    def read_byte
+      buf = read_all(1)
+      return ::Thrift::TransportUtils.get_string_byte(buf, 0)
+    end
+
+    # Reads size bytes and copies them into buffer[0..size].
+    def read_into_buffer(buffer, size)
+      tmp = read_all(size)
+      i = 0
+      tmp.each_byte do |byte|
+        ::Thrift::TransportUtils.set_string_byte(buffer, i, byte)
+        i += 1
+      end
+      i
+    end
+
     def read_all(size)
-      buf = ''
-    
+      return '' if size <= 0
+      buf = read(size)
       while (buf.length < size)
         chunk = read(size - buf.length)
         buf << chunk

data/lib/thrift/transport/buffered_transport.rb

@@ -55,6 +55,37 @@ module Thrift
       ret
     end
 
+    def read_byte
+      # If the read buffer is exhausted, try to read up to DEFAULT_BUFFER more bytes into it.
+      if @index >= @rbuf.size
+        @rbuf = @transport.read(DEFAULT_BUFFER)
+        @index = 0
+      end
+
+      # The read buffer has some data now, read a single byte. Using get_string_byte() avoids
+      # allocating a temp string of size 1 unnecessarily.
+      @index += 1
+      return ::Thrift::TransportUtils.get_string_byte(@rbuf, @index - 1)
+    end
+
+    def read_into_buffer(buffer, size)
+      i = 0
+      while i < size
+        # If the read buffer is exhausted, try to read up to DEFAULT_BUFFER more bytes into it.
+        if @index >= @rbuf.size
+          @rbuf = @transport.read(DEFAULT_BUFFER)
+          @index = 0
+        end
+
+        # The read buffer has some data now, so copy bytes over to the output buffer.
+        byte = ::Thrift::TransportUtils.get_string_byte(@rbuf, @index)
+        ::Thrift::TransportUtils.set_string_byte(buffer, i, byte)
+        @index += 1
+        i += 1
+      end
+      i
+    end
+
     def write(buf)
       @wbuf << buf
     end