Class: Thrift::CompactProtocol

Inherits:
BaseProtocol show all
Defined in:
lib/thrift/protocol/compact_protocol.rb

Defined Under Namespace

Classes: CompactTypes

Constant Summary collapse

PROTOCOL_ID = 
[0x82].pack('c').unpack('c').first
VERSION = 
1
VERSION_MASK = 
0x1f
TYPE_MASK = 
0xE0
TYPE_SHIFT_AMOUNT = 
5
TSTOP = 
["", Types::STOP, 0]

Instance Attribute Summary

Attributes inherited from BaseProtocol

#trans

Instance Method Summary collapse

Methods inherited from BaseProtocol

#native?, #read_field_end, #read_list_end, #read_map_end, #read_message_end, #read_set_end, #read_type, #skip, #write_field, #write_field_end, #write_list_end, #write_map_end, #write_message_end, #write_set_end, #write_type

Constructor Details

#initialize(transport) ⇒ CompactProtocol

Returns a new instance of CompactProtocol.



96
97
98
99
100
101
102
103
104
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 96

def initialize(transport)
  super(transport)

  @last_field = [0]
  @boolean_value = nil

  # Pre-allocated read buffer for read_double().
  @rbuf = Bytes.empty_byte_buffer(8)
end

Instance Method Details

#read_binary ⇒ Object 



343
344
345
346
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 343

def read_binary
  size = read_varint32()
  trans.read_all(size)
end

#read_bool ⇒ Object 



302
303
304
305
306
307
308
309
310
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 302

def read_bool
  unless @bool_value.nil?
    bv = @bool_value
    @bool_value = nil
    bv
  else
    read_byte() == CompactTypes::BOOLEAN_TRUE
  end
end

#read_byte ⇒ Object 



312
313
314
315
316
317
318
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 312

def read_byte
  val = trans.read_byte
  if (val > 0x7f)
    val = 0 - ((val - 1) ^ 0xff)
  end
  val
end

#read_double ⇒ Object 



332
333
334
335
336
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 332

def read_double
  trans.read_into_buffer(@rbuf, 8)
  val = @rbuf.reverse.unpack('G').first
  val
end

#read_field_begin ⇒ Object 



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 250

def read_field_begin
  type = read_byte()

  # if it's a stop, then we can return immediately, as the struct is over.
  if (type & 0x0f) == Types::STOP
    TSTOP
  else
    field_id = nil

    # mask off the 4 MSB of the type header. it could contain a field id delta.
    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.
      field_id = @last_field.pop + modifier
    end

    # if this happens to be a boolean field, the value is encoded in the type
    if CompactTypes.is_bool_type?(type)
      # save the boolean value in a special instance variable.
      @bool_value = (type & 0x0f) == CompactTypes::BOOLEAN_TRUE
    end

    # push the new field onto the field stack so we can keep the deltas going.
    @last_field.push(field_id)
    ["", CompactTypes.get_ttype(type & 0x0f), field_id]
  end
end

#read_i16 ⇒ Object 



320
321
322
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 320

def read_i16
  zig_zag_to_int(read_varint32())
end

#read_i32 ⇒ Object 



324
325
326
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 324

def read_i32
  zig_zag_to_int(read_varint32())
end

#read_i64 ⇒ Object 



328
329
330
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 328

def read_i64
  zig_zag_to_long(read_varint64())
end

#read_list_begin ⇒ Object 



288
289
290
291
292
293
294
295
296
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 288

def read_list_begin
  size_and_type = read_byte()
  size = (size_and_type >> 4) & 0x0f
  if size == 15
    size = read_varint32()
  end
  type = CompactTypes.get_ttype(size_and_type)
  [type, size]
end

#read_map_begin ⇒ Object 



282
283
284
285
286
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 282

def read_map_begin
  size = read_varint32()
  key_and_value_type = size == 0 ? 0 : read_byte()
  [CompactTypes.get_ttype(key_and_value_type >> 4), CompactTypes.get_ttype(key_and_value_type & 0xf), size]
end

#read_message_begin ⇒ Object 



222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 222

def read_message_begin
  protocol_id = read_byte()
  if protocol_id != PROTOCOL_ID
    raise ProtocolException.new("Expected protocol id #{PROTOCOL_ID} but got #{protocol_id}")
  end
  
  version_and_type = read_byte()
  version = version_and_type & VERSION_MASK
  if (version != VERSION)
    raise ProtocolException.new("Expected version #{VERSION} but got #{version}");
  end
  
  type = (version_and_type >> TYPE_SHIFT_AMOUNT) & 0x03
  seqid = read_varint32()
  messageName = read_string()
  [messageName, type, seqid]
end

#read_set_begin ⇒ Object 



298
299
300
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 298

def read_set_begin
  read_list_begin
end

#read_string ⇒ Object 



338
339
340
341
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 338

def read_string
  buffer = read_binary
  Bytes.convert_to_string(buffer)
end

#read_struct_begin ⇒ Object 



240
241
242
243
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 240

def read_struct_begin
  @last_field.push(0)
  ""
end

#read_struct_end ⇒ Object 



245
246
247
248
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 245

def read_struct_end
  @last_field.pop()
  nil
end

#write_binary(buf) ⇒ Object 



217
218
219
220
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 217

def write_binary(buf)
  write_varint32(buf.bytesize)
  @trans.write(buf)
end

#write_bool(bool) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 180

def write_bool(bool)
  type = bool ? CompactTypes::BOOLEAN_TRUE : CompactTypes::BOOLEAN_FALSE
  unless @boolean_field.nil?
    # we haven't written the field header yet
    write_field_begin_internal(@boolean_field.first, @boolean_field.last, type)
    @boolean_field = nil
  else
    # we're not part of a field, so just write the value.
    write_byte(type)
  end
end

#write_byte(byte) ⇒ Object 



192
193
194
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 192

def write_byte(byte)
  @trans.write([byte].pack('c'))
end

#write_double(dub) ⇒ Object 



208
209
210
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 208

def write_double(dub)
  @trans.write([dub].pack("G").reverse)
end

#write_field_begin(name, type, id) ⇒ Object 



124
125
126
127
128
129
130
131
132
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 124

def write_field_begin(name, type, id)
  if type == Types::BOOL
    # we want to possibly include the value, so we'll wait.
    @boolean_field = [type, id]
  else
    write_field_begin_internal(type, id)
  end
  nil
end

#write_field_begin_internal(type, id, type_override = nil) ⇒ Object

The workhorse of writeFieldBegin. It has the option of doing a ‘type override’ of the type header. This is used specifically in the boolean field case.



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 139

def write_field_begin_internal(type, id, type_override=nil)
  last_id = @last_field.pop
  
  # if there's a type override, use that.
  typeToWrite = type_override || CompactTypes.get_compact_type(type)

  # check if we can use delta encoding for the field id
  if id > last_id && id - last_id <= 15
    # write them together
    write_byte((id - last_id) << 4 | typeToWrite)
  else
    # write them separate
    write_byte(typeToWrite)
    write_i16(id)
  end

  @last_field.push(id)
  nil
end

#write_field_stop ⇒ Object 



159
160
161
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 159

def write_field_stop
  write_byte(Types::STOP)
end

#write_i16(i16) ⇒ Object 



196
197
198
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 196

def write_i16(i16)
  write_varint32(int_to_zig_zag(i16))
end

#write_i32(i32) ⇒ Object 



200
201
202
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 200

def write_i32(i32)
  write_varint32(int_to_zig_zag(i32))
end

#write_i64(i64) ⇒ Object 



204
205
206
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 204

def write_i64(i64)
  write_varint64(long_to_zig_zag(i64))
end

#write_list_begin(etype, size) ⇒ Object 



172
173
174
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 172

def write_list_begin(etype, size)
  write_collection_begin(etype, size)
end

#write_map_begin(ktype, vtype, size) ⇒ Object 



163
164
165
166
167
168
169
170
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 163

def write_map_begin(ktype, vtype, size)
  if (size == 0)
    write_byte(0)
  else
    write_varint32(size)
    write_byte(CompactTypes.get_compact_type(ktype) << 4 | CompactTypes.get_compact_type(vtype))
  end
end

#write_message_begin(name, type, seqid) ⇒ Object 



106
107
108
109
110
111
112
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 106

def write_message_begin(name, type, seqid)
  write_byte(PROTOCOL_ID)
  write_byte((VERSION & VERSION_MASK) | ((type << TYPE_SHIFT_AMOUNT) & TYPE_MASK))
  write_varint32(seqid)
  write_string(name)
  nil
end

#write_set_begin(etype, size) ⇒ Object 



176
177
178
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 176

def write_set_begin(etype, size)
  write_collection_begin(etype, size);
end

#write_string(str) ⇒ Object 



212
213
214
215
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 212

def write_string(str)
  buf = Bytes.convert_to_utf8_byte_buffer(str)
  write_binary(buf)
end

#write_struct_begin(name) ⇒ Object 



114
115
116
117
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 114

def write_struct_begin(name)
  @last_field.push(0)
  nil
end

#write_struct_end ⇒ Object 



119
120
121
122
 
# File 'lib/thrift/protocol/compact_protocol.rb', line 119

def write_struct_end
  @last_field.pop
  nil
end