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 55e72b3..0b0d13e 100644
--- a/lib/rb/lib/thrift/client.rb
+++ b/lib/rb/lib/thrift/client.rb
@@ -7,22 +7,22 @@
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 @@
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 47fe723..553d8d4 100644
--- a/lib/rb/lib/thrift/protocol.rb
+++ b/lib/rb/lib/thrift/protocol.rb
@@ -35,106 +35,145 @@
@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 @@
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 @@
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 9832383..6a69f5e 100644
--- a/lib/rb/lib/thrift/protocol/binaryprotocol.rb
+++ b/lib/rb/lib/thrift/protocol/binaryprotocol.rb
@@ -18,38 +18,38 @@
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 @@
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 @@
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 @@
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 @@
return val
end
- def readI16()
+ def read_i16()
dat = trans.readAll(2)
val, = dat.unpack('n')
if (val > 0x7fff)
@@ -146,7 +146,7 @@
return val
end
- def readI32()
+ def read_i32()
dat = trans.readAll(4)
val, = dat.unpack('N')
if (val > 0x7fffffff)
@@ -155,7 +155,7 @@
return val
end
- def readI64()
+ def read_i64()
dat = trans.readAll(8)
hi, lo = dat.unpack('N2')
if (hi > 0x7fffffff)
@@ -167,13 +167,13 @@
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 f1907a3..ee3a360 100644
--- a/lib/rb/lib/thrift/struct.rb
+++ b/lib/rb/lib/thrift/struct.rb
@@ -17,31 +17,31 @@
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 @@
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 b2fa813..dd015ae 100644
--- a/lib/rb/lib/thrift/transport/ttransport.rb
+++ b/lib/rb/lib/thrift/transport/ttransport.rb
@@ -29,7 +29,9 @@
# 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 @@
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