Class: Thrift::JsonProtocol

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

Constant Summary collapse

@@kJSONObjectStart = 
'{'
@@kJSONObjectEnd = 
'}'
@@kJSONArrayStart = 
'['
@@kJSONArrayEnd = 
']'
@@kJSONNewline = 
'\n'
@@kJSONBackslash = 
'\\'
@@kJSONStringDelimiter = 
'"'
@@kThriftVersion1 = 
1
@@kThriftNan = 
"NaN"
@@kThriftInfinity = 
"Infinity"
@@kThriftNegativeInfinity = 
"-Infinity"

Instance Attribute Summary

Attributes inherited from BaseProtocol

#trans

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from BaseProtocol

#native?, #read_type, #skip, #write_field, #write_type

Constructor Details

#initialize(trans) ⇒ JsonProtocol

Returns a new instance of JsonProtocol.



153
154
155
156
157
158
 
# File 'lib/thrift/protocol/json_protocol.rb', line 153

def initialize(trans)
  super(trans)
  @context = JSONContext.new
  @contexts = Array.new
  @reader = LookaheadReader.new(trans)
end

Class Method Details

.read_syntax_char(reader, ch) ⇒ Object

Read 1 character from the trans and verify that it is the expected character ch. Throw a protocol exception if it is not.



225
226
227
228
229
230
 
# File 'lib/thrift/protocol/json_protocol.rb', line 225

def self.read_syntax_char(reader, ch)
  ch2 = reader.read
  if (ch2 != ch)
    raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected \'#{ch}\' got \'#{ch2}\'.")
  end
end

Instance Method Details

#get_type_id_for_type_name(name) ⇒ Object 



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/thrift/protocol/json_protocol.rb', line 189

def get_type_id_for_type_name(name)
  if (name == "tf")
    result = Types::BOOL
  elsif (name == "i8")
    result = Types::BYTE
  elsif (name == "i16")
    result = Types::I16
  elsif (name == "i32")
    result = Types::I32
  elsif (name == "i64")
    result = Types::I64
  elsif (name == "dbl")
    result = Types::DOUBLE
  elsif (name == "str")
    result = Types::STRING
  elsif (name == "rec")
    result = Types::STRUCT
  elsif (name == "map")
    result = Types::MAP
  elsif (name == "set")
    result = Types::SET
  elsif (name == "lst")
    result = Types::LIST
  else
    result = Types::STOP
  end
  if (result == Types::STOP)
    raise NotImplementedError
  end
  return result
end

#get_type_name_for_type_id(id) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/thrift/protocol/json_protocol.rb', line 160

def get_type_name_for_type_id(id)
  case id
  when Types::BOOL
    "tf"
  when Types::BYTE
    "i8"
  when Types::I16
    "i16"
  when Types::I32
    "i32"
  when Types::I64
    "i64"
  when Types::DOUBLE
    "dbl"
  when Types::STRING
    "str"
  when Types::STRUCT
    "rec"
  when Types::MAP
    "map"
  when Types::SET
    "set"
  when Types::LIST
    "lst"
  else
    raise NotImplementedError
  end
end

#is_json_numeric(ch) ⇒ Object

Return true if the character ch is in [-+0-9.Ee]; false otherwise



233
234
235
236
237
238
239
240
 
# File 'lib/thrift/protocol/json_protocol.rb', line 233

def is_json_numeric(ch)
  case ch
  when '+', '-', '.', '0' .. '9', 'E', "e"
    return true
  else
    return false
  end
end

#pop_context ⇒ Object 



247
248
249
 
# File 'lib/thrift/protocol/json_protocol.rb', line 247

def pop_context
  @context = @contexts.pop
end

#push_context(context) ⇒ Object 



242
243
244
245
 
# File 'lib/thrift/protocol/json_protocol.rb', line 242

def push_context(context)
  @contexts.push(@context)
  @context = context
end

#read_binary ⇒ Object 



768
769
770
 
# File 'lib/thrift/protocol/json_protocol.rb', line 768

def read_binary
  read_json_base64
end

#read_bool ⇒ Object 



739
740
741
742
 
# File 'lib/thrift/protocol/json_protocol.rb', line 739

def read_bool
  byte = read_byte
  byte != 0
end

#read_byte ⇒ Object 



744
745
746
 
# File 'lib/thrift/protocol/json_protocol.rb', line 744

def read_byte
  read_json_integer
end

#read_double ⇒ Object 



760
761
762
 
# File 'lib/thrift/protocol/json_protocol.rb', line 760

def read_double
  read_json_double
end

#read_field_begin ⇒ Object 



690
691
692
693
694
695
696
697
698
699
700
701
 
# File 'lib/thrift/protocol/json_protocol.rb', line 690

def read_field_begin
  # Check if we hit the end of the list
  ch = @reader.peek
  if (ch == @@kJSONObjectEnd)
    field_type = Types::STOP
  else
    field_id = read_json_integer
    read_json_object_start
    field_type = get_type_id_for_type_name(read_json_string)
  end
  [nil, field_type, field_id]
end

#read_field_end ⇒ Object 



703
704
705
 
# File 'lib/thrift/protocol/json_protocol.rb', line 703

def read_field_end
  read_json_object_end
end

#read_i16 ⇒ Object 



748
749
750
 
# File 'lib/thrift/protocol/json_protocol.rb', line 748

def read_i16
  read_json_integer
end

#read_i32 ⇒ Object 



752
753
754
 
# File 'lib/thrift/protocol/json_protocol.rb', line 752

def read_i32
  read_json_integer
end

#read_i64 ⇒ Object 



756
757
758
 
# File 'lib/thrift/protocol/json_protocol.rb', line 756

def read_i64
  read_json_integer
end

#read_json_array_end ⇒ Object 



657
658
659
660
661
 
# File 'lib/thrift/protocol/json_protocol.rb', line 657

def read_json_array_end
  read_json_syntax_char(@@kJSONArrayEnd)
  pop_context
  nil
end

#read_json_array_start ⇒ Object 



650
651
652
653
654
655
 
# File 'lib/thrift/protocol/json_protocol.rb', line 650

def read_json_array_start
  @context.read(@reader)
  read_json_syntax_char(@@kJSONArrayStart)
  push_context(JSONListContext.new)
  nil
end

#read_json_base64 ⇒ Object

Reads a block of base64 characters, decoding it, and returns via str



549
550
551
552
553
554
555
556
557
558
559
 
# File 'lib/thrift/protocol/json_protocol.rb', line 549

def read_json_base64
  str = read_json_string
  m = str.length % 4
  if m != 0
    # Add missing padding
    (4 - m).times do
      str += '='
    end
  end
  Base64.strict_decode64(str)
end

#read_json_double ⇒ Object

Reads a JSON number or string and interprets it as a double.



599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
 
# File 'lib/thrift/protocol/json_protocol.rb', line 599

def read_json_double
  @context.read(@reader)
  num = 0
  if (@reader.peek == @@kJSONStringDelimiter)
    str = read_json_string(true)
    # Check for NaN, Infinity and -Infinity
    if (str == @@kThriftNan)
      num = (+1.0/0.0)/(+1.0/0.0)
    elsif (str == @@kThriftInfinity)
      num = +1.0/0.0
    elsif (str == @@kThriftNegativeInfinity)
      num = -1.0/0.0
    else
      if (!@context.escapeNum)
        # Raise exception -- we should not be in a string in this case
        raise ProtocolException.new(ProtocolException::INVALID_DATA, "Numeric data unexpectedly quoted")
      end
      begin
        num = Float(str)
      rescue
        raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
      end
    end
  else
    if (@context.escapeNum)
      # This will throw - we should have had a quote if escapeNum == true
      read_json_syntax_char(@@kJSONStringDelimiter)
    end
    str = read_json_numeric_chars
    begin
      num = Float(str)
    rescue
      raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
    end
  end
  return num
end

#read_json_escape_char ⇒ Object

Decodes the four hex parts of a JSON escaped string character and returns the character via out.

Note - this only supports Unicode characters in the BMP (U+0000 to U+FFFF); characters above the BMP are encoded as two escape sequences (surrogate pairs), which is not yet implemented



495
496
497
498
499
500
501
502
503
504
505
 
# File 'lib/thrift/protocol/json_protocol.rb', line 495

def read_json_escape_char
  str = @reader.read
  str += @reader.read
  str += @reader.read
  str += @reader.read
  if RUBY_VERSION >= '1.9'
    str.hex.chr(Encoding::UTF_8)
  else
    str.hex.chr
  end
end

#read_json_integer ⇒ Object

Reads a sequence of characters and assembles them into a number, returning them via num



578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
 
# File 'lib/thrift/protocol/json_protocol.rb', line 578

def read_json_integer
  @context.read(@reader)
  if (@context.escapeNum)
    read_json_syntax_char(@@kJSONStringDelimiter)
  end
  str = read_json_numeric_chars

  begin
    num = Integer(str);
  rescue
    raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
  end

  if (@context.escapeNum)
    read_json_syntax_char(@@kJSONStringDelimiter)
  end

  return num
end

#read_json_numeric_chars ⇒ Object

Reads a sequence of characters, stopping at the first one that is not a valid JSON numeric character.



563
564
565
566
567
568
569
570
571
572
573
574
 
# File 'lib/thrift/protocol/json_protocol.rb', line 563

def read_json_numeric_chars
  str = ""
  while (true)
    ch = @reader.peek
    if (!is_json_numeric(ch))
      break;
    end
    ch = @reader.read
    str += ch
  end
  return str
end

#read_json_object_end ⇒ Object 



644
645
646
647
648
 
# File 'lib/thrift/protocol/json_protocol.rb', line 644

def read_json_object_end
  read_json_syntax_char(@@kJSONObjectEnd)
  pop_context
  nil
end

#read_json_object_start ⇒ Object 



637
638
639
640
641
642
 
# File 'lib/thrift/protocol/json_protocol.rb', line 637

def read_json_object_start
  @context.read(@reader)
  read_json_syntax_char(@@kJSONObjectStart)
  push_context(JSONPairContext.new)
  nil
end

#read_json_string(skipContext = false) ⇒ Object

Decodes a JSON string, including unescaping, and returns the string via str



508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
 
# File 'lib/thrift/protocol/json_protocol.rb', line 508

def read_json_string(skipContext = false)
  # This string's characters must match up with the elements in escape_char_vals.
  # I don't have '/' on this list even though it appears on www.json.org --
  # it is not in the RFC -> it is. See RFC 4627
  escape_chars = "\"\\/bfnrt"

  # The elements of this array must match up with the sequence of characters in
  # escape_chars
  escape_char_vals = [
    "\"", "\\", "\/", "\b", "\f", "\n", "\r", "\t",
  ]

  if !skipContext
    @context.read(@reader)
  end
  read_json_syntax_char(@@kJSONStringDelimiter)
  ch = ""
  str = ""
  while (true)
    ch = @reader.read
    if (ch == @@kJSONStringDelimiter)
      break
    end
    if (ch == @@kJSONBackslash)
      ch = @reader.read
      if (ch == 'u')
        ch = read_json_escape_char
      else
        pos = escape_chars.index(ch);
        if (pos.nil?) # not found
          raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected control char, got \'#{ch}\'.")
        end
        ch = escape_char_vals[pos]
      end
    end
    str += ch
  end
  return str
end

#read_json_syntax_char(ch) ⇒ Object

Reads 1 byte and verifies that it matches ch.



485
486
487
 
# File 'lib/thrift/protocol/json_protocol.rb', line 485

def read_json_syntax_char(ch)
  JsonProtocol::read_syntax_char(@reader, ch)
end

#read_list_begin ⇒ Object 



721
722
723
724
 
# File 'lib/thrift/protocol/json_protocol.rb', line 721

def read_list_begin
  read_json_array_start
  [get_type_id_for_type_name(read_json_string), read_json_integer]
end

#read_list_end ⇒ Object 



726
727
728
 
# File 'lib/thrift/protocol/json_protocol.rb', line 726

def read_list_end
  read_json_array_end
end

#read_map_begin ⇒ Object 



707
708
709
710
711
712
713
714
 
# File 'lib/thrift/protocol/json_protocol.rb', line 707

def read_map_begin
  read_json_array_start
  key_type = get_type_id_for_type_name(read_json_string)
  val_type = get_type_id_for_type_name(read_json_string)
  size = read_json_integer
  read_json_object_start
  [key_type, val_type, size]
end

#read_map_end ⇒ Object 



716
717
718
719
 
# File 'lib/thrift/protocol/json_protocol.rb', line 716

def read_map_end
  read_json_object_end
  read_json_array_end
end

#read_message_begin ⇒ Object 



663
664
665
666
667
668
669
670
671
672
673
 
# File 'lib/thrift/protocol/json_protocol.rb', line 663

def read_message_begin
  read_json_array_start
  version = read_json_integer
  if (version != @@kThriftVersion1)
    raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Message contained bad version.')
  end
  name = read_json_string
  message_type = read_json_integer
  seqid = read_json_integer
  [name, message_type, seqid]
end

#read_message_end ⇒ Object 



675
676
677
678
 
# File 'lib/thrift/protocol/json_protocol.rb', line 675

def read_message_end
  read_json_array_end
  nil
end

#read_set_begin ⇒ Object 



730
731
732
733
 
# File 'lib/thrift/protocol/json_protocol.rb', line 730

def read_set_begin
  read_json_array_start
  [get_type_id_for_type_name(read_json_string), read_json_integer]
end

#read_set_end ⇒ Object 



735
736
737
 
# File 'lib/thrift/protocol/json_protocol.rb', line 735

def read_set_end
  read_json_array_end
end

#read_string ⇒ Object 



764
765
766
 
# File 'lib/thrift/protocol/json_protocol.rb', line 764

def read_string
  read_json_string
end

#read_struct_begin ⇒ Object 



680
681
682
683
 
# File 'lib/thrift/protocol/json_protocol.rb', line 680

def read_struct_begin
  read_json_object_start
  nil
end

#read_struct_end ⇒ Object 



685
686
687
688
 
# File 'lib/thrift/protocol/json_protocol.rb', line 685

def read_struct_end
  read_json_object_end
  nil
end

#to_s ⇒ Object 



772
773
774
 
# File 'lib/thrift/protocol/json_protocol.rb', line 772

def to_s
  "json(#{super.to_s})"
end

#write_binary(str) ⇒ Object 



476
477
478
 
# File 'lib/thrift/protocol/json_protocol.rb', line 476

def write_binary(str)
  write_json_base64(str)
end

#write_bool(bool) ⇒ Object 



448
449
450
 
# File 'lib/thrift/protocol/json_protocol.rb', line 448

def write_bool(bool)
  write_json_integer(bool ? 1 : 0)
end

#write_byte(byte) ⇒ Object 



452
453
454
 
# File 'lib/thrift/protocol/json_protocol.rb', line 452

def write_byte(byte)
  write_json_integer(byte)
end

#write_double(dub) ⇒ Object 



468
469
470
 
# File 'lib/thrift/protocol/json_protocol.rb', line 468

def write_double(dub)
  write_json_double(dub)
end

#write_field_begin(name, type, id) ⇒ Object 



403
404
405
406
407
 
# File 'lib/thrift/protocol/json_protocol.rb', line 403

def write_field_begin(name, type, id)
  write_json_integer(id)
  write_json_object_start
  write_json_string(get_type_name_for_type_id(type))
end

#write_field_end ⇒ Object 



409
410
411
 
# File 'lib/thrift/protocol/json_protocol.rb', line 409

def write_field_end
  write_json_object_end
end

#write_field_stop ⇒ Object 



413
 
# File 'lib/thrift/protocol/json_protocol.rb', line 413

def write_field_stop; nil; end

#write_i16(i16) ⇒ Object 



456
457
458
 
# File 'lib/thrift/protocol/json_protocol.rb', line 456

def write_i16(i16)
  write_json_integer(i16)
end

#write_i32(i32) ⇒ Object 



460
461
462
 
# File 'lib/thrift/protocol/json_protocol.rb', line 460

def write_i32(i32)
  write_json_integer(i32)
end

#write_i64(i64) ⇒ Object 



464
465
466
 
# File 'lib/thrift/protocol/json_protocol.rb', line 464

def write_i64(i64)
  write_json_integer(i64)
end

#write_json_array_end ⇒ Object 



378
379
380
381
 
# File 'lib/thrift/protocol/json_protocol.rb', line 378

def write_json_array_end
  pop_context
  trans.write(@@kJSONArrayEnd)
end

#write_json_array_start ⇒ Object 



372
373
374
375
376
 
# File 'lib/thrift/protocol/json_protocol.rb', line 372

def write_json_array_start
  @context.write(trans)
  trans.write(@@kJSONArrayStart)
  push_context(JSONListContext.new);
end

#write_json_base64(str) ⇒ Object

Write out the contents of the string as JSON string, base64-encoding the string’s contents, and escaping as appropriate



311
312
313
314
315
316
 
# File 'lib/thrift/protocol/json_protocol.rb', line 311

def write_json_base64(str)
  @context.write(trans)
  trans.write(@@kJSONStringDelimiter)
  trans.write(Base64.strict_encode64(str))
  trans.write(@@kJSONStringDelimiter)
end

#write_json_char(ch) ⇒ Object

Write the character ch as part of a JSON string, escaping as appropriate.



262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'lib/thrift/protocol/json_protocol.rb', line 262

def write_json_char(ch)
  # This table describes the handling for the first 0x30 characters
  # 0 : escape using "\u00xx" notation
  # 1 : just output index
  # <other> : escape using "\<other>" notation
  kJSONCharTable = [
      # 0 1 2 3 4 5 6 7 8 9 A B C D E F
      0, 0, 0, 0, 0, 0, 0, 0,'b','t','n', 0,'f','r', 0, 0, # 0
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 1
      1, 1,'"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, # 2
  ]

  ch_value = ch[0]
  if (ch_value.kind_of? String)
    ch_value = ch.bytes.first
  end
  if (ch_value >= 0x30)
    if (ch == @@kJSONBackslash) # Only special character >= 0x30 is '\'
      trans.write(@@kJSONBackslash)
      trans.write(@@kJSONBackslash)
    else
      trans.write(ch)
    end
  else
    outCh = kJSONCharTable[ch_value];
    # Check if regular character, backslash escaped, or JSON escaped
    if outCh.kind_of? String
      trans.write(@@kJSONBackslash)
      trans.write(outCh)
    elsif outCh == 1
      trans.write(ch)
    else
      write_json_escape_char(ch)
    end
  end
end

#write_json_double(num) ⇒ Object

Convert the given double to a JSON string, which is either the number, “NaN” or “Infinity” or “-Infinity”.



334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'lib/thrift/protocol/json_protocol.rb', line 334

def write_json_double(num)
  @context.write(trans)
  # Normalize output of thrift::to_string for NaNs and Infinities
  special = false;
  if (num.nan?)
    special = true;
    val = @@kThriftNan;
  elsif (num.infinite?)
    special = true;
    val = @@kThriftInfinity;
    if (num < 0.0)
      val = @@kThriftNegativeInfinity;
    end
  else
    val = num.to_s
  end

  escapeNum = special || @context.escapeNum
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
  trans.write(val)
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
end

#write_json_escape_char(ch) ⇒ Object

Write the character ch as a JSON escape sequence (“u00xx”)



252
253
254
255
256
257
258
259
 
# File 'lib/thrift/protocol/json_protocol.rb', line 252

def write_json_escape_char(ch)
  trans.write('\\u')
  ch_value = ch[0]
  if (ch_value.kind_of? String)
    ch_value = ch.bytes.first
  end
  trans.write(ch_value.to_s(16).rjust(4,'0'))
end

#write_json_integer(num) ⇒ Object

Convert the given integer type to a JSON number, or a string if the context requires it (eg: key in a map pair).



320
321
322
323
324
325
326
327
328
329
330
 
# File 'lib/thrift/protocol/json_protocol.rb', line 320

def write_json_integer(num)
  @context.write(trans)
  escapeNum = @context.escapeNum
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
  trans.write(num.to_s);
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
end

#write_json_object_end ⇒ Object 



367
368
369
370
 
# File 'lib/thrift/protocol/json_protocol.rb', line 367

def write_json_object_end
  pop_context
  trans.write(@@kJSONObjectEnd)
end

#write_json_object_start ⇒ Object 



361
362
363
364
365
 
# File 'lib/thrift/protocol/json_protocol.rb', line 361

def write_json_object_start
  @context.write(trans)
  trans.write(@@kJSONObjectStart)
  push_context(JSONPairContext.new);
end

#write_json_string(str) ⇒ Object

Write out the contents of the string str as a JSON string, escaping characters as appropriate.



300
301
302
303
304
305
306
307
 
# File 'lib/thrift/protocol/json_protocol.rb', line 300

def write_json_string(str)
  @context.write(trans)
  trans.write(@@kJSONStringDelimiter)
  str.split('').each do |ch|
    write_json_char(ch)
  end
  trans.write(@@kJSONStringDelimiter)
end

#write_list_begin(etype, size) ⇒ Object 



428
429
430
431
432
 
# File 'lib/thrift/protocol/json_protocol.rb', line 428

def write_list_begin(etype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(etype))
  write_json_integer(size)
end

#write_list_end ⇒ Object 



434
435
436
 
# File 'lib/thrift/protocol/json_protocol.rb', line 434

def write_list_end
  write_json_array_end
end

#write_map_begin(ktype, vtype, size) ⇒ Object 



415
416
417
418
419
420
421
 
# File 'lib/thrift/protocol/json_protocol.rb', line 415

def write_map_begin(ktype, vtype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(ktype))
  write_json_string(get_type_name_for_type_id(vtype))
  write_json_integer(size)
  write_json_object_start
end

#write_map_end ⇒ Object 



423
424
425
426
 
# File 'lib/thrift/protocol/json_protocol.rb', line 423

def write_map_end
  write_json_object_end
  write_json_array_end
end

#write_message_begin(name, type, seqid) ⇒ Object 



383
384
385
386
387
388
389
 
# File 'lib/thrift/protocol/json_protocol.rb', line 383

def write_message_begin(name, type, seqid)
  write_json_array_start
  write_json_integer(@@kThriftVersion1)
  write_json_string(name)
  write_json_integer(type)
  write_json_integer(seqid)
end

#write_message_end ⇒ Object 



391
392
393
 
# File 'lib/thrift/protocol/json_protocol.rb', line 391

def write_message_end
  write_json_array_end
end

#write_set_begin(etype, size) ⇒ Object 



438
439
440
441
442
 
# File 'lib/thrift/protocol/json_protocol.rb', line 438

def write_set_begin(etype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(etype))
  write_json_integer(size)
end

#write_set_end ⇒ Object 



444
445
446
 
# File 'lib/thrift/protocol/json_protocol.rb', line 444

def write_set_end
  write_json_array_end
end

#write_string(str) ⇒ Object 



472
473
474
 
# File 'lib/thrift/protocol/json_protocol.rb', line 472

def write_string(str)
  write_json_string(str)
end

#write_struct_begin(name) ⇒ Object 



395
396
397
 
# File 'lib/thrift/protocol/json_protocol.rb', line 395

def write_struct_begin(name)
  write_json_object_start
end

#write_struct_end ⇒ Object 



399
400
401
 
# File 'lib/thrift/protocol/json_protocol.rb', line 399

def write_struct_end
  write_json_object_end
end