thrift 0.2.0.4 → 0.4.0

data/ext/struct.h

@@ -17,51 +17,9 @@
  * under the License.
  */
 
+
 #include <stdbool.h>
 #include <ruby.h>
 
-typedef struct native_proto_method_table {
-  VALUE (*write_bool)(VALUE, VALUE);
-  VALUE (*write_byte)(VALUE, VALUE);
-  VALUE (*write_i16)(VALUE, VALUE);
-  VALUE (*write_i32)(VALUE, VALUE);
-  VALUE (*write_i64)(VALUE, VALUE);
-  VALUE (*write_double)(VALUE, VALUE);
-  VALUE (*write_string)(VALUE, VALUE);
-  VALUE (*write_list_begin)(VALUE, VALUE, VALUE);
-  VALUE (*write_list_end)(VALUE);
-  VALUE (*write_set_begin)(VALUE, VALUE, VALUE);
-  VALUE (*write_set_end)(VALUE);
-  VALUE (*write_map_begin)(VALUE, VALUE, VALUE, VALUE);
-  VALUE (*write_map_end)(VALUE);
-  VALUE (*write_struct_begin)(VALUE, VALUE);
-  VALUE (*write_struct_end)(VALUE);
-  VALUE (*write_field_begin)(VALUE, VALUE, VALUE, VALUE);
-  VALUE (*write_field_end)(VALUE);
-  VALUE (*write_field_stop)(VALUE);
-  VALUE (*write_message_begin)(VALUE, VALUE, VALUE, VALUE);
-  VALUE (*write_message_end)(VALUE);
-  
-  VALUE (*read_message_begin)(VALUE);
-  VALUE (*read_message_end)(VALUE);
-  VALUE (*read_field_begin)(VALUE);
-  VALUE (*read_field_end)(VALUE);
-  VALUE (*read_map_begin)(VALUE);
-  VALUE (*read_map_end)(VALUE);
-  VALUE (*read_list_begin)(VALUE);
-  VALUE (*read_list_end)(VALUE);
-  VALUE (*read_set_begin)(VALUE);
-  VALUE (*read_set_end)(VALUE);
-  VALUE (*read_byte)(VALUE);
-  VALUE (*read_bool)(VALUE);
-  VALUE (*read_i16)(VALUE);
-  VALUE (*read_i32)(VALUE);
-  VALUE (*read_i64)(VALUE);
-  VALUE (*read_double)(VALUE);
-  VALUE (*read_string)(VALUE);
-  VALUE (*read_struct_begin)(VALUE);
-  VALUE (*read_struct_end)(VALUE);
-  
-} native_proto_method_table;
-
 void Init_struct();
+void Init_union();

data/ext/thrift_native.c

@@ -111,7 +111,7 @@ void Init_thrift_native() {
   thrift_types_module = rb_const_get(thrift_module, rb_intern("Types"));
   rb_cSet = rb_const_get(rb_cObject, rb_intern("Set"));
   protocol_exception_class = rb_const_get(thrift_module, rb_intern("ProtocolException"));
-  
+
   // Init ttype constants
   TTYPE_BOOL = FIX2INT(rb_const_get(thrift_types_module, rb_intern("BOOL")));
   TTYPE_BYTE = FIX2INT(rb_const_get(thrift_types_module, rb_intern("BYTE")));
@@ -171,13 +171,13 @@ void Init_thrift_native() {
   write_method_id = rb_intern("write");
   read_all_method_id = rb_intern("read_all");
   native_qmark_method_id = rb_intern("native?");
-  
+
   // constant ids
   fields_const_id = rb_intern("FIELDS");
   transport_ivar_id = rb_intern("@trans");
   strict_read_ivar_id = rb_intern("@strict_read");
   strict_write_ivar_id = rb_intern("@strict_write");  
-  
+
   // cached symbols
   type_sym = ID2SYM(rb_intern("type"));
   name_sym = ID2SYM(rb_intern("name"));

data/lib/thrift.rb

@@ -16,6 +16,9 @@
 # specific language governing permissions and limitations
 # under the License.
 # 
+# Contains some contributions under the Thrift Software License.
+# Please see doc/old-thrift-license.txt in the Thrift distribution for
+# details.
 
 $:.unshift File.dirname(__FILE__)
 
@@ -25,6 +28,8 @@ require 'thrift/types'
 require 'thrift/processor'
 require 'thrift/client'
 require 'thrift/struct'
+require 'thrift/union'
+require 'thrift/struct_union'
 
 # serializer
 require 'thrift/serializer/serializer'
@@ -56,4 +61,4 @@ require 'thrift/server/simple_server'
 require 'thrift/server/threaded_server'
 require 'thrift/server/thread_pool_server'
 
-require 'thrift/thrift_native'
+require 'thrift/thrift_native'

data/lib/thrift/protocol/binary_protocol_accelerated.rb

@@ -29,7 +29,11 @@ See MemoryBuffer and BufferedTransport for examples.
 module Thrift
   class BinaryProtocolAcceleratedFactory < BaseProtocolFactory
     def get_protocol(trans)
-      BinaryProtocolAccelerated.new(trans)
+      if (defined? BinaryProtocolAccelerated)
+        BinaryProtocolAccelerated.new(trans)
+      else
+        BinaryProtocol.new(trans)
+      end
     end
   end
 end

data/lib/thrift/protocol/compact_protocol.rb

@@ -252,6 +252,7 @@ module Thrift
         modifier = (type & 0xf0) >> 4
         if modifier == 0
           # not a delta. look ahead for the zigzag varint field id.
+          @last_field.pop
           field_id = read_i16()
         else
           # has a delta. add the delta to the last read field id.

data/lib/thrift/server/nonblocking_server.rb

@@ -160,8 +160,7 @@ module Thrift
 
       def read_connection(fd)
         @buffers[fd] << fd.read(DEFAULT_BUFFER)
-        frame = slice_frame!(@buffers[fd])
-        if frame
+        while(frame = slice_frame!(@buffers[fd]))
           @logger.debug "#{self} is processing a frame"
           @worker_queue.push [:frame, fd, frame]
         end

data/lib/thrift/struct.rb

@@ -65,33 +65,14 @@ module Thrift
       end
       fields_with_default_values
     end
-
-    def name_to_id(name)
-      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)
-      end
-      names_to_ids[name]
-    end
-
-    def each_field
-      struct_fields.keys.sort.each do |fid|
-        data = struct_fields[fid]
-        yield fid, data
-      end
-    end
-
+    
     def inspect(skip_optional_nulls = true)
       fields = []
       each_field do |fid, field_info|
         name = field_info[:name]
         value = instance_variable_get("@#{name}")
         unless skip_optional_nulls && field_info[:optional] && value.nil?
-          fields << "#{name}:#{value.inspect}"
+          fields << "#{name}:#{inspect_field(value, field_info)}"
         end
       end
       "<#{self.class} #{fields.join(", ")}>"
@@ -115,7 +96,8 @@ module Thrift
       each_field do |fid, field_info|
         name = field_info[:name]
         type = field_info[:type]
-        if (value = instance_variable_get("@#{name}"))
+        value = instance_variable_get("@#{name}")
+        unless value.nil?
           if is_container? type
             oprot.write_field_begin(name, type, fid)
             write_container(oprot, value, field_info)
@@ -163,13 +145,49 @@ module Thrift
       diffs
     end
 
-    def self.field_accessor(klass, *fields)
-      fields.each do |field|
-        klass.send :attr_reader, field
-        klass.send :define_method, "#{field}=" do |value|
-          Thrift.check_type(value, klass::FIELDS.values.find { |f| f[:name].to_s == field.to_s }, field) if Thrift.type_checking
-          instance_variable_set("@#{field}", value)
+    def self.field_accessor(klass, field_info)
+      field_name_sym = field_info[:name].to_sym
+      klass.send :attr_reader, field_name_sym
+      klass.send :define_method, "#{field_info[:name]}=" do |value|
+        Thrift.check_type(value, field_info, field_info[:name]) if Thrift.type_checking
+        instance_variable_set("@#{field_name_sym}", value)
+      end
+    end
+
+    def self.generate_accessors(klass)
+      klass::FIELDS.values.each do |field_info|
+        field_accessor(klass, field_info)
+        qmark_isset_method(klass, field_info)
+      end
+    end
+
+    def self.qmark_isset_method(klass, field_info)
+      klass.send :define_method, "#{field_info[:name]}?" do
+        !self.send(field_info[:name].to_sym).nil?
+      end
+    end
+
+    def <=>(other)
+      if self.class == other.class
+        each_field do |fid, field_info|
+          v1 = self.send(field_info[:name])
+          v1_set = !v1.nil?
+          v2 = other.send(field_info[:name])
+          v2_set = !v2.nil?
+          if v1_set && !v2_set
+            return -1
+          elsif !v1_set && v2_set
+            return 1
+          elsif v1_set && v2_set
+            cmp = v1 <=> v2
+            if cmp != 0
+              return cmp
+            end
+          end
         end
+        0
+      else
+        self.class <=> other.class
       end
     end
 
@@ -210,89 +228,5 @@ module Thrift
         iprot.skip(ftype)
       end
     end
-
-    def read_field(iprot, field = {})
-      case field[:type]
-      when Types::STRUCT
-        value = field[:class].new
-        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
-        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]))
-        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
-        end
-        iprot.read_set_end
-      else
-        value = iprot.read_type(field[:type])
-      end
-      value
-    end
-
-    def write_data(oprot, value, field)
-      if is_container? field[:type]
-        write_container(oprot, value, field)
-      else
-        oprot.write_type(field[:type], value)
-      end
-    end
-
-    def write_container(oprot, value, field = {})
-      case field[:type]
-      when Types::MAP
-        oprot.write_map_begin(field[:key][:type], field[:value][:type], value.size)
-        value.each do |k, v|
-          write_data(oprot, k, field[:key])
-          write_data(oprot, v, field[:value])
-        end
-        oprot.write_map_end
-      when Types::LIST
-        oprot.write_list_begin(field[:element][:type], value.size)
-        value.each do |elem|
-          write_data(oprot, elem, field[:element])
-        end
-        oprot.write_list_end
-      when Types::SET
-        oprot.write_set_begin(field[:element][:type], value.size)
-        value.each do |v,| # the , is to preserve compatibility with the old Hash-style sets
-          write_data(oprot, v, field[:element])
-        end
-        oprot.write_set_end
-      else
-        raise "Not a container type: #{field[:type]}"
-      end
-    end
-
-    CONTAINER_TYPES = []
-    CONTAINER_TYPES[Types::LIST] = true
-    CONTAINER_TYPES[Types::MAP] = true
-    CONTAINER_TYPES[Types::SET] = true
-    def is_container?(type)
-      CONTAINER_TYPES[type]
-    end
-
-    def field_info(field)
-      { :type => field[:type],
-        :class => field[:class],
-        :key => field[:key],
-        :value => field[:value],
-        :element => field[:element] }
-    end
   end
 end

data/lib/thrift/struct_union.rb

@@ -0,0 +1,159 @@
+# 
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+require 'set'
+
+module Thrift
+  module Struct_Union
+    def name_to_id(name)
+      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)
+      end
+      names_to_ids[name]
+    end
+
+    def each_field
+      struct_fields.keys.sort.each do |fid|
+        data = struct_fields[fid]
+        yield fid, data
+      end
+    end
+
+    def read_field(iprot, field = {})
+      case field[:type]
+      when Types::STRUCT
+        value = field[:class].new
+        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
+        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]))
+        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
+        end
+        iprot.read_set_end
+      else
+        value = iprot.read_type(field[:type])
+      end
+      value
+    end
+
+    def write_data(oprot, value, field)
+      if is_container? field[:type]
+        write_container(oprot, value, field)
+      else
+        oprot.write_type(field[:type], value)
+      end
+    end
+
+    def write_container(oprot, value, field = {})
+      case field[:type]
+      when Types::MAP
+        oprot.write_map_begin(field[:key][:type], field[:value][:type], value.size)
+        value.each do |k, v|
+          write_data(oprot, k, field[:key])
+          write_data(oprot, v, field[:value])
+        end
+        oprot.write_map_end
+      when Types::LIST
+        oprot.write_list_begin(field[:element][:type], value.size)
+        value.each do |elem|
+          write_data(oprot, elem, field[:element])
+        end
+        oprot.write_list_end
+      when Types::SET
+        oprot.write_set_begin(field[:element][:type], value.size)
+        value.each do |v,| # the , is to preserve compatibility with the old Hash-style sets
+          write_data(oprot, v, field[:element])
+        end
+        oprot.write_set_end
+      else
+        raise "Not a container type: #{field[:type]}"
+      end
+    end
+
+    CONTAINER_TYPES = []
+    CONTAINER_TYPES[Types::LIST] = true
+    CONTAINER_TYPES[Types::MAP] = true
+    CONTAINER_TYPES[Types::SET] = true
+    def is_container?(type)
+      CONTAINER_TYPES[type]
+    end
+
+    def field_info(field)
+      { :type => field[:type],
+        :class => field[:class],
+        :key => field[:key],
+        :value => field[:value],
+        :element => field[:element] }
+    end
+
+    def inspect_field(value, field_info)
+      if enum_class = field_info[:enum_class]
+        "#{enum_class.const_get(:VALUE_MAP)[value]} (#{value})"
+      elsif value.is_a? Hash 
+        if field_info[:type] == Types::MAP
+          map_buf = []
+          value.each do |k, v|
+            map_buf << inspect_field(k, field_info[:key]) + ": " + inspect_field(v, field_info[:value])
+          end
+          "{" + map_buf.join(", ") + "}"
+        else
+          # old-style set
+          inspect_collection(value.keys, field_info)
+        end
+      elsif value.is_a? Array
+        inspect_collection(value, field_info)
+      elsif value.is_a? Set
+        inspect_collection(value, field_info)
+      elsif value.is_a?(String) && field_info[:binary]
+        value.unpack("H*").first
+      else
+        value.inspect
+      end
+    end
+    
+    def inspect_collection(collection, field_info)
+      buf = []
+      collection.each do |k|
+        buf << inspect_field(k, field_info[:element])
+      end
+      "[" + buf.join(", ") + "]"      
+    end
+  end
+end