From: Kevin Clark Date: Wed, 18 Jun 2008 00:58:23 +0000 (+0000) Subject: Start renaming camelCase methods to ruby_style X-Git-Tag: 0.2.0~632 X-Git-Url: https://source.supwisdom.com/gerrit/gitweb?a=commitdiff_plain;h=b8a7ad727e43be1d40a5532a490857a8d9189598;p=common%2Fthrift.git Start renaming camelCase methods to ruby_style git-svn-id: https://svn.apache.org/repos/asf/incubator/thrift/trunk@668917 13f79535-47bb-0310-9956-ffa450edef68 --- diff --git a/lib/rb/lib/thrift/client.rb b/lib/rb/lib/thrift/client.rb index 55e72b3d..0b0d13e3 100644 --- a/lib/rb/lib/thrift/client.rb +++ b/lib/rb/lib/thrift/client.rb @@ -7,22 +7,22 @@ module Thrift end def send_message(name, args_class, args = {}) - @oprot.writeMessageBegin(name, MessageTypes::CALL, @seqid) + @oprot.write_message_begin(name, MessageTypes::CALL, @seqid) data = args_class.new args.each do |k, v| data.send("#{k.to_s}=", v) end data.write(@oprot) - @oprot.writeMessageEnd() + @oprot.write_message_end() @oprot.trans.flush() end def receive_message(result_klass) - fname, mtype, rseqid = @iprot.readMessageBegin() + fname, mtype, rseqid = @iprot.read_message_begin() handle_exception(mtype) result = result_klass.new result.read(@iprot) - @iprot.readMessageEnd() + @iprot.read_message_end() return result end @@ -30,7 +30,7 @@ module Thrift if mtype == MessageTypes::EXCEPTION x = ApplicationException.new() x.read(@iprot) - @iprot.readMessageEnd() + @iprot.read_message_end() raise x end end diff --git a/lib/rb/lib/thrift/protocol.rb b/lib/rb/lib/thrift/protocol.rb index 47fe7233..553d8d4e 100644 --- a/lib/rb/lib/thrift/protocol.rb +++ b/lib/rb/lib/thrift/protocol.rb @@ -35,106 +35,145 @@ module Thrift @trans = trans end - def writeMessageBegin(name, type, seqid); nil; end + def write_message_begin(name, type, seqid); nil; end + deprecate! :writeMessageBegin => :write_message_begin - def writeMessageEnd; nil; end + def write_message_end; nil; end + deprecate! :writeMessageEnd => :write_message_end - def writeStructBegin(name); nil; end + def write_struct_begin(name); nil; end + deprecate! :writeStructBegin => :write_struct_begin - def writeStructEnd(); nil; end + def write_struct_end(); nil; end + deprecate! :writeStructEnd => :write_struct_end - def writeFieldBegin(name, type, id); nil; end + def write_field_begin(name, type, id); nil; end + deprecate! :writeFieldBegin => :write_field_begin - def writeFieldEnd(); nil; end + def write_field_end(); nil; end + deprecate! :writeFieldEnd => :write_field_end - def writeFieldStop(); nil; end + def write_field_stop(); nil; end + deprecate! :writeFieldStop => :write_field_stop - def writeMapBegin(ktype, vtype, size); nil; end + def write_map_begin(ktype, vtype, size); nil; end + deprecate! :writeMapBegin => :write_map_begin - def writeMapEnd(); nil; end + def write_map_end(); nil; end + deprecate! :writeMapEnd => :write_map_end - def writeListBegin(etype, size); nil; end + def write_list_begin(etype, size); nil; end + deprecate! :writeListBegin => :write_list_begin - def writeListEnd(); nil; end + def write_list_end(); nil; end + deprecate! :writeListEnd => :write_list_end - def writeSetBegin(etype, size); nil; end + def write_set_begin(etype, size); nil; end + deprecate! :writeSetBegin => :write_set_begin - def writeSetEnd(); nil; end + def write_set_end(); nil; end + deprecate! :writeSetEnd => :write_set_end - def writeBool(bool); nil; end + def write_bool(bool); nil; end + deprecate! :writeBool => :write_bool - def writeByte(byte); nil; end + def write_byte(byte); nil; end + deprecate! :writeByte => :write_byte - def writeI16(i16); nil; end + def write_i16(i16); nil; end + deprecate! :writeI16 => :write_i16 - def writeI32(i32); nil; end + def write_i32(i32); nil; end + deprecate! :writeI32 => :write_i32 - def writeI64(i64); nil; end + def write_i64(i64); nil; end + deprecate! :writeI64 => :write_i64 - def writeDouble(dub); nil; end + def write_double(dub); nil; end + deprecate! :writeDouble => :write_double - def writeString(str); nil; end + def write_string(str); nil; end + deprecate! :writeString => :write_string - def readMessageBegin(); nil; end + def read_message_begin(); nil; end + deprecate! :readMessageBegin => :read_message_begin - def readMessageEnd(); nil; end + def read_message_end(); nil; end + deprecate! :readMessageEnd => :read_message_end - def readStructBegin(); nil; end + def read_struct_begin(); nil; end + deprecate! :readStructBegin => :read_struct_begin - def readStructEnd(); nil; end + def read_struct_end(); nil; end + deprecate! :readStructEnd => :read_struct_end - def readFieldBegin(); nil; end + def read_field_begin(); nil; end + deprecate! :readFieldBegin => :read_field_begin - def readFieldEnd(); nil; end + def read_field_end(); nil; end + deprecate! :readFieldEnd => :read_field_end - def readMapBegin(); nil; end + def read_map_begin(); nil; end + deprecate! :readMapBegin => :read_map_begin - def readMapEnd(); nil; end + def read_map_end(); nil; end + deprecate! :readMapEnd => :read_map_end - def readListBegin(); nil; end + def read_list_begin(); nil; end + deprecate! :readListBegin => :read_list_begin - def readListEnd(); nil; end + def read_list_end(); nil; end + deprecate! :readListEnd => :read_list_end - def readSetBegin(); nil; end + def read_set_begin(); nil; end + deprecate! :readSetBegin => :read_set_begin - def readSetEnd(); nil; end + def read_set_end(); nil; end + deprecate! :readSetEnd => :read_set_end - def readBool(); nil; end + def read_bool(); nil; end + deprecate! :readBool => :read_bool - def readByte(); nil; end + def read_byte(); nil; end + deprecate! :readByte => :read_byte - def readI16(); nil; end + def read_i16(); nil; end + deprecate! :readI16 => :read_i16 - def readI32(); nil; end + def read_i32(); nil; end + deprecate! :readI32 => :read_i32 - def readI64(); nil; end + def read_i64(); nil; end + deprecate! :readI64 => :read_i64 - def readDouble(); nil; end + def read_double(); nil; end + deprecate! :readDouble => :read_double - def readString(); nil; end + def read_string(); nil; end + deprecate! :readString => :read_string def write_field(name, type, fid, value) - writeFieldBegin(name, type, fid) + write_field_begin(name, type, fid) write_type(type, value) - writeFieldEnd + write_field_end end def write_type(type, value) case type when Types::BOOL - writeBool(value) + write_bool(value) when Types::BYTE - writeByte(value) + write_byte(value) when Types::DOUBLE - writeDouble(value) + write_double(value) when Types::I16 - writeI16(value) + write_i16(value) when Types::I32 - writeI32(value) + write_i32(value) when Types::I64 - writeI64(value) + write_i64(value) when Types::STRING - writeString(value) + write_string(value) when Types::STRUCT value.write(self) else @@ -145,19 +184,19 @@ module Thrift def read_type(type) case type when Types::BOOL - readBool + read_bool when Types::BYTE - readByte + read_byte when Types::DOUBLE - readDouble + read_double when Types::I16 - readI16 + read_i16 when Types::I32 - readI32 + read_i32 when Types::I64 - readI64 + read_i64 when Types::STRING - readString + read_string else raise NotImplementedError end @@ -167,50 +206,50 @@ module Thrift if type === Types::STOP nil elsif type === Types::BOOL - readBool() + read_bool() elsif type === Types::BYTE - readByte() + read_byte() elsif type === Types::I16 - readI16() + read_i16() elsif type === Types::I32 - readI32() + read_i32() elsif type === Types::I64 - readI64() + read_i64() elsif type === Types::DOUBLE - readDouble() + read_double() elsif type === Types::STRING - readString() + read_string() elsif type === Types::STRUCT - readStructBegin() + read_struct_begin() while true - name, type, id = readFieldBegin() + name, type, id = read_field_begin() if type === Types::STOP break else skip(type) - readFieldEnd() + read_field_end() end - readStructEnd() + read_struct_end() end elsif type === Types::MAP - ktype, vtype, size = readMapBegin() + ktype, vtype, size = read_map_begin() for i in 1..size skip(ktype) skip(vtype) end - readMapEnd() + read_map_end() elsif type === Types::SET - etype, size = readSetBegin() + etype, size = read_set_begin() for i in 1..size skip(etype) end - readSetEnd() + read_set_end() elsif type === Types::LIST - etype, size = readListBegin() + etype, size = read_list_begin() for i in 1..size skip(etype) end - readListEnd() + read_list_end() end end diff --git a/lib/rb/lib/thrift/protocol/binaryprotocol.rb b/lib/rb/lib/thrift/protocol/binaryprotocol.rb index 98323839..6a69f5e3 100644 --- a/lib/rb/lib/thrift/protocol/binaryprotocol.rb +++ b/lib/rb/lib/thrift/protocol/binaryprotocol.rb @@ -18,38 +18,38 @@ module Thrift super(trans) end - def writeMessageBegin(name, type, seqid) + def write_message_begin(name, type, seqid) writeI32(VERSION_1 | type) writeString(name) writeI32(seqid) end - def writeFieldBegin(name, type, id) + def write_field_begin(name, type, id) writeByte(type) writeI16(id) end - def writeFieldStop() + def write_field_stop() writeByte(Thrift::Types::STOP) end - def writeMapBegin(ktype, vtype, size) + def write_map_begin(ktype, vtype, size) writeByte(ktype) writeByte(vtype) writeI32(size) end - def writeListBegin(etype, size) + def write_list_begin(etype, size) writeByte(etype) writeI32(size) end - def writeSetBegin(etype, size) + def write_set_begin(etype, size) writeByte(etype) writeI32(size) end - def writeBool(bool) + def write_bool(bool) if (bool) writeByte(1) else @@ -57,34 +57,34 @@ module Thrift end end - def writeByte(byte) + def write_byte(byte) trans.write([byte].pack('n')[1..1]) end - def writeI16(i16) + def write_i16(i16) trans.write([i16].pack('n')) end - def writeI32(i32) + def write_i32(i32) trans.write([i32].pack('N')) end - def writeI64(i64) + def write_i64(i64) hi = i64 >> 32 lo = i64 & 0xffffffff trans.write([hi, lo].pack('N2')) end - def writeDouble(dub) + def write_double(dub) trans.write([dub].pack('G')) end - def writeString(str) + def write_string(str) writeI32(str.length) trans.write(str) end - def readMessageBegin() + def read_message_begin() version = readI32() if (version & VERSION_MASK != VERSION_1) raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Missing version identifier') @@ -95,7 +95,7 @@ module Thrift return name, type, seqid end - def readFieldBegin() + def read_field_begin() type = readByte() if (type === Types::STOP) return nil, type, 0 @@ -104,31 +104,31 @@ module Thrift return nil, type, id end - def readMapBegin() + def read_map_begin() ktype = readByte() vtype = readByte() size = readI32() return ktype, vtype, size end - def readListBegin() + def read_list_begin() etype = readByte() size = readI32() return etype, size end - def readSetBegin() + def read_set_begin() etype = readByte() size = readI32() return etype, size end - def readBool() + def read_bool() byte = readByte() return byte != 0 end - def readByte() + def read_byte() dat = trans.readAll(1) val = dat[0] if (val > 0x7f) @@ -137,7 +137,7 @@ module Thrift return val end - def readI16() + def read_i16() dat = trans.readAll(2) val, = dat.unpack('n') if (val > 0x7fff) @@ -146,7 +146,7 @@ module Thrift return val end - def readI32() + def read_i32() dat = trans.readAll(4) val, = dat.unpack('N') if (val > 0x7fffffff) @@ -155,7 +155,7 @@ module Thrift return val end - def readI64() + def read_i64() dat = trans.readAll(8) hi, lo = dat.unpack('N2') if (hi > 0x7fffffff) @@ -167,13 +167,13 @@ module Thrift end end - def readDouble() + def read_double() dat = trans.readAll(8) val, = dat.unpack('G') return val end - def readString() + def read_string() sz = readI32() dat = trans.readAll(sz) return dat diff --git a/lib/rb/lib/thrift/struct.rb b/lib/rb/lib/thrift/struct.rb index f1907a3a..ee3a3604 100644 --- a/lib/rb/lib/thrift/struct.rb +++ b/lib/rb/lib/thrift/struct.rb @@ -17,31 +17,31 @@ module Thrift end def read(iprot) - iprot.readStructBegin() + iprot.read_struct_begin() loop do - fname, ftype, fid = iprot.readFieldBegin() + fname, ftype, fid = iprot.read_field_begin() break if (ftype === Types::STOP) handle_message(iprot, fid, ftype) - iprot.readFieldEnd() + iprot.read_field_end() end - iprot.readStructEnd() + iprot.read_struct_end() end def write(oprot) - oprot.writeStructBegin(self.class.name) + oprot.write_struct_begin(self.class.name) each_field do |fid, type, name| if ((value = instance_variable_get("@#{name}")) != nil) if is_container? type - oprot.writeFieldBegin(name, type, fid) + oprot.write_field_begin(name, type, fid) write_container(oprot, value, struct_fields[fid]) - oprot.writeFieldEnd + oprot.write_field_end else oprot.write_field(name, type, fid, value) end end end - oprot.writeFieldStop() - oprot.writeStructEnd() + oprot.write_field_stop() + oprot.write_struct_end() end protected @@ -99,24 +99,24 @@ module Thrift def write_container(oprot, value, field = {}) if field[:type] == Types::MAP - oprot.writeMapBegin(field[:key][:type], field[:value][:type], value.size) + 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.writeMapEnd + oprot.write_map_end elsif field[:type] == Types::LIST - oprot.writeListBegin(field[:element][:type], value.size) + oprot.write_list_begin(field[:element][:type], value.size) value.each do |elem| write_data(oprot, elem, field[:element]) end - oprot.writeListEnd + oprot.write_list_end elsif field[:type] == Types::SET - oprot.writeSetBegin(field[:element][:type], value.size) + oprot.write_set_begin(field[:element][:type], value.size) value.each do |k, v| write_data(oprot, k, field[:element]) end - oprot.writeSetEnd + oprot.write_set_end else raise "Not a container type: #{field[:type]}" end diff --git a/lib/rb/lib/thrift/transport/ttransport.rb b/lib/rb/lib/thrift/transport/ttransport.rb index b2fa813f..dd015aee 100644 --- a/lib/rb/lib/thrift/transport/ttransport.rb +++ b/lib/rb/lib/thrift/transport/ttransport.rb @@ -29,7 +29,9 @@ end # TTransport is basically an abstract class, but isn't raising NotImplementedError # TODO: Think about if this is the right thing - Kevin Clark - 3/27/08 class TTransport - def is_open?; end + def open?; end + deprecate! :isOpen => :open? + deprecate! :is_open? => :open? def open; end @@ -49,22 +51,11 @@ class TTransport buff end + deprecate! :readAll => :read_all def write(buf); end def flush; end - - ################ - ## Deprecated - ################ - - def isOpen - is_open? - end - - def readAll(sz) - read_all sz - end end class TServerTransport