end
class TProtocolFactory
- def getProtocol(trans); nil; end
+ def get_protocol(trans); nil; end
+ deprecate! :getProtocol => :get_protocol
end
end
def write_message_begin(name, type, seqid)
- writeI32(VERSION_1 | type)
- writeString(name)
- writeI32(seqid)
+ write_i32(VERSION_1 | type)
+ write_string(name)
+ write_i32(seqid)
end
def write_field_begin(name, type, id)
- writeByte(type)
- writeI16(id)
+ write_byte(type)
+ write_i16(id)
end
def write_field_stop()
- writeByte(Thrift::Types::STOP)
+ write_byte(Thrift::Types::STOP)
end
def write_map_begin(ktype, vtype, size)
- writeByte(ktype)
- writeByte(vtype)
- writeI32(size)
+ write_byte(ktype)
+ write_byte(vtype)
+ write_i32(size)
end
def write_list_begin(etype, size)
- writeByte(etype)
- writeI32(size)
+ write_byte(etype)
+ write_i32(size)
end
def write_set_begin(etype, size)
- writeByte(etype)
- writeI32(size)
+ write_byte(etype)
+ write_i32(size)
end
def write_bool(bool)
if (bool)
- writeByte(1)
+ write_byte(1)
else
- writeByte(0)
+ write_byte(0)
end
end
end
def write_string(str)
- writeI32(str.length)
+ write_i32(str.length)
trans.write(str)
end
def read_message_begin()
- version = readI32()
+ version = read_i32()
if (version & VERSION_MASK != VERSION_1)
raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Missing version identifier')
end
type = version & 0x000000ff
- name = readString()
- seqid = readI32()
+ name = read_string()
+ seqid = read_i32()
return name, type, seqid
end
def read_field_begin()
- type = readByte()
+ type = read_byte()
if (type === Types::STOP)
return nil, type, 0
end
- id = readI16()
+ id = read_i16()
return nil, type, id
end
def read_map_begin()
- ktype = readByte()
- vtype = readByte()
- size = readI32()
+ ktype = read_byte()
+ vtype = read_byte()
+ size = read_i32()
return ktype, vtype, size
end
def read_list_begin()
- etype = readByte()
- size = readI32()
+ etype = read_byte()
+ size = read_i32()
return etype, size
end
def read_set_begin()
- etype = readByte()
- size = readI32()
+ etype = read_byte()
+ size = read_i32()
return etype, size
end
def read_bool()
- byte = readByte()
+ byte = read_byte()
return byte != 0
end
def read_byte()
- dat = trans.readAll(1)
+ dat = trans.read_all(1)
val = dat[0]
if (val > 0x7f)
val = 0 - ((val - 1) ^ 0xff)
end
def read_i16()
- dat = trans.readAll(2)
+ dat = trans.read_all(2)
val, = dat.unpack('n')
if (val > 0x7fff)
val = 0 - ((val - 1) ^ 0xffff)
end
def read_i32()
- dat = trans.readAll(4)
+ dat = trans.read_all(4)
val, = dat.unpack('N')
if (val > 0x7fffffff)
val = 0 - ((val - 1) ^ 0xffffffff)
end
def read_i64()
- dat = trans.readAll(8)
+ dat = trans.read_all(8)
hi, lo = dat.unpack('N2')
if (hi > 0x7fffffff)
hi = hi ^ 0xffffffff
end
def read_double()
- dat = trans.readAll(8)
+ dat = trans.read_all(8)
val, = dat.unpack('G')
return val
end
def read_string()
- sz = readI32()
- dat = trans.readAll(sz)
+ sz = read_i32()
+ dat = trans.read_all(sz)
return dat
end
end
class TBinaryProtocolFactory < TProtocolFactory
- def getProtocol(trans)
+ def get_protocol(trans)
return TBinaryProtocol.new(trans)
end
end
response.start(200) do |head, out|
head["Content-Type"] = "application/x-thrift"
transport = TIOStreamTransport.new request.body, out
- protocol = @protocol_factory.getProtocol transport
+ protocol = @protocol_factory.get_protocol transport
@processor.process protocol, protocol
end
end
@serverTransport.listen()
while (true)
client = @serverTransport.accept()
- trans = @transportFactory.getTransport(client)
- prot = @protocolFactory.getProtocol(trans)
+ trans = @transportFactory.get_transport(client)
+ prot = @protocolFactory.get_protocol(trans)
begin
while (true)
@processor.process(prot, prot)
@serverTransport.listen()
while (true)
client = @serverTransport.accept()
- trans = @transportFactory.getTransport(client)
- prot = @protocolFactory.getProtocol(trans)
+ trans = @transportFactory.get_transport(client)
+ prot = @protocolFactory.get_protocol(trans)
Thread.new(prot, trans) do |p, t|
begin
while (true)
begin
while (true)
client = @serverTransport.accept()
- trans = @transportFactory.getTransport(client)
- prot = @protocolFactory.getProtocol(trans)
+ trans = @transportFactory.get_transport(client)
+ prot = @protocolFactory.get_protocol(trans)
begin
while (true)
@processor.process(prot, prot)
value = field[:class].new
value.read(iprot)
elsif field[:type] == Types::MAP
- key_type, val_type, size = iprot.readMapBegin
+ 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.readMapEnd
+ iprot.read_map_end
elsif field[:type] == Types::LIST
- e_type, size = iprot.readListBegin
+ e_type, size = iprot.read_list_begin
value = Array.new(size) do |n|
read_field(iprot, field_info(field[:element]))
end
- iprot.readListEnd
+ iprot.read_list_end
elsif field[:type] == Types::SET
- e_type, size = iprot.readSetBegin
+ e_type, size = iprot.read_set_begin
value = {}
size.times do
element = read_field(iprot, field_info(field[:element]))
value[element] = true
end
- iprot.readSetEnd
+ iprot.read_set_end
else
value = iprot.read_type(field[:type])
end
@outbuf = ""
end
- def isOpen; true end
+ def open?; true end
def read(sz); @inbuf.read sz end
def write(buf); @outbuf << buf end
def flush
@handle = nil
end
- def setHandle(handle)
+ def set_handle(handle)
@handle = handle
end
end
end
- def isOpen()
+ def open?()
return !@handle.nil?
end
if (@handle != nil)
sock = @handle.accept()
trans = TSocket.new()
- trans.setHandle(sock)
+ trans.set_handle(sock)
return trans
end
return nil
end
class TTransportFactory
- def getTransport(trans)
+ def get_transport(trans)
return trans
end
+ deprecate! :getTransport => :get_transport
end
class TBufferedTransport < TTransport
@wbuf = ''
end
- def isOpen()
- return @transport.isOpen()
+ def open?()
+ return @transport.open?()
end
def open()
end
class TBufferedTransportFactory < TTransportFactory
- def getTransport(transport)
+ def get_transport(transport)
return TBufferedTransport.new(transport)
end
end
private
def read_frame
- buf = @transport.readAll(4)
+ buf = @transport.read_all(4)
val = buf.unpack('N')
sz = val[0]
- @rbuf = @transport.readAll(sz)
+ @rbuf = @transport.read_all(sz)
end
end
class TFramedTransportFactory < TTransportFactory
- def getTransport(transport)
+ def get_transport(transport)
return TFramedTransport.new(transport)
end
end
@output = output
end
- def isOpen; true end
+ def open?; true end
def read(sz); @input.read(sz) end
def write(buf); @output.write(buf) end
end